Contract Source Code (Solidity)

IDE

• Blockscan IDE

Outline

•    - function _msgSender()
•    - function _msgData()
• library MerkleProof
•    - function verify(
•    - function verifyCalldata(
•    - function processProof(bytes32[] memor ...
•    - function processProofCalldata(bytes32 ...
•    - function multiProofVerify(
•    - function multiProofVerifyCalldata(
•    - function processMultiProof(
•    - function processMultiProofCalldata(
•    - function _hashPair(bytes32 a, bytes32 ...
•    - function _efficientHash(bytes32 a, by ...
•    - function _requireCallerIsContractOwne ...
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•    - function _requireCallerIsContractOwne ...
•  contract PhaseManager is OwnableBa ... *
•    - function configurePhase(
•    - function currentPhase()
•    - function isWhitelistedForPhase(

More Options

• Similar
• Compare

/**
 *Submitted for verification at curtis.apescan.io on 2024-11-27
*/

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

// lib/openzeppelin-contracts/contracts/utils/Context.sol

// OpenZeppelin Contracts v4.4.1 (utils/Context.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 Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

// lib/openzeppelin-contracts/contracts/utils/cryptography/MerkleProof.sol

// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// lib/creator-token-standards/src/access/OwnablePermissions.sol

abstract contract OwnablePermissions is Context {
    function _requireCallerIsContractOwner() internal view virtual;
}

// lib/openzeppelin-contracts/contracts/access/Ownable.sol

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.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 Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _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 anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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);
    }
}

// lib/creator-token-standards/src/access/OwnableBasic.sol

abstract contract OwnableBasic is OwnablePermissions, Ownable {
    function _requireCallerIsContractOwner() internal view virtual override {
        _checkOwner();
    }
}

// src/PhaseManager.sol

error NoActivePhase();
error InvalidTimestamps();
error InvalidLimits();
error InvalidPhaseType();
error NoTwinPhase();
error NotWhitelisted();
error InvalidPhaseConfiguration();

enum PhaseType {
    NONE,
    TWIN_PHASE1,
    TWIN_PHASE2,
    ALBARRA_OG_WL,
    RILLAZ_HOLDER_WL,
    COMMUNITY_WL,
    PUBLIC_SALE
}

contract PhaseManager is OwnableBasic {
    struct Phase {
        bytes32 merkleRoot;
        uint96 price;
        uint64 start;
        uint64 end;
        uint8 maxPerWallet;
        uint16 maxSupplyPerPhase;
    }

    // State variables
    mapping(PhaseType => Phase) public phases;

    function configurePhase(
        PhaseType phaseType,
        bytes32 merkleRoot,
        uint96 price,
        uint64 start,
        uint64 end,
        uint8 maxPerWallet,
        uint16 maxSupplyPerPhase
    ) external {
        _requireCallerIsContractOwner();
        if (phaseType == PhaseType.NONE) revert InvalidPhaseType();
        if (end <= start) revert InvalidTimestamps();
        if (maxPerWallet == 0) revert InvalidLimits();
        if (maxSupplyPerPhase == 0) revert InvalidLimits();

        phases[phaseType] = Phase({
            merkleRoot: merkleRoot,
            price: price,
            start: start,
            end: end,
            maxPerWallet: maxPerWallet,
            maxSupplyPerPhase: maxSupplyPerPhase
        });
    }

    function currentPhase() public view returns (Phase memory, PhaseType) {
        uint256 currentTimestamp = block.timestamp;
        for (
            PhaseType i = PhaseType.TWIN_PHASE1;
            i <= type(PhaseType).max;
            i = PhaseType(uint8(i) + 1)
        ) {
            if (
                currentTimestamp >= phases[i].start &&
                currentTimestamp <= phases[i].end
            ) {
                return (phases[i], i);
            }
        }
        return (phases[PhaseType.NONE], PhaseType.NONE);
    }

    function isWhitelistedForPhase(
        PhaseType phaseType,
        address user,
        bytes32[] calldata merkleProof
    ) public view returns (bool) {
        return MerkleProof.verify(
            merkleProof,
            phases[phaseType].merkleRoot,
            keccak256(abi.encodePacked(user))
        );
    }
}

[{"inputs":[],"name":"InvalidLimits","type":"error"},{"inputs":[],"name":"InvalidPhaseType","type":"error"},{"inputs":[],"name":"InvalidTimestamps","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"enum PhaseType","name":"phaseType","type":"uint8"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint96","name":"price","type":"uint96"},{"internalType":"uint64","name":"start","type":"uint64"},{"internalType":"uint64","name":"end","type":"uint64"},{"internalType":"uint8","name":"maxPerWallet","type":"uint8"},{"internalType":"uint16","name":"maxSupplyPerPhase","type":"uint16"}],"name":"configurePhase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentPhase","outputs":[{"components":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint96","name":"price","type":"uint96"},{"internalType":"uint64","name":"start","type":"uint64"},{"internalType":"uint64","name":"end","type":"uint64"},{"internalType":"uint8","name":"maxPerWallet","type":"uint8"},{"internalType":"uint16","name":"maxSupplyPerPhase","type":"uint16"}],"internalType":"struct PhaseManager.Phase","name":"","type":"tuple"},{"internalType":"enum PhaseType","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum PhaseType","name":"phaseType","type":"uint8"},{"internalType":"address","name":"user","type":"address"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"isWhitelistedForPhase","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum PhaseType","name":"","type":"uint8"}],"name":"phases","outputs":[{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint96","name":"price","type":"uint96"},{"internalType":"uint64","name":"start","type":"uint64"},{"internalType":"uint64","name":"end","type":"uint64"},{"internalType":"uint8","name":"maxPerWallet","type":"uint8"},{"internalType":"uint16","name":"maxSupplyPerPhase","type":"uint16"}],"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"}]

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

13946:1991:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15040:555;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;14204:41;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;14204:41:0;;;-1:-1:-1;;;;;;;;14204:41:0;;;;;-1:-1:-1;;;14204:41:0;;;;;;;-1:-1:-1;;;14204:41:0;;;;;-1:-1:-1;;;14204:41:0;;;;;;;;;;1679:25:1;;;-1:-1:-1;;;;;1740:39:1;;;1735:2;1720:18;;1713:67;-1:-1:-1;;;;;1816:31:1;;;1796:18;;;1789:59;;;;1884:31;;1879:2;1864:18;;1857:59;1965:4;1953:17;1947:3;1932:19;;1925:46;2020:6;2008:19;2002:3;1987:19;;1980:48;1666:3;1651:19;14204:41:0;1404:630:1;12523:103:0;;;:::i;:::-;;14254:778;;;;;;:::i;:::-;;:::i;11875:87::-;11921:7;11948:6;11875:87;;-1:-1:-1;;;;;11948:6:0;;;3322:51:1;;3310:2;3295:18;11875:87:0;3176:203:1;12781:201:0;;;;;;:::i;:::-;;:::i;15603:331::-;;;;;;:::i;:::-;;:::i;:::-;;;4701:14:1;;4694:22;4676:41;;4664:2;4649:18;15603:331:0;4536:187:1;15040:555:0;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15148:15:0;15207:21;15174:356;15248:19;15243:1;:24;;;;;;;;:::i;:::-;;15174:356;;15378:6;:9;15385:1;15378:9;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;15378:9:0;:15;;;-1:-1:-1;;;15378:15:0;;-1:-1:-1;;;;;15378:15:0;15358:35;;;;;:89;;;15434:6;:9;15441:1;15434:9;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;15434:9:0;:13;;;-1:-1:-1;;;15434:13:0;;-1:-1:-1;;;;;15434:13:0;15414:33;;;15358:89;15336:183;;;15490:6;:9;15497:1;15490:9;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;15490:9:0;15482:21;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15482:21:0;;;;;;;;;-1:-1:-1;;;15482:21:0;;-1:-1:-1;;;;;15482:21:0;;;;;;;;;;-1:-1:-1;;;15482:21:0;;;;;;;;;-1:-1:-1;;;15482:21:0;;;;;;;;-1:-1:-1;;;15482:21:0;;;;;;;;;;15501:1;;-1:-1:-1;15482:21:0;-1:-1:-1;;15040:555:0:o;15336:183::-;15302:1;15296:8;;;;;;;;:::i;:::-;:12;;15307:1;15296:12;:::i;:::-;15286:23;;;;;;;;;;:::i;:::-;15282:27;;15174:356;;;-1:-1:-1;;15548:22:0;;;;:6;:22;;;;;15540:47;;;;;;;15548:22;15540:47;;;;;-1:-1:-1;;;;;15540:47:0;;;;;;;;;-1:-1:-1;;;15540:47:0;;-1:-1:-1;;;;;15540:47:0;;;;;;;;;;-1:-1:-1;;;15540:47:0;;;;;;;;;-1:-1:-1;;;15540:47:0;;;;;;;;-1:-1:-1;;;15540:47:0;;;;;;;;;;15548:22;;-1:-1:-1;15540:47:0;-1:-1:-1;15040:555:0:o;12523:103::-;11761:13;:11;:13::i;:::-;12588:30:::1;12615:1;12588:18;:30::i;:::-;12523:103::o:0;14254:778::-;14495:31;:29;:31::i;:::-;14554:14;14541:9;:27;;;;;;;;:::i;:::-;;14537:58;;14577:18;;-1:-1:-1;;;14577:18:0;;;;;;;;;;;14537:58;14617:5;-1:-1:-1;;;;;14610:12:0;:3;-1:-1:-1;;;;;14610:12:0;;14606:44;;14631:19;;-1:-1:-1;;;14631:19:0;;;;;;;;;;;14606:44;14665:12;:17;;14681:1;14665:17;14661:45;;14691:15;;-1:-1:-1;;;14691:15:0;;;;;;;;;;;14661:45;14721:17;:22;;14742:1;14721:22;14717:50;;14752:15;;-1:-1:-1;;;14752:15:0;;;;;;;;;;;14717:50;14800:224;;;;;;;;14833:10;14800:224;;;;14865:5;-1:-1:-1;;;;;14800:224:0;;;;;14892:5;-1:-1:-1;;;;;14800:224:0;;;;;14917:3;-1:-1:-1;;;;;14800:224:0;;;;;14949:12;14800:224;;;;;;14995:17;14800:224;;;;;14780:6;:17;14787:9;14780:17;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;14780:17:0;:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;14780:244:0;-1:-1:-1;;;;14780:244:0;;;;-1:-1:-1;;;14780:244:0;-1:-1:-1;;;;;;;;;14780:244:0;;;-1:-1:-1;;;14780:244:0;;-1:-1:-1;;;;14780:244:0;;;;-1:-1:-1;;;14780:244:0;-1:-1:-1;;;;;;14780:244:0;;;-1:-1:-1;;;;;14780:244:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;14254:778:0:o;12781:201::-;11761:13;:11;:13::i;:::-;-1:-1:-1;;;;;12870:22:0;::::1;12862:73;;;::::0;-1:-1:-1;;;12862:73:0;;5180:2:1;12862:73:0::1;::::0;::::1;5162:21:1::0;5219:2;5199:18;;;5192:30;5258:34;5238:18;;;5231:62;-1:-1:-1;;;5309:18:1;;;5302:36;5355:19;;12862:73:0::1;;;;;;;;;12946:28;12965:8;12946:18;:28::i;:::-;12781:201:::0;:::o;15603:331::-;15756:4;15780:146;15813:11;;15780:146;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15839:6:0;;-1:-1:-1;15780:146:0;-1:-1:-1;15846:9:0;;-1:-1:-1;15839:17:0;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;;;:28;;;15909:4;15892:22;;;;;;;5534:2:1;5530:15;;;;-1:-1:-1;;5526:53:1;5514:66;;5605:2;5596:12;;5385:229;15892:22:0;;;;;;;;;;;;;15882:33;;;;;;15780:18;:146::i;:::-;15773:153;15603:331;-1:-1:-1;;;;;15603:331:0:o;12040:132::-;11921:7;11948:6;-1:-1:-1;;;;;11948:6:0;798:10;12104:23;12096:68;;;;-1:-1:-1;;;12096:68:0;;5821:2:1;12096:68:0;;;5803:21:1;;;5840:18;;;5833:30;5899:34;5879:18;;;5872:62;5951:18;;12096:68:0;5619:356:1;13142:191:0;13216:16;13235:6;;-1:-1:-1;;;;;13252:17:0;;;-1:-1:-1;;;;;;13252:17:0;;;;;;13285:40;;13235:6;;;;;;;13285:40;;13216:16;13285:40;13205:128;13142:191;:::o;13471:104::-;13554:13;:11;:13::i;2132:190::-;2257:4;2310;2281:25;2294:5;2301:4;2281:12;:25::i;:::-;:33;;2132:190;-1:-1:-1;;;;2132:190:0:o;2999:296::-;3082:7;3125:4;3082:7;3140:118;3164:5;:12;3160:1;:16;3140:118;;;3213:33;3223:12;3237:5;3243:1;3237:8;;;;;;;;:::i;:::-;;;;;;;3213:9;:33::i;:::-;3198:48;-1:-1:-1;3178:3:0;;3140:118;;;-1:-1:-1;3275:12:0;-1:-1:-1;2999:296:0;;;;;:::o;10039:149::-;10102:7;10133:1;10129;:5;:51;;10264:13;10358:15;;;10394:4;10387:15;;;10441:4;10425:21;;10129:51;;;10264:13;10358:15;;;10394:4;10387:15;;;10441:4;10425:21;;10137:20;10122:58;10039:149;-1:-1:-1;;;10039:149:0:o;14:127:1:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:887;321:4;363:3;352:9;348:19;340:27;;400:6;394:13;383:9;376:32;-1:-1:-1;;;;;468:4:1;460:6;456:17;450:24;446:57;439:4;428:9;424:20;417:87;-1:-1:-1;;;;;564:4:1;556:6;552:17;546:24;542:49;535:4;524:9;520:20;513:79;-1:-1:-1;;;;;652:4:1;644:6;640:17;634:24;630:49;623:4;612:9;608:20;601:79;748:4;740;732:6;728:17;722:24;718:35;711:4;700:9;696:20;689:65;822:6;814:4;806:6;802:17;796:24;792:37;785:4;774:9;770:20;763:67;860:1;852:6;849:13;839:144;;905:10;900:3;896:20;893:1;886:31;940:4;937:1;930:15;968:4;965:1;958:15;839:144;1020:6;1014:3;1003:9;999:19;992:35;146:887;;;;;:::o;1038:150::-;1113:20;;1162:1;1152:12;;1142:40;;1178:1;1175;1168:12;1142:40;1038:150;;;:::o;1193:206::-;1265:6;1318:2;1306:9;1297:7;1293:23;1289:32;1286:52;;;1334:1;1331;1324:12;1286:52;1357:36;1383:9;1357:36;:::i;2039:171::-;2106:20;;-1:-1:-1;;;;;2155:30:1;;2145:41;;2135:69;;2200:1;2197;2190:12;2215:956;2335:6;2343;2351;2359;2367;2375;2383;2436:3;2424:9;2415:7;2411:23;2407:33;2404:53;;;2453:1;2450;2443:12;2404:53;2476:36;2502:9;2476:36;:::i;:::-;2466:46;;2559:2;2548:9;2544:18;2531:32;2521:42;;2613:2;2602:9;2598:18;2585:32;-1:-1:-1;;;;;2650:5:1;2646:38;2639:5;2636:49;2626:77;;2699:1;2696;2689:12;2626:77;2722:5;-1:-1:-1;2746:37:1;2779:2;2764:18;;2746:37;:::i;:::-;2736:47;;2802:38;2835:3;2824:9;2820:19;2802:38;:::i;:::-;2792:48;;2892:3;2881:9;2877:19;2864:33;2941:4;2932:7;2928:18;2919:7;2916:31;2906:59;;2961:1;2958;2951:12;2906:59;2984:7;-1:-1:-1;3064:3:1;3049:19;;3036:33;3113:6;3100:20;;3088:33;;3078:61;;3135:1;3132;3125:12;3078:61;3158:7;3148:17;;;2215:956;;;;;;;;;;:::o;3384:173::-;3452:20;;-1:-1:-1;;;;;3501:31:1;;3491:42;;3481:70;;3547:1;3544;3537:12;3562:186;3621:6;3674:2;3662:9;3653:7;3649:23;3645:32;3642:52;;;3690:1;3687;3680:12;3642:52;3713:29;3732:9;3713:29;:::i;3753:778::-;3870:6;3878;3886;3894;3947:2;3935:9;3926:7;3922:23;3918:32;3915:52;;;3963:1;3960;3953:12;3915:52;3986:36;4012:9;3986:36;:::i;:::-;3976:46;;4041:38;4075:2;4064:9;4060:18;4041:38;:::i;:::-;4031:48;;4130:2;4119:9;4115:18;4102:32;-1:-1:-1;;;;;4149:6:1;4146:30;4143:50;;;4189:1;4186;4179:12;4143:50;4212:22;;4265:4;4257:13;;4253:27;-1:-1:-1;4243:55:1;;4294:1;4291;4284:12;4243:55;4334:2;4321:16;-1:-1:-1;;;;;4352:6:1;4349:30;4346:50;;;4392:1;4389;4382:12;4346:50;4445:7;4440:2;4430:6;4427:1;4423:14;4419:2;4415:23;4411:32;4408:45;4405:65;;;4466:1;4463;4456:12;4405:65;3753:778;;;;-1:-1:-1;4497:2:1;4489:11;;-1:-1:-1;;;3753:778:1:o;4728:245::-;4816:4;4795:12;;;4809;;;4791:31;;4834:13;;4831:136;;;4889:10;4884:3;4880:20;4877:1;4870:31;4924:4;4921:1;4914:15;4952:4;4949:1;4942:15;5980:127;6041:10;6036:3;6032:20;6029:1;6022:31;6072:4;6069:1;6062:15;6096:4;6093:1;6086:15

ipfs://847486de0485f4dc2994009508f654f14b2652de2cfde3f0c13470affc2807df