Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Arbiscan.io on 2024-05-14
*/

// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


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

pragma solidity ^0.8.0;

/**
 * @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 rebuilds 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 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proofLen - 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 from 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) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                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 rebuilds 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 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proofLen - 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 from 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) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                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)
        }
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

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

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

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

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

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

// File: Compensation/compensation.sol


pragma solidity ^0.8.18;




contract Compensation is Ownable {

    constructor (
        address contractAddress,
        uint256 _begin,
        uint256 _end,
        bytes32 _merkleRoot
    ) {
        MX = IERC20(contractAddress);
        begin = _begin;
        end = _end;
        merkleRoot = _merkleRoot;
    }

    IERC20 public MX;
    uint256 public begin;
    uint256 public end;
    mapping (address => bool) public alreadyClaimed;

/** Verify **/
    bytes32 public merkleRoot;

    function setRoot (bytes32 _merkleRoot) public onlyOwner {
        merkleRoot = _merkleRoot;
    }

    function verify (address sender, uint256 compensation, bytes32[] calldata merkleProof) public view returns (bool) {
        bytes32 leaf = keccak256(abi.encodePacked(sender, compensation));
        return MerkleProof.verify(merkleProof, merkleRoot, leaf);
    }

/** Claim **/
    function Claim (uint256 compensation, bytes32[] calldata merkleProof) public {
        require(block.timestamp >= begin, "Not begin.");
        require(block.timestamp <= end, "Claim is ended.");
        require(!alreadyClaimed[msg.sender], "Already claimed.");
        require(verify(msg.sender, compensation, merkleProof), "Wrong compensation input.");
        MX.transfer(msg.sender, compensation);
        alreadyClaimed[msg.sender] = true;
        emit claimRecord (msg.sender, compensation, block.timestamp);
    }
    event claimRecord (address user, uint256 compensation, uint256 time);

/** Withdraw **/
    function withdraw (address receipent) public onlyOwner {
        MX.transfer(receipent, MX.balanceOf(address(this)));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"uint256","name":"_begin","type":"uint256"},{"internalType":"uint256","name":"_end","type":"uint256"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"compensation","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"claimRecord","type":"event"},{"inputs":[{"internalType":"uint256","name":"compensation","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"Claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"MX","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"alreadyClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"begin","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"end","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"compensation","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"verify","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receipent","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000dc1b3f63944e0ff11dbad513fe4175fc0466ce2e000000000000000000000000000000000000000000000000000000006644a3c000000000000000000000000000000000000000000000000000000000664c8cc0d1dfea47fd4a26fdccbcfceab48c0e40c0f8352a8626bf0d6ceda09f7c34fb10

-----Decoded View---------------
Arg [0] : contractAddress (address): 0xdc1B3F63944e0ff11dbaD513FE4175fc0466cE2E
Arg [1] : _begin (uint256): 1715774400
Arg [2] : _end (uint256): 1716292800
Arg [3] : _merkleRoot (bytes32): 0xd1dfea47fd4a26fdccbcfceab48c0e40c0f8352a8626bf0d6ceda09f7c34fb10

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000dc1b3f63944e0ff11dbad513fe4175fc0466ce2e
Arg [1] : 000000000000000000000000000000000000000000000000000000006644a3c0
Arg [2] : 00000000000000000000000000000000000000000000000000000000664c8cc0
Arg [3] : d1dfea47fd4a26fdccbcfceab48c0e40c0f8352a8626bf0d6ceda09f7c34fb10

16400:1642:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16733:20;;;;;;;;;160:25:1;;;148:2;133:18;16733:20:0;;;;;;;;16857:25;;;;;;17914:125;;;;;;:::i;:::-;;:::i;:::-;;12660:103;;;:::i;16998:264::-;;;;;;:::i;:::-;;:::i;:::-;;;1868:14:1;;1861:22;1843:41;;1831:2;1816:18;16998:264:0;1703:187:1;12019:87:0;12065:7;12092:6;-1:-1:-1;;;;;12092:6:0;12019:87;;;-1:-1:-1;;;;;2059:32:1;;;2041:51;;2029:2;2014:18;12019:87:0;1895:203:1;16710:16:0;;;;;-1:-1:-1;;;;;16710:16:0;;;16891:99;;;;;;:::i;:::-;;:::i;16760:18::-;;;;;;12918:201;;;;;;:::i;:::-;;:::i;16785:47::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;17285:528;;;;;;:::i;:::-;;:::i;17914:125::-;11905:13;:11;:13::i;:::-;17980:2:::1;::::0;18003:27:::1;::::0;-1:-1:-1;;;18003:27:0;;18024:4:::1;18003:27;::::0;::::1;2041:51:1::0;-1:-1:-1;;;;;17980:2:0;;::::1;::::0;:11:::1;::::0;17992:9;;17980:2;;18003:12:::1;::::0;2014:18:1;;18003:27:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17980:51;::::0;-1:-1:-1;;;;;;17980:51:0::1;::::0;;;;;;-1:-1:-1;;;;;3401:32:1;;;17980:51:0::1;::::0;::::1;3383::1::0;3450:18;;;3443:34;3356:18;;17980:51:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;17914:125:::0;:::o;12660:103::-;11905:13;:11;:13::i;:::-;12725:30:::1;12752:1;12725:18;:30::i;:::-;12660:103::o:0;16998:264::-;17148:38;;-1:-1:-1;;3947:2:1;3943:15;;;3939:53;17148:38:0;;;3927:66:1;4009:12;;;4002:28;;;17106:4:0;;;;4046:12:1;;17148:38:0;;;;;;;;;;;;17138:49;;;;;;17123:64;;17205:49;17224:11;;17205:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;17237:10:0;;;-1:-1:-1;17249:4:0;;-1:-1:-1;17205:18:0;:49::i;:::-;17198:56;16998:264;-1:-1:-1;;;;;;16998:264:0:o;16891:99::-;11905:13;:11;:13::i;:::-;16958:10:::1;:24:::0;16891:99::o;12918:201::-;11905:13;:11;:13::i;:::-;-1:-1:-1;;;;;13007:22:0;::::1;12999:73;;;::::0;-1:-1:-1;;;12999:73:0;;4271:2:1;12999:73:0::1;::::0;::::1;4253:21:1::0;4310:2;4290:18;;;4283:30;4349:34;4329:18;;;4322:62;-1:-1:-1;;;4400:18:1;;;4393:36;4446:19;;12999:73:0::1;;;;;;;;;13083:28;13102:8;13083:18;:28::i;:::-;12918:201:::0;:::o;17285:528::-;17400:5;;17381:15;:24;;17373:47;;;;-1:-1:-1;;;17373:47:0;;4678:2:1;17373:47:0;;;4660:21:1;4717:2;4697:18;;;4690:30;-1:-1:-1;;;4736:18:1;;;4729:40;4786:18;;17373:47:0;4476:334:1;17373:47:0;17458:3;;17439:15;:22;;17431:50;;;;-1:-1:-1;;;17431:50:0;;5017:2:1;17431:50:0;;;4999:21:1;5056:2;5036:18;;;5029:30;-1:-1:-1;;;5075:18:1;;;5068:45;5130:18;;17431:50:0;4815:339:1;17431:50:0;17516:10;17501:26;;;;:14;:26;;;;;;;;17500:27;17492:56;;;;-1:-1:-1;;;17492:56:0;;5361:2:1;17492:56:0;;;5343:21:1;5400:2;5380:18;;;5373:30;-1:-1:-1;;;5419:18:1;;;5412:46;5475:18;;17492:56:0;5159:340:1;17492:56:0;17567:45;17574:10;17586:12;17600:11;;17567:6;:45::i;:::-;17559:83;;;;-1:-1:-1;;;17559:83:0;;5706:2:1;17559:83:0;;;5688:21:1;5745:2;5725:18;;;5718:30;5784:27;5764:18;;;5757:55;5829:18;;17559:83:0;5504:349:1;17559:83:0;17653:2;;:37;;-1:-1:-1;;;17653:37:0;;17665:10;17653:37;;;3383:51:1;3450:18;;;3443:34;;;-1:-1:-1;;;;;17653:2:0;;;;:11;;3356:18:1;;17653:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;17716:10:0;17701:26;;;;:14;:26;;;;;;;;;:33;;-1:-1:-1;;17701:33:0;17730:4;17701:33;;;17750:55;;6060:51:1;;;6127:18;;6120:34;;;17789:15:0;6170:18:1;;;6163:34;17750:55:0;;6048:2:1;6033:18;17750:55:0;;;;;;;17285:528;;;:::o;12184:132::-;12065:7;12092:6;-1:-1:-1;;;;;12092:6:0;10650:10;12248:23;12240:68;;;;-1:-1:-1;;;12240:68:0;;6410:2:1;12240:68:0;;;6392:21:1;;;6429:18;;;6422:30;6488:34;6468:18;;;6461:62;6540:18;;12240:68:0;6208:356:1;13279:191:0;13353:16;13372:6;;-1:-1:-1;;;;;13389:17:0;;;-1:-1:-1;;;;;;13389:17:0;;;;;;13422:40;;13372:6;;;;;;;13422:40;;13353:16;13422:40;13342:128;13279:191;:::o;1222:156::-;1313:4;1366;1337:25;1350:5;1357:4;1337:12;:25::i;:::-;:33;;1222:156;-1:-1:-1;;;;1222:156:0:o;2021:296::-;2104:7;2147:4;2104:7;2162:118;2186:5;:12;2182:1;:16;2162:118;;;2235:33;2245:12;2259:5;2265:1;2259:8;;;;;;;;:::i;:::-;;;;;;;2235:9;:33::i;:::-;2220:48;-1:-1:-1;2200:3:0;;;;:::i;:::-;;;;2162:118;;;-1:-1:-1;2297:12:0;2021:296;-1:-1:-1;;;2021:296:0:o;9459:149::-;9522:7;9553:1;9549;:5;:51;;9684:13;9778:15;;;9814:4;9807:15;;;9861:4;9845:21;;9549:51;;;9684:13;9778:15;;;9814:4;9807:15;;;9861:4;9845:21;;9557:20;9542:58;9459:149;-1:-1:-1;;;9459:149:0:o;378:173:1:-;446:20;;-1:-1:-1;;;;;495:31:1;;485:42;;475:70;;541:1;538;531:12;475:70;378:173;;;:::o;556:186::-;615:6;668:2;656:9;647:7;643:23;639:32;636:52;;;684:1;681;674:12;636:52;707:29;726:9;707:29;:::i;747:367::-;810:8;820:6;874:3;867:4;859:6;855:17;851:27;841:55;;892:1;889;882:12;841:55;-1:-1:-1;915:20:1;;958:18;947:30;;944:50;;;990:1;987;980:12;944:50;1027:4;1019:6;1015:17;1003:29;;1087:3;1080:4;1070:6;1067:1;1063:14;1055:6;1051:27;1047:38;1044:47;1041:67;;;1104:1;1101;1094:12;1041:67;747:367;;;;;:::o;1119:579::-;1223:6;1231;1239;1247;1300:2;1288:9;1279:7;1275:23;1271:32;1268:52;;;1316:1;1313;1306:12;1268:52;1339:29;1358:9;1339:29;:::i;:::-;1329:39;;1415:2;1404:9;1400:18;1387:32;1377:42;;1470:2;1459:9;1455:18;1442:32;1497:18;1489:6;1486:30;1483:50;;;1529:1;1526;1519:12;1483:50;1568:70;1630:7;1621:6;1610:9;1606:22;1568:70;:::i;:::-;1119:579;;;;-1:-1:-1;1657:8:1;-1:-1:-1;;;;1119:579:1:o;2325:180::-;2384:6;2437:2;2425:9;2416:7;2412:23;2408:32;2405:52;;;2453:1;2450;2443:12;2405:52;-1:-1:-1;2476:23:1;;2325:180;-1:-1:-1;2325:180:1:o;2510:505::-;2605:6;2613;2621;2674:2;2662:9;2653:7;2649:23;2645:32;2642:52;;;2690:1;2687;2680:12;2642:52;2726:9;2713:23;2703:33;;2787:2;2776:9;2772:18;2759:32;2814:18;2806:6;2803:30;2800:50;;;2846:1;2843;2836:12;2800:50;2885:70;2947:7;2938:6;2927:9;2923:22;2885:70;:::i;:::-;2510:505;;2974:8;;-1:-1:-1;2859:96:1;;-1:-1:-1;;;;2510:505:1:o;3020:184::-;3090:6;3143:2;3131:9;3122:7;3118:23;3114:32;3111:52;;;3159:1;3156;3149:12;3111:52;-1:-1:-1;3182:16:1;;3020:184;-1:-1:-1;3020:184:1:o;3488:277::-;3555:6;3608:2;3596:9;3587:7;3583:23;3579:32;3576:52;;;3624:1;3621;3614:12;3576:52;3656:9;3650:16;3709:5;3702:13;3695:21;3688:5;3685:32;3675:60;;3731:1;3728;3721:12;6569:127;6630:10;6625:3;6621:20;6618:1;6611:31;6661:4;6658:1;6651:15;6685:4;6682:1;6675:15;6701:232;6740:3;6761:17;;;6758:140;;6820:10;6815:3;6811:20;6808:1;6801:31;6855:4;6852:1;6845:15;6883:4;6880:1;6873:15;6758:140;-1:-1:-1;6925:1:1;6914:13;;6701:232::o

ipfs://13978b3f07625932ba72b32163b5381dd8c8a75eb6afbb00d987e6f9cd1ba552