Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

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

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.20;

import "./SupraErrors.sol";
import "./Smr.sol";
import {ISupraSValueFeed} from "./ISupraSValueFeed.sol";
import {ISupraSValueFeedVerifier} from "./ISupraSValueFeedVerifier.sol";
import {Ownable2StepUpgradeable} from
"../lib/openzeppelin-contracts-upgradeable/contracts/access/Ownable2StepUpgradeable.sol";
import {UUPSUpgradeable} from "../lib/openzeppelin-contracts/contracts/proxy/utils/UUPSUpgradeable.sol";

/// @title Supra Oracle Pull Model Contract
/// @notice This contract verifies SMR transactions and returns the price data to the caller
/// @notice The contract does not make assumptions about its owner, but its recommended to be a multisig wallet
contract SupraOraclePull is Ownable2StepUpgradeable, UUPSUpgradeable {
    /// @notice Push Based Supra Svalue Feed Storage contract
    /// @dev This is used to check if a pair is stale
    ISupraSValueFeed internal supraSValueFeedStorage;
    ISupraSValueFeedVerifier internal supraSValueVerifier;

    event SupraSValueFeedUpdated(address supraSValueFeedStorage);
    event SupraSValueVerifierUpdated(address supraSValueVerifier);
    event PriceUpdate(uint256[] pairs,uint256[] prices,uint256[] updateMask);

    /// @notice Proof for verifying and extracting pairs from SMR transactions
    struct OracleProof {
        // list of SMR votes
        Smr.Vote[] votes;
        // List of BLS signatures of the votes
        // votes[i] is verified by sigs[i]
        uint256[2][] sigs;
        // List of SMR batches
        Smr.MinBatch[] smrBatches;
        // List of SMR transactions
        Smr.MinTxn[] smrTxns;
        // Abi Encoded Signed Coherent Clusters containing the pairs
        bytes[] clustersRaw;
        // Index of each batch corresponding vote
        // votes[voteIndexes[i]] should correspond to vote of smrBatches[i]
        uint256[] batchToVote;
        // Index of each transaction's corresponding batch
        // smrBatches[txnToBatch[i]] should correspond to batch of smrTxns[i]
        uint256[] txnToBatch;
        // Index to each cluster's corresponding transaction
        // txn = smrTxns[clusterToTxn[i]] should correspond to txn of clustersRaw[i]
        uint256[] clusterToTxn;
        // Index of the cluster's hash in its corresponding transaction
        // txn.clusterHashes[clusterToHash[i]] should correspond to the hash of clustersRaw[i]
        uint256[] clusterToHash;
        // whether to include n'th pair or not
        // n is the position of the pair considering all pairs in all clusters
        // i.e consider 2 clusters with 2 pairs each
        // n for clusters[0].pairs[0] = 0
        // n for clusters[0].pairs[1] = 1
        // n for clusters[1].pairs[0] = 2
        // n for clusters[1].pairs[1] = 3
        bool[] pairMask;
        // Total number of pairs to return
        // i.e number of true values in pairMasks
        // This is for opts
        uint256 pairCnt;
    }

    /// @notice Verified price data
    struct PriceData {
        // List of pairs
        uint256[] pairs;
        // List of prices
        // prices[i] is the price of pairs[i]
        uint256[] prices;
        // List of decimals
        // decimals[i] is the decimals of pairs[i]
        uint256[] decimals;

    }

    /// @notice Helper function for upgradability
    /// @dev While upgrading using UUPS proxy interface, when we call upgradeTo(address) function
    /// @dev we need to check that only owner can upgrade
    /// @param newImplementation address of the new implementation contract

    function _authorizeUpgrade(address newImplementation) internal virtual override onlyOwner {}

    function initialize(address _supraSValueFeedStorage, address _supraSValueVerifier) public initializer {
        Ownable2StepUpgradeable.__Ownable2Step_init();
        updateSupraSValueFeedInitLevel(ISupraSValueFeed(_supraSValueFeedStorage));
        updateSupraSValueVerifierInitLevel(ISupraSValueFeedVerifier(_supraSValueVerifier));
    }

    /// @notice Verify Oracle Pairs
    /// @dev throws error if proof is invalid
    /// @dev Stale price data is marked
    /// @param _bytesProof The oracle proof to extract the pairs from
    function verifyOracleProof(bytes calldata _bytesProof) external returns (PriceData memory) {

        OracleProof memory proof = abi.decode(_bytesProof, (OracleProof));
        requireVotesVerified(proof.votes, proof.sigs);
        requireBatchesVerified(proof.votes, proof.smrBatches, proof.batchToVote);

        Smr.MinTxn[] memory smrTxns = proof.smrTxns;
        requireTxnsVerfified(proof.smrBatches, smrTxns, proof.txnToBatch);

        bytes[] memory clusters = proof.clustersRaw;
        uint256[] memory clusterToTxn = proof.clusterToTxn;
        uint256[] memory clusterToHash = proof.clusterToHash;
        uint256[] memory updateMask= new uint256[](proof.pairCnt);

        PriceData memory priceData = PriceData(
            new uint256[](proof.pairCnt),
            new uint256[](proof.pairCnt),
            new uint256[](proof.pairCnt)
        );

        uint256 pair = 0;
        uint256 flaggedPairs = 0;

        for (uint256 i = 0; i < clusters.length; ++i) {
            bytes32 clusterHash = keccak256(clusters[i]);
            if (smrTxns[clusterToTxn[i]].clusterHashes[clusterToHash[i]] != clusterHash) {
                revert ClusterNotVerified();
            }

            Smr.SignedCoherentCluster memory scc = abi.decode(clusters[i], (Smr.SignedCoherentCluster));
            for (uint256 j = 0; j < scc.cc.pair.length; ++j) {
                pair += 1;
                if (!proof.pairMask[pair - 1]) {
                    continue;
                }
                priceData.pairs[flaggedPairs] = scc.cc.pair[j];

                priceData.decimals[flaggedPairs] = scc.cc.decimals[j];

                if(scc.cc.timestamp[j] > supraSValueFeedStorage.getTimestamp(scc.cc.pair[j])){
                    packData(scc.cc.pair[j],scc.round,scc.cc.decimals[j],scc.cc.timestamp[j],scc.cc.prices[j]);
                    priceData.prices[flaggedPairs] =scc.cc.prices[j];
                    updateMask[flaggedPairs]=1;
                }
                else if(scc.cc.timestamp[j] < supraSValueFeedStorage.getTimestamp(scc.cc.pair[j]) ) {
                    priceData.prices[flaggedPairs] = supraSValueFeedStorage.getSvalue(scc.cc.pair[j]).price;
                    updateMask[flaggedPairs]=0;
                }
                else {
                    priceData.prices[flaggedPairs] =scc.cc.prices[j];
                    updateMask[flaggedPairs]=0;
                }
                flaggedPairs += 1;
            }
        }
        emit PriceUpdate(priceData.pairs,priceData.prices,updateMask);
        return priceData;
    }

    /// @notice It helps to pack many data points into one single word (32 bytes)
    /// @dev This function will take the required parameters, Will shift the value to its specific position
    /// @dev For concatenating one value with another we are using unary OR operator
    /// @dev Saving the Packed data into the SupraStorage Contract
    /// @param _pair Pair identifier of the token pair
    /// @param _round Round on which DORA nodes collects and post the pair data
    /// @param _decimals Number of decimals that the price of the pair supports
    /// @param _price Price of the pair
    /// @param _time Last updated timestamp of the pair
    function packData(
    uint256 _pair,
    uint256 _round,
    uint256 _decimals,
    uint256 _time,
    uint256 _price
    ) internal {
    uint256 r = uint256(_round) << 192;
    r = r | _decimals << 184;
    r = r | _time << 120;
    r = r | _price << 24;
    supraSValueFeedStorage.restrictedSetSupraStorage(
    _pair,
    bytes32(r)
    );
    }


    /// @notice Internal Function to check for zero address
    function _ensureNonZeroAddress (address contract_) pure private {
        if (contract_ == address(0)) {
            revert ZeroAddress();
        }
    }

    /// @notice Helper Function to update the supraSValueFeedStorage Contract address during contract initialization
    /// @param supraSValueFeed_ new supraSValueFeed
    function updateSupraSValueFeedInitLevel(ISupraSValueFeed supraSValueFeed_) private {
        _ensureNonZeroAddress(address(supraSValueFeed_));
        supraSValueFeedStorage = supraSValueFeed_;

        emit SupraSValueFeedUpdated(address(supraSValueFeed_));
    }

    /// @notice Helper Function to update the supraSvalueVerifier Contract address during contract initialization
    /// @param supraSvalueVerifier_ new supraSvalueVerifier Contract address
    function updateSupraSValueVerifierInitLevel(ISupraSValueFeedVerifier supraSvalueVerifier_) private {
        _ensureNonZeroAddress(address(supraSvalueVerifier_));
        supraSValueVerifier = supraSvalueVerifier_;

        emit SupraSValueVerifierUpdated(address(supraSvalueVerifier_));
    }


    /// @notice Helper Function to update the supraSValueFeedStorage Contract address in future
    /// @param supraSValueFeed_ new supraSValueFeedStorage Contract address
    function updateSupraSValueFeed(ISupraSValueFeed supraSValueFeed_) external onlyOwner {
        _ensureNonZeroAddress(address(supraSValueFeed_));
        supraSValueFeedStorage = supraSValueFeed_;

        emit SupraSValueFeedUpdated(address(supraSValueFeed_));
    }


    /// @notice Helper Function to check for the address of SupraSValueFeedVerifier contract    
    function checkSupraSValueVerifier() external view returns(address){
        return (address(supraSValueVerifier));
    }

    ///@notice Helper function to check for the address of SupraSValueFeed contract
    function checkSupraSValueFeed() external view returns(address){
        return (address(supraSValueFeedStorage));
    }


    /// @notice Helper Function to update the supraSvalueVerifier Contract address in future
    /// @param supraSvalueVerifier_ new supraSvalueVerifier Contract address
    function updateSupraSValueVerifier(ISupraSValueFeedVerifier supraSvalueVerifier_) external onlyOwner {
        _ensureNonZeroAddress(address(supraSvalueVerifier_));
        supraSValueVerifier = supraSvalueVerifier_;

        emit SupraSValueVerifierUpdated(address(supraSvalueVerifier_));
    }

    /// @notice Verify SMR Txns
    function requireTxnsVerfified(
        Smr.MinBatch[] memory smrBatches,
        Smr.MinTxn[] memory smrTxns,
        uint256[] memory txnToBatch
    ) internal pure {
        if(smrBatches.length!=smrTxns.length || smrTxns.length!=txnToBatch.length) {
            revert ArrayLengthMismatch();
        }

        for (uint256 i = 0; i < smrTxns.length; ++i) {
            Smr.MinTxn memory smrTxn = smrTxns[i];
            bytes32 txnHash = Smr.hashTxn(smrTxn);
            if (smrBatches[txnToBatch[i]].txnHashes[smrTxn.txnIdx] != txnHash) {
                revert InvalidTransaction();
            }
        }
    }

    /// @notice Verify batches
    function requireBatchesVerified(
        Smr.Vote[] memory votes,
        Smr.MinBatch[] memory smrBatches,
        uint256[] memory batchToVote
    ) internal pure {
        if(smrBatches.length != batchToVote.length){
            revert ArrayLengthMismatch();
        }
        for (uint256 i = 0; i < smrBatches.length; ++i) {
            Smr.MinBatch memory smrBatch = smrBatches[i];
            bytes32 batchHash = Smr.hashBatch(smrBatch);
            if (votes[batchToVote[i]].smrBlock.batchHashes[smrBatch.batchIdx] != batchHash) {
                revert InvalidBatch();
            }
        }
    }

    /// @notice Verify votes
    /// @dev Requires the provided votes to be verified using SupraSValueFeedVerifierContract contract's authority public key and BLS signature.
    /// @param votes The array of data on which the signature is to be verified.
    /// @param sigs The BLS signature of the array of data in the form of Votes.
    /// @dev This function verifies the BLS signature by calling the SupraSValueFeedVerifierContract that uses BLS precompile contract and checks if the message matches the provided signature.
    /// @dev If the signature verification fails or if there is an issue with the BLS precompile contract call, the function reverts with an error.
    function requireVotesVerified(Smr.Vote[] memory votes, uint256[2][] memory sigs) internal view {
        if( votes.length != sigs.length){
            revert ArrayLengthMismatch();
        }
        for (uint256 i = 0; i < votes.length; ++i) {
            bytes32 smrVoteHash = Smr.hashVote(votes[i]);
            (bool status,)=address(supraSValueVerifier).staticcall(abi.encodeCall(ISupraSValueFeedVerifier.requireHashVerified,(bytes.concat(smrVoteHash), sigs[i])));
            if(!status){
                revert DataNotVerified();
            }
        }
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.20;

error ZeroAddress();
error InvalidBatch();
error InvalidTransaction();
error DuplicateCluster();
error ClusterNotVerified();
error BLSInvalidPubllicKeyorSignaturePoints();
error BLSIncorrectInputMessaage();
error DataNotVerified();
error ArrayLengthMismatch();

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.20;

/// @title Supra SMR Block Utilities
/// @notice This library contains the data structures and functions for hashing SMR blocks.
library Smr {
    /// @notice A vote is a block with a round number.
    /// @dev The library assumes the round number is passed in little endian format
    struct Vote {
        MinBlock smrBlock;
        // SPEC: smrBlock.round.to_le_bytes()
        bytes8 roundLE;
    }

    /// @notice A partial SMR block containing the bare-minimum for hashing
    struct MinBlock {
        uint64 round;
        uint128 timestamp;
        bytes32 author;
        bytes32 qcHash;
        bytes32[] batchHashes;
    }

    /// @notice An SMR Transaction
    struct MinTxn {
        bytes32[] clusterHashes;
        bytes32 sender;
        bytes10 protocol;
        bytes1 tx_sub_type;
        // SPEC: Index of the transaction in its batch
        uint256 txnIdx;
    }

    /// @notice A partial SMR batch containing the bare-minimum for hashing
    /// @dev The library assumes that txnHashes is a list of keccak256 hashes of abi encoded SMR transaction
    struct MinBatch {
        bytes10 protocol;
        // SPEC: List of keccak256(Txn.clusterHashes, Txn.sender, Txn.protocol, Txn.tx_sub_type)
        bytes32[] txnHashes;
        // SPEC: Index of the batch in its block
        uint256 batchIdx;
    }

    /// @notice An SMR Signed Coherent Cluster
    struct SignedCoherentCluster {
        CoherentCluster cc;
        bytes qc;
        uint256 round;
        Origin origin;
    }

    /// @notice An SMR Coherent Cluster containing the price data
    struct CoherentCluster {
        bytes32 dataHash;
        uint256[] pair;
        uint256[] prices;
        uint256[] timestamp;
        uint256[] decimals;
    }

    /// @notice An SMR Txn Sender
    struct Origin {
        bytes32 _publicKeyIdentity;
        uint256 _pubMemberIndex;
        uint256 _committeeIndex;
    }

    /// @notice Hash an SMR Transaction
    /// @param txn The SMR transaction to hash
    /// @return Hash of the SMR Transaction
    function hashTxn(MinTxn memory txn) internal pure returns (bytes32) {
        bytes memory clustersConcat = abi.encodePacked(txn.clusterHashes);
        return
            keccak256(
                abi.encodePacked(
                    clustersConcat,
                    txn.sender,
                    txn.protocol,
                    txn.tx_sub_type
                )
            );
    }

    /// @notice Hash an SMR Batch
    /// @param batch The SMR batch to hash
    /// @return Hash of the SMR Batch
    function hashBatch(MinBatch memory batch) internal pure returns (bytes32) {
        bytes32 txnsHash = keccak256(abi.encodePacked(batch.txnHashes));
        return keccak256(abi.encodePacked(batch.protocol, txnsHash));
    }

    /// @notice Hash an SMR Vote
    /// @param vote The SMR vote to hash
    /// @return Hash of the SMR Vote
    function hashVote(Vote memory vote) internal pure returns (bytes32) {
        bytes32 batchesHash = keccak256(
            abi.encodePacked(vote.smrBlock.batchHashes)
        );
        bytes32 blockHash = keccak256(
            abi.encodePacked(
                vote.smrBlock.round,
                vote.smrBlock.timestamp,
                vote.smrBlock.author,
                vote.smrBlock.qcHash,
                batchesHash
            )
        );
        return keccak256(abi.encodePacked(blockHash, vote.roundLE));
    }   
}

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

interface ISupraSValueFeed {


     struct dataWithoutHcc {
        uint256 round;
        uint256 decimals;
        uint256 time;
        uint256 price;

    }

    struct dataWithHcc {
        uint256 round;
        uint256 decimals;
        uint256 time;
        uint256 price;
        uint256 historyConsistent;
    }

    struct derivedData{
        int256 roundDifference;
        int256 timeDifference;
        uint256 derivedPrice;
        uint256 decimals;
    }

    
    function restrictedSetSupraStorage(uint256 _index, bytes32 _bytes) 
        external;


    function restrictedSetTimestamp(uint256 _tradingPair, uint256 timestamp)
        external;


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


     function getSvalue(uint64 _pairIndex)
        external
        view
        returns (bytes32, bool);


    function getSvalues(uint64[] memory _pairIndexes)
        external
        view
        returns (bytes32[] memory, bool[] memory);


    function getDerivedSvalue(uint256 _derivedPairId) 
        external 
        view 
        returns (derivedData memory);
   

    function getSvalueWithHCC(uint256 _pairIndex)
        external
        view
        returns (dataWithHcc memory);


    function getSvaluesWithHCC(uint256[] memory _pairIndexes)
        external
        view
        returns (dataWithHcc[] memory);


    function getSvalue(uint256 _pairIndex)
        external
        view
        returns (dataWithoutHcc memory);


    function getSvalues(uint256[] memory _pairIndexes)
        external
        view
        returns (dataWithoutHcc[] memory);
  

}

pragma solidity ^0.8.19;


interface  ISupraSValueFeedVerifier {

    function isPairAlreadyAddedForHCC(uint256[] calldata _pairIndexes)
        external
        view
        returns (bool);

    function isPairAlreadyAddedForHCC(uint256 _pairId)
        external
        view
        returns (bool);

    function requireHashVerified(bytes memory message, uint256[2] memory signature) 
        external
        view ;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)

pragma solidity ^0.8.0;

import "./OwnableUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which provides access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {
    function __Ownable2Step_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable2Step_init_unchained() internal onlyInitializing {
    }
    address private _pendingOwner;

    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Returns the address of the pending owner.
     */
    function pendingOwner() public view virtual returns (address) {
        return _pendingOwner;
    }

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
        _transferOwnership(sender);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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 the implementation's compatibility when performing 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.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeTo(address newImplementation) public 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.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) public 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.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev 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.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    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.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    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.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

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

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

// 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 (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;

import "../beacon/IBeacon.sol";
import "../../interfaces/IERC1967.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._
 */
abstract contract ERC1967Upgrade is IERC1967 {
    // 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 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 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 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 v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";

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

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

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts 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.9.0) (interfaces/IERC1967.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
 *
 * _Available since v4.8.3._
 */
interface IERC1967 {
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Emitted when the beacon is changed.
     */
    event BeaconUpgraded(address indexed beacon);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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

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:
 * ```solidity
 * 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`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes 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
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"ArrayLengthMismatch","type":"error"},{"inputs":[],"name":"ClusterNotVerified","type":"error"},{"inputs":[],"name":"DataNotVerified","type":"error"},{"inputs":[],"name":"InvalidBatch","type":"error"},{"inputs":[],"name":"InvalidTransaction","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256[]","name":"pairs","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"prices","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"updateMask","type":"uint256[]"}],"name":"PriceUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"supraSValueFeedStorage","type":"address"}],"name":"SupraSValueFeedUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"supraSValueVerifier","type":"address"}],"name":"SupraSValueVerifierUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"checkSupraSValueFeed","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"checkSupraSValueVerifier","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_supraSValueFeedStorage","type":"address"},{"internalType":"address","name":"_supraSValueVerifier","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ISupraSValueFeed","name":"supraSValueFeed_","type":"address"}],"name":"updateSupraSValueFeed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ISupraSValueFeedVerifier","name":"supraSvalueVerifier_","type":"address"}],"name":"updateSupraSValueVerifier","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_bytesProof","type":"bytes"}],"name":"verifyOracleProof","outputs":[{"components":[{"internalType":"uint256[]","name":"pairs","type":"uint256[]"},{"internalType":"uint256[]","name":"prices","type":"uint256[]"},{"internalType":"uint256[]","name":"decimals","type":"uint256[]"}],"internalType":"struct SupraOraclePull.PriceData","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"}]

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

725:12108:16:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;;;:::i;:::-;1303:62:1;;:::i;:::-;1504:24:0;725:12108:16;;-1:-1:-1;;;;;;725:12108:16;-1:-1:-1;;;;;725:12108:16;;;;;;;;;1513:6:1;725:12108:16;;;;1543:43:0;-1:-1:-1;;1543:43:0;725:12108:16;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;1202:13:0;725:12108:16;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4413:11;;725:12108;;;4426:10;725:12108;;;;12375:27;12371:85;;12603:19;725:12108;-1:-1:-1;;;;;725:12108:16;;12470:13;;;725:12108;12503:3;725:12108;;12485:16;;;;;12557:8;;;;:::i;:::-;;725:12108;3086:43:14;725:12108:16;3103:13:14;;:25;;725:12108:16;;3086:43:14;;;725:12108:16;3086:43:14;;725:12108:16;;:::i;:::-;3086:43:14;725:12108:16;;3086:43:14;;;;;;:::i;:::-;725:12108:16;;;3086:43:14;;3063:76;3226:13;;725:12108:16;;;3263:23:14;;;;725:12108:16;3304:20:14;725:12108:16;;3304:20:14;;725:12108:16;3342:20:14;;725:12108:16;;;;3192:213:14;;;;725:12108:16;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;3192:213:14;;;;;:::i;:::-;725:12108:16;3169:246:14;;3470:12;;725:12108:16;;;;;3442:41:14;725:12108:16;3442:41:14;;725:12108:16;;;;;;;3442:41:14;;;;;:::i;:::-;725:12108:16;3432:52:14;;725:12108:16;;;;;;;;;;;;;:::i;:::-;12723:7;;;;:::i;:::-;;725:12108;;-1:-1:-1;;;725:12108:16;12635:97;;;725:12108;;12635:97;;725:12108;;;;;;;;;:::i;:::-;;;;;;;;;;;;;12635:97;;;;;725:12108;12635:97;;;;725:12108;;12635:97;;;;;;:::i;:::-;725:12108;12595:138;;12635:97;;12595:138;;;;;:::i;:::-;;12750:7;12747:68;;12503:3;;;:::i;:::-;12470:13;;12747:68;725:12108;;-1:-1:-1;;;12783:17:16;;725:12108;;12783:17;725:12108;;;;;;;;;;;;;;;;;;12485:16;;4470:11;;725:12108;;;4483:16;725:12108;;;;4501:17;725:12108;;;;;11154:39;11151:96;;725:12108;11299:3;725:12108;;11276:21;;;;;11349:13;;;;:::i;:::-;;11437:61;725:12108;2752:15:14;;;725:12108:16;;2735:33:14;;725:12108:16;;2735:33:14;;725:12108:16;;;:::i;2735:33:14:-;725:12108:16;2725:44:14;;725:12108:16;;;;;;;;;2796:42:14;725:12108:16;2796:42:14;;725:12108:16;;;;;;;;;2796:42:14;;;;;:::i;:::-;725:12108:16;2786:53:14;;11443:14:16;725:12108;;11437:21;11443:14;;;;:::i;:::-;725:12108;11437:21;;:::i;:::-;;:30;:42;;11480:17;;725:12108;11437:61;;:::i;:::-;725:12108;11437:74;11433:134;;11299:3;;;:::i;:::-;11261:13;;11433:134;725:12108;;-1:-1:-1;;;11538:14:16;;725:12108;;11538:14;11276:21;;725:12108;;;4560:13;725:12108;;;4604:16;725:12108;;;4631:16;725:12108;;;;;10500:33;;;;;;:70;;;11256:321;10497:128;;;725:12108;10675:3;725:12108;;10655:18;;;;;10721:10;;;;:::i;:::-;;10800:50;2233:17:14;;725:12108:16;;2216:35:14;;725:12108:16;;2216:35:14;;725:12108:16;;;:::i;2216:35:14:-;2307:173;;725:12108:16;2381:10:14;;725:12108:16;;;;;;2413:12:14;;725:12108:16;;;;;;;2447:15:14;;725:12108:16;;;;2307:173:14;;;725:12108:16;;2307:173:14;;725:12108:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;2307:173:14;725:12108:16;2307:173:14;;;;;;;:::i;:::-;725:12108:16;2280:214:14;;10811:13:16;725:12108;;10800:25;10811:13;;;;:::i;10800:25::-;;:35;;10836:13;;725:12108;10800:50;;:::i;:::-;725:12108;10800:61;10796:127;;10675:3;;;:::i;:::-;10640:13;;10796:127;725:12108;;-1:-1:-1;;;10888:20:16;;725:12108;;10888:20;10655:18;;;725:12108;;;4685:17;725:12108;;;;4744:18;725:12108;;;;4805:19;4863:28;725:12108;;;;4863:28;:::i;:::-;725:12108;4954:28;725:12108;;;;4954:28;:::i;:::-;725:12108;4996:28;725:12108;;;;4996:28;:::i;:::-;5038;725:12108;;;;5038:28;:::i;:::-;725:12108;;;;;;;:::i;:::-;;;;4931:145;;725:12108;;4931:145;;725:12108;;;;5148:1523;5189:3;725:12108;;5168:19;;;;;5240:11;5270:56;:24;5278:15;5240:11;;;;;:::i;:::-;;725:12108;;;;;5230:22;5278:15;;:::i;:::-;725:12108;5270:24;;:::i;:::-;;:38;5309:16;;;;:::i;:::-;725:12108;5270:56;;:::i;:::-;725:12108;5270:71;5266:137;;5467:11;;;;:::i;:::-;;725:12108;;;5456:52;;725:12108;;;;;;;;;5456:52;;725:12108;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;689:66:7;725:12108:16;;;;;-1:-1:-1;;;;;725:12108:16;;;;;5456:52;725:12108;5456:52;;;725:12108;;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;5456:52;725:12108;5456:52;;;725:12108;;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;5456:52;725:12108;5456:52;;;725:12108;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;5456:52;;;;725:12108;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;5456:52;;725:12108;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;5456:52;;725:12108;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;;;;;;;;;:::i;:::-;;;;;689:66:7;725:12108:16;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5566:3:16;725:12108;;5546:6;;:11;;725:12108;5542:22;;;;;725:12108;;;;;;;;5589:9;725:12108;;;;5621:14;725:12108;;;;;5621:24;;;:::i;:::-;725:12108;;5616:80;;5745:14;:6;725:12108;5745:6;;:11;;:14;:::i;:::-;725:12108;5713:46;:15;;;:46;:::i;:::-;725:12108;5813:18;:6;725:12108;5813:6;;:15;;:18;:::i;:::-;725:12108;5778:53;4931:145;725:12108;4931:145;;5778:18;:53;:::i;:::-;725:12108;5853:19;:6;725:12108;5853:6;;:16;;:19;:::i;:::-;725:12108;;;;;;5875:22;725:12108;;5911:6;:14;:6;725:12108;5911:6;;:11;;:14;:::i;:::-;725:12108;;;;689:66:7;;;;5875:51:16;;725:12108;5875:51;;725:12108;;5875:51;725:12108;5875:51;;;;;;;;;725:12108;5875:51;;;5566:3;-1:-1:-1;5853:73:16;;;;5958:14;:6;725:12108;5958:6;;:11;;:14;:::i;:::-;725:12108;;;;;;5983:6;;:18;:6;725:12108;5983:6;;:15;;:18;:::i;:::-;725:12108;6002:6;6022:16;6002:6;725:12108;6002:19;:6;725:12108;6002:6;;:16;;:19;:::i;:::-;725:12108;6022:6;;:13;;:16;:::i;:::-;725:12108;7695:81;;;;;;725:12108;;;;;;;;689:66:7;;;;;;;;7695:81:16;;725:12108;7695:81;;725:12108;7687:2;725:12108;;;;;7634:3;725:12108;;;;7617:20;7647:16;7673;725:12108;;;;7695:81;;;;;;;;5850:762;6093:6;:16;:6;725:12108;6093:6;;:13;;:16;:::i;:::-;725:12108;6061:48;4931:145;725:12108;4931:145;;6061:16;:48;:::i;:::-;725:12108;;6131:26;;;;:::i;:::-;725:12108;5850:762;725:12108;;;;;;;;5566:3;725:12108;;5566:3;;:::i;:::-;5527:13;;;725:12108;;;;;;;;;;;;7695:81;-1:-1:-1;;;;;725:12108:16;;;;;;7695:81;;;725:12108;;;;;;;;;;;;7695:81;725:12108;;689:66:7;725:12108:16;689:66:7;;;;;5850:762:16;6201:19;:6;725:12108;6201:6;;:16;;:19;:::i;:::-;725:12108;6259:14;:6;725:12108;6259:6;;:11;;:14;:::i;:::-;725:12108;;;;689:66:7;;;;6223:51:16;;725:12108;6223:51;;725:12108;;6223:51;725:12108;6223:51;;;;;;;;;725:12108;6223:51;;;5850:762;-1:-1:-1;6201:73:16;;;;725:12108;6365:14;:6;725:12108;6365:6;;:11;;:14;:::i;:::-;725:12108;;;;689:66:7;;;;;;;6332:48:16;;725:12108;6332:48;;725:12108;6332:48;;;;;;725:12108;6332:48;;;6198:414;725:12108;6332:54;;;725:12108;6299:87;4931:145;725:12108;4931:145;;6299:16;:87;:::i;:::-;725:12108;;6408:26;;;;:::i;:::-;725:12108;5850:762;;6332:48;;725:12108;6332:48;;725:12108;6332:48;;;;;;725:12108;6332:48;;;:::i;:::-;;;725:12108;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;6332:48;;;;;-1:-1:-1;6332:48:16;;6198:414;6529:6;:16;:6;725:12108;6529:6;;:13;;:16;:::i;:::-;725:12108;6497:48;4931:145;725:12108;4931:145;;6497:16;:48;:::i;6223:51::-;;;;725:12108;6223:51;;725:12108;6223:51;;;;;;725:12108;6223:51;;;:::i;:::-;;;725:12108;;;;;6223:51;;;;;;;-1:-1:-1;6223:51:16;;5875;;;;725:12108;5875:51;;725:12108;5875:51;;;;;;725:12108;5875:51;;;:::i;:::-;;;725:12108;;;;;5875:51;;;;;;;-1:-1:-1;5875:51:16;;5616:80;5669:8;5566:3;5669:8;5566:3;:::i;5542:22::-;;;;;;;;5189:3;5542:22;;;5189:3;:::i;:::-;5153:13;;;;;;;;;;5266:137;725:12108;;-1:-1:-1;;;5368:20:16;;725:12108;;5368:20;5168:19;725:12108;5168:19;6685:56;725:12108;5168:19;725:12108;6697:15;;4931:145;725:12108;;4931:145;;6713:16;725:12108;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;6685:56;;;725:12108;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;4931:145;;725:12108;;;;;;;;;;;;;;;:::i;:::-;4931:145;;725:12108;;;;;;;;;;;:::i;:::-;;;;10497:128;725:12108;;-1:-1:-1;;;10593:21:16;;725:12108;;10593:21;10500:70;725:12108;;;;10537:33;;10500:70;;;725:12108;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;1513:6:1;725:12108:16;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;1202:13:0;725:12108:16;929:10:4;-1:-1:-1;;;;;725:12108:16;;;2109:24:0;725:12108:16;;2208:6:0;929:10:4;2208:6:0;:::i;:::-;725:12108:16;;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;;;;;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;1357:1:1;1303:62;;;:::i;:::-;1357:1;:::i;725:12108:16:-;;;;;;-1:-1:-1;;725:12108:16;;;;1303:62:1;;:::i;:::-;1859:20:0;725:12108:16;;-1:-1:-1;;;;;;725:12108:16;;;;;;2758:6:1;725:12108:16;;;;;;;;;-1:-1:-1;;;;;725:12108:16;2806:40:1;725:12108:16;;2806:40:1;725:12108:16;;;;;;;-1:-1:-1;;725:12108:16;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;1357:1:1;1303:62;;;:::i;:::-;1357:1;:::i;725:12108:16:-;;;;;;-1:-1:-1;;725:12108:16;;;;9574:19;725:12108;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;2089:6:9;-1:-1:-1;;;;;725:12108:16;2080:4:9;2072:23;725:12108:16;;;;;-1:-1:-1;;;;;;;;;;;725:12108:16;;;;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;725:12108:16;;;;;;:::i;:::-;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;:::i;:::-;;-1:-1:-1;;;;;1654:6:9;725:12108:16;;;1629:80:9;1645:4;1637:23;;;1629:80;:::i;:::-;1719:87;-1:-1:-1;;;;;;;;;;;725:12108:16;;;;;1727:30:9;1719:87;:::i;:::-;1303:62:1;;:::i;:::-;689:66:7;;;;;;;2993:17;;;;;;:::i;2906:504::-;725:12108:16;;-1:-1:-1;;;3046:52:7;;;;725:12108:16;;;;;;3046:52:7;725:12108:16;;;;3046:52:7;;725:12108:16;;3046:52:7;;;2906:504;-1:-1:-1;3042:291:7;;725:12108:16;;-1:-1:-1;;;3262:56:7;;725:12108:16;3262:56:7;;689:66;;;;725:12108:16;689:66:7;;725:12108:16;689:66:7;725:12108:16;;;689:66:7;-1:-1:-1;;;689:66:7;;;;;;3262:56;3042:291;3148:28;689:66;;1856:17;;;:::i;:::-;1889:27;725:12108:16;1889:27:7;;725:12108:16;;2208:15:7;;;:28;;;3042:291;2204:112;;725:12108:16;2204:112:7;725:12108:16;;7307:69:10;725:12108:16;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;725:12108:16;;;;7265:25:10;;;;;;;;;:::i;:::-;7307:69;;:::i;2208:28:7:-;;725:12108:16;2208:28:7;;689:66;725:12108:16;;-1:-1:-1;;;689:66:7;;725:12108:16;689:66:7;;;;;;725:12108:16;689:66:7;;725:12108:16;689:66:7;725:12108:16;;;689:66:7;-1:-1:-1;;;689:66:7;;;;;;;3046:52;;;;;;;;;;;;;;;;;:::i;:::-;;;689:66;;;;;3046:52;;;;;;;;;725:12108:16;;;;;;-1:-1:-1;;725:12108:16;;;;;;:::i;:::-;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;;;;689:66:7;725:12108:16;;;689:66:7;3301:14:2;3347:34;;;;;;725:12108:16;3346:108:2;;;;725:12108:16;;;;-1:-1:-1;;725:12108:16;;;;;;3963:46;;3876:41;;725:12108;3562:65:2;;725:12108:16;;5366:69:2;689:66:7;725:12108:16;;;;689:66:7;5366:69:2;;;:::i;:::-;;:::i;:::-;1195:12:1;929:10:4;1195:12:1;:::i;:::-;725:12108:16;3876:41;:::i;3963:46::-;3647:99:2;;725:12108:16;3647:99:2;725:12108:16;;;;;;;3721:14:2;725:12108:16;;;;;;3721:14:2;725:12108:16;3562:65:2;-1:-1:-1;;725:12108:16;;;;;3562:65:2;;;725:12108:16;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;;;;;;;-1:-1:-1;;;725:12108:16;;;;;;;3346:108:2;3426:4;;1702:19:10;:23;3387:66:2;;3346:108;3387:66;689::7;725:12108:16;689:66:7;;;3436:17:2;3346:108;;3347:34;689:66:7;725:12108:16;689:66:7;;;3365:16:2;3347:34;;725:12108:16;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;1654:6:9;725:12108:16;;;;1629:80:9;1645:4;1637:23;;;1629:80;:::i;:::-;1719:87;-1:-1:-1;;;;;;;;;;;725:12108:16;;;;;1727:30:9;1719:87;:::i;:::-;1303:62:1;;:::i;:::-;725:12108:16;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;;689:66:7;;;;2906:504;689:66;;;2993:17;;;;;;;;:::i;2906:504::-;725:12108:16;;;;;;;689:66:7;;;3046:52;;;;725:12108:16;3046:52:7;;;;725:12108:16;;3046:52:7;;;2906:504;-1:-1:-1;3042:291:7;;725:12108:16;;-1:-1:-1;;;3262:56:7;;725:12108:16;3262:56:7;;689:66;;;;;;;725:12108:16;689:66:7;725:12108:16;;;689:66:7;-1:-1:-1;;;689:66:7;;;;;;3262:56;3042:291;3148:28;689:66;;1856:17;;;:::i;:::-;1889:27;725:12108:16;1889:27:7;;725:12108:16;;2208:15:7;;;:28;;;3042:291;2204:112;;725:12108:16;2204:112:7;725:12108:16;;;7307:69:10;725:12108:16;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;;725:12108:16;;;;7265:25:10;;;;;;;:::i;2208:28:7:-;;725:12108:16;2208:28:7;;689:66;725:12108:16;;-1:-1:-1;;;689:66:7;;725:12108:16;689:66:7;;;;;;;;;725:12108:16;689:66:7;725:12108:16;;;689:66:7;-1:-1:-1;;;689:66:7;;;;;;;3046:52;;;;;;;;;;;;;;;;;:::i;:::-;;;689:66;;;;;3046:52;;;;;;;;;725:12108:16;;;;;;-1:-1:-1;;725:12108:16;;;;9780:22;725:12108;-1:-1:-1;;;;;725:12108:16;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;:::o;:::-;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;:::o;:::-;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;:::o;:::-;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;:::o;:::-;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;:::o;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;:::o;:::-;-1:-1:-1;;;;;725:12108:16;;;;;;-1:-1:-1;;725:12108:16;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;725:12108:16;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;-1:-1:-1;725:12108:16;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;1777:153:0;725:12108:16;;;;;1859:20:0;725:12108:16;;1859:20:0;725:12108:16;2758:6:1;725:12108:16;;;;;;;;;;;;;;2758:6:1;725:12108:16;;2806:40:1;1859:20:0;2806:40:1;;1777:153:0:o;1599:130:1:-;1513:6;725:12108:16;-1:-1:-1;;;;;725:12108:16;929:10:4;1662:23:1;725:12108:16;;1599:130:1:o;725:12108:16:-;;;;689:66:7;;;725:12108:16;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;;;;;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;;;;;;;-1:-1:-1;;;725:12108:16;;;;;;;1406:259:7;1702:19:10;;:23;725:12108:16;;-1:-1:-1;;;;;;;;;;;725:12108:16;;-1:-1:-1;;;;;;725:12108:16;-1:-1:-1;;;;;725:12108:16;;;;;;;;;1406:259:7:o;725:12108:16:-;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;;;;;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;-1:-1:-1;725:12108:16;;;;:::o;:::-;;;:::o;7671:628:10:-;;;;7875:418;;;725:12108:16;;;7906:22:10;7902:286;;8201:17;;:::o;7902:286::-;1702:19;:23;725:12108:16;;8201:17:10;:::o;725:12108:16:-;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;;;;;;;;;;7875:418:10;725:12108:16;;;;-1:-1:-1;8980:21:10;:17;;9152:142;;;;;;;8976:379;725:12108:16;;-1:-1:-1;;;9324:20:10;;725:12108:16;9324:20:10;;;725:12108:16;;;;;;;;;;;:::i;:::-;9324:20:10;;;725:12108:16;;;;;;;;-1:-1:-1;;725:12108:16;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;725:12108:16;;;;:::o;:::-;;;;:::o;:::-;;;-1:-1:-1;;;725:12108:16;;;;;;;;;;;;;;;;;-1:-1:-1;;;725:12108:16;;;;;;;;-1:-1:-1;;;;;725:12108:16;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;725:12108:16;;;;;;:::o;:::-;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;:::o;:::-;-1:-1:-1;;725:12108:16;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;8179:264;8387:49;;725:12108;;-1:-1:-1;;;;;725:12108:16;8294:25;725:12108;8294:25;:::i;:::-;8330:41;725:12108;;-1:-1:-1;;;;;;725:12108:16;;;;;;;;;;8387:49;8179:264::o;7850:154::-;-1:-1:-1;;;;;725:12108:16;7928:23;7924:74;;7850:154::o;7924:74::-;725:12108;;-1:-1:-1;;;7974:13:16;;;;;8640:293;8869:57;;725:12108;;-1:-1:-1;;;;;725:12108:16;8771:29;725:12108;8771:29;:::i;:::-;8811:42;725:12108;;-1:-1:-1;;;;;;725:12108:16;;;;;;;;;;8869:57;8640:293::o;725:12108::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;

ipfs://3424d37b33f5a74f96d34a7d1a43e9def392787ddc14c994b8466194c69fff6b