Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at moonbeam.moonscan.io on 2023-08-07
*/

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

interface IReferralStorage {
    function codeOwners(bytes32 _code) external view returns (address);
    function getReferralInfo(address _account) external view returns (bytes32, address);
    function getOwnedCodes(address _account) external view returns (bytes32[] memory);
    function setReferralCodeByUser(bytes32 _code) external;
}

// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

contract ReferralStorage is IReferralStorage {
    using EnumerableSet for EnumerableSet.Bytes32Set;

    mapping(bytes32 => address) public override codeOwners;
    mapping(address => bytes32) public referralCodes;
    mapping(address => EnumerableSet.Bytes32Set) private _ownedCodes;

    event SetReferralCode(address account, bytes32 code);
    event RegisterCode(address account, bytes32 code);
    event SetCodeOwner(address account, address newAccount, bytes32 code);

    error InvalidCode(bytes32 code);
    error CodeAlreadyExists();
    error NotCodeOwner();

    function setReferralCodeByUser(bytes32 _code) override external {
        _setReferralCode(msg.sender, _code);
    }

    function registerCode(bytes32 _code) external {
        if (_code == bytes32(0)) revert InvalidCode(_code);
        if (codeOwners[_code] != address(0)) revert CodeAlreadyExists();

        codeOwners[_code] = msg.sender;
        _ownedCodes[msg.sender].add(_code);
        emit RegisterCode(msg.sender, _code);
    }

    function setCodeOwner(bytes32 _code, address _newAccount) external {
        if (_code == bytes32(0)) revert InvalidCode(_code);

        address account = codeOwners[_code];
        if (msg.sender != account) revert NotCodeOwner();

        codeOwners[_code] = _newAccount;
        _ownedCodes[msg.sender].remove(_code);
        _ownedCodes[_newAccount].add(_code);
        emit SetCodeOwner(msg.sender, _newAccount, _code);
    }

    function getOwnedCodes(address _account) override external view returns (bytes32[] memory) {
        return _ownedCodes[_account].values();
    }

    function getReferralInfo(address _account) override external view returns (bytes32, address) {
        bytes32 code = referralCodes[_account];
        address referrer;
        if (code != bytes32(0)) {
            referrer = codeOwners[code];
        }
        return (code, referrer);
    }

    function _setReferralCode(address _account, bytes32 _code) private {
        referralCodes[_account] = _code;
        emit SetReferralCode(_account, _code);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"CodeAlreadyExists","type":"error"},{"inputs":[{"internalType":"bytes32","name":"code","type":"bytes32"}],"name":"InvalidCode","type":"error"},{"inputs":[],"name":"NotCodeOwner","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bytes32","name":"code","type":"bytes32"}],"name":"RegisterCode","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"newAccount","type":"address"},{"indexed":false,"internalType":"bytes32","name":"code","type":"bytes32"}],"name":"SetCodeOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bytes32","name":"code","type":"bytes32"}],"name":"SetReferralCode","type":"event"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"codeOwners","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getOwnedCodes","outputs":[{"internalType":"bytes32[]","name":"","type":"bytes32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getReferralInfo","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"referralCodes","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_code","type":"bytes32"}],"name":"registerCode","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_code","type":"bytes32"},{"internalType":"address","name":"_newAccount","type":"address"}],"name":"setCodeOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_code","type":"bytes32"}],"name":"setReferralCodeByUser","outputs":[],"stateMutability":"nonpayable","type":"function"}]

608060405234801561001057600080fd5b50610752806100206000396000f3fe608060405234801561001057600080fd5b506004361061007d5760003560e01c806336def2c81161005b57806336def2c8146100ec5780639534dd3e146100ff578063c8b3c4601461012d578063ed8431341461016e57600080fd5b8063170018fe1461008257806321874ae2146100975780632da116b2146100cc575b600080fd5b61009561009036600461060f565b610181565b005b6100aa6100a5366004610644565b61018e565b604080519283526001600160a01b039091166020830152015b60405180910390f35b6100df6100da366004610644565b6101d4565b6040516100c3919061065f565b6100956100fa36600461060f565b6101fe565b61011f61010d366004610644565b60016020526000908152604090205481565b6040519081526020016100c3565b61015661013b36600461060f565b6000602081905290815260409020546001600160a01b031681565b6040516001600160a01b0390911681526020016100c3565b61009561017c3660046106a3565b6102d9565b61018b33826103ed565b50565b6001600160a01b03811660009081526001602052604081205481908181156101ca57506000818152602081905260409020546001600160a01b03165b9094909350915050565b6001600160a01b03811660009081526002602052604090206060906101f890610445565b92915050565b806102245760405163e33ab65360e01b8152600481018290526024015b60405180910390fd5b6000818152602081905260409020546001600160a01b03161561025a57604051636b3d055d60e11b815260040160405180910390fd5b600081815260208181526040808320805473ffffffffffffffffffffffffffffffffffffffff19163390811790915583526002909152902061029c9082610459565b5060408051338152602081018390527f04f82286a2a3b2ee5c8555de8304dfe2ea70991613213184b73a9e408d2d8029910160405180910390a150565b816102fa5760405163e33ab65360e01b81526004810183905260240161021b565b6000828152602081905260409020546001600160a01b031633811461033257604051635b774fb360e01b815260040160405180910390fd5b600083815260208181526040808320805473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0387161790553383526002909152902061037b9084610465565b506001600160a01b038216600090815260026020526040902061039e9084610459565b50604080513381526001600160a01b03841660208201529081018490527f5640856798d41ce9ca0a109b54c20a06eb99ba9c36ab4547115dafb8473cf3979060600160405180910390a1505050565b6001600160a01b038216600081815260016020908152604091829020849055815192835282018390527f60750994fdf9995c19bee1ac3f38a6fbf271ecd405e8bd0d55c99f7f14f86e0f910160405180910390a15050565b6060600061045283610471565b9392505050565b600061045283836104cd565b6000610452838361051c565b6060816000018054806020026020016040519081016040528092919081815260200182805480156104c157602002820191906000526020600020905b8154815260200190600101908083116104ad575b50505050509050919050565b6000818152600183016020526040812054610514575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556101f8565b5060006101f8565b600081815260018301602052604081205480156106055760006105406001836106cf565b8554909150600090610554906001906106cf565b90508181146105b9576000866000018281548110610574576105746106f0565b9060005260206000200154905080876000018481548110610597576105976106f0565b6000918252602080832090910192909255918252600188019052604090208390555b85548690806105ca576105ca610706565b6001900381819060005260206000200160009055905585600101600086815260200190815260200160002060009055600193505050506101f8565b60009150506101f8565b60006020828403121561062157600080fd5b5035919050565b80356001600160a01b038116811461063f57600080fd5b919050565b60006020828403121561065657600080fd5b61045282610628565b6020808252825182820181905260009190848201906040850190845b818110156106975783518352928401929184019160010161067b565b50909695505050505050565b600080604083850312156106b657600080fd5b823591506106c660208401610628565b90509250929050565b818103818111156101f857634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052603160045260246000fdfea26469706673582212205f4447f3d915d1fe97391a379022ed30d238647880f4d1baa7fee3df6fbd558c64736f6c63430008130033

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

13688:2127:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14278:118;;;;;;:::i;:::-;;:::i;:::-;;15340:299;;;;;;:::i;:::-;;:::i;:::-;;;;765:25:1;;;-1:-1:-1;;;;;826:55:1;;;821:2;806:18;;799:83;738:18;15340:299:0;;;;;;;;15185:147;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;14404:324::-;;;;;;:::i;:::-;;:::i;13858:48::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;1676:25:1;;;1664:2;1649:18;13858:48:0;1530:177:1;13797:54:0;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;13797:54:0;;;;;;-1:-1:-1;;;;;1876:55:1;;;1858:74;;1846:2;1831:18;13797:54:0;1712:226:1;14736:441:0;;;;;;:::i;:::-;;:::i;14278:118::-;14353:35;14370:10;14382:5;14353:16;:35::i;:::-;14278:118;:::o;15340:299::-;-1:-1:-1;;;;;15459:23:0;;15415:7;15459:23;;;:13;:23;;;;;;15415:7;;;15524:18;;15520:78;;-1:-1:-1;15570:10:0;:16;;;;;;;;;;;-1:-1:-1;;;;;15570:16:0;15520:78;15616:4;;15622:8;;-1:-1:-1;15340:299:0;-1:-1:-1;;15340:299:0:o;15185:147::-;-1:-1:-1;;;;;15294:21:0;;;;;;:11;:21;;;;;15258:16;;15294:30;;:28;:30::i;:::-;15287:37;15185:147;-1:-1:-1;;15185:147:0:o;14404:324::-;14465:5;14461:50;;14493:18;;-1:-1:-1;;;14493:18:0;;;;;1676:25:1;;;1649:18;;14493::0;;;;;;;;14461:50;14555:1;14526:17;;;;;;;;;;;-1:-1:-1;;;;;14526:17:0;:31;14522:63;;14566:19;;-1:-1:-1;;;14566:19:0;;;;;;;;;;;14522:63;14598:10;:17;;;;;;;;;;;:30;;-1:-1:-1;;14598:30:0;14618:10;14598:30;;;;;;14639:23;;:11;:23;;;;;:34;;14609:5;14639:27;:34::i;:::-;-1:-1:-1;14689:31:0;;;14702:10;2376:74:1;;2481:2;2466:18;;2459:34;;;14689:31:0;;2349:18:1;14689:31:0;;;;;;;14404:324;:::o;14736:441::-;14818:5;14814:50;;14846:18;;-1:-1:-1;;;14846:18:0;;;;;1676:25:1;;;1649:18;;14846::0;1530:177:1;14814:50:0;14877:15;14895:17;;;;;;;;;;;-1:-1:-1;;;;;14895:17:0;14927:10;:21;;14923:48;;14957:14;;-1:-1:-1;;;14957:14:0;;;;;;;;;;;14923:48;14984:10;:17;;;;;;;;;;;:31;;-1:-1:-1;;14984:31:0;-1:-1:-1;;;;;14984:31:0;;;;;15038:10;15026:23;;:11;:23;;;;;:37;;14984:17;15026:30;:37::i;:::-;-1:-1:-1;;;;;;15074:24:0;;;;;;:11;:24;;;;;:35;;15103:5;15074:28;:35::i;:::-;-1:-1:-1;15125:44:0;;;15138:10;2767:34:1;;-1:-1:-1;;;;;2837:15:1;;2832:2;2817:18;;2810:43;2869:18;;;2862:34;;;15125:44:0;;2694:2:1;2679:18;15125:44:0;;;;;;;14803:374;14736:441;;:::o;15647:165::-;-1:-1:-1;;;;;15725:23:0;;;;;;:13;:23;;;;;;;;;:31;;;15772:32;;2376:74:1;;;2466:18;;2459:34;;;15772:32:0;;2349:18:1;15772:32:0;;;;;;;15647:165;;:::o;8331:310::-;8394:16;8423:22;8448:19;8456:3;8448:7;:19::i;:::-;8423:44;8331:310;-1:-1:-1;;;8331:310:0:o;6435:125::-;6505:4;6529:23;6534:3;6546:5;6529:4;:23::i;6736:131::-;6809:4;6833:26;6841:3;6853:5;6833:7;:26::i;6070:111::-;6126:16;6162:3;:11;;6155:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6070:111;;;:::o;2626:414::-;2689:4;4819:19;;;:12;;;:19;;;;;;2706:327;;-1:-1:-1;2749:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;2932:18;;2910:19;;;:12;;;:19;;;;;;:40;;;;2965:11;;2706:327;-1:-1:-1;3016:5:0;3009:12;;3216:1420;3282:4;3421:19;;;:12;;;:19;;;;;;3457:15;;3453:1176;;3832:21;3856:14;3869:1;3856:10;:14;:::i;:::-;3905:18;;3832:38;;-1:-1:-1;3885:17:0;;3905:22;;3926:1;;3905:22;:::i;:::-;3885:42;;3961:13;3948:9;:26;3944:405;;3995:17;4015:3;:11;;4027:9;4015:22;;;;;;;;:::i;:::-;;;;;;;;;3995:42;;4169:9;4140:3;:11;;4152:13;4140:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;4254:23;;;:12;;;:23;;;;;:36;;;3944:405;4430:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;4525:3;:12;;:19;4538:5;4525:19;;;;;;;;;;;4518:26;;;4568:4;4561:11;;;;;;;3453:1176;4612:5;4605:12;;;;;14:180:1;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;199:196::-;267:20;;-1:-1:-1;;;;;316:54:1;;306:65;;296:93;;385:1;382;375:12;296:93;199:196;;;:::o;400:186::-;459:6;512:2;500:9;491:7;487:23;483:32;480:52;;;528:1;525;518:12;480:52;551:29;570:9;551:29;:::i;893:632::-;1064:2;1116:21;;;1186:13;;1089:18;;;1208:22;;;1035:4;;1064:2;1287:15;;;;1261:2;1246:18;;;1035:4;1330:169;1344:6;1341:1;1338:13;1330:169;;;1405:13;;1393:26;;1474:15;;;;1439:12;;;;1366:1;1359:9;1330:169;;;-1:-1:-1;1516:3:1;;893:632;-1:-1:-1;;;;;;893:632:1:o;1943:254::-;2011:6;2019;2072:2;2060:9;2051:7;2047:23;2043:32;2040:52;;;2088:1;2085;2078:12;2040:52;2124:9;2111:23;2101:33;;2153:38;2187:2;2176:9;2172:18;2153:38;:::i;:::-;2143:48;;1943:254;;;;;:::o;2907:225::-;2974:9;;;2995:11;;;2992:134;;;3048:10;3043:3;3039:20;3036:1;3029:31;3083:4;3080:1;3073:15;3111:4;3108:1;3101:15;3137:127;3198:10;3193:3;3189:20;3186:1;3179:31;3229:4;3226:1;3219:15;3253:4;3250:1;3243:15;3269:127;3330:10;3325:3;3321:20;3318:1;3311:31;3361:4;3358:1;3351:15;3385:4;3382:1;3375:15

ipfs://5f4447f3d915d1fe97391a379022ed30d238647880f4d1baa7fee3df6fbd558c