Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-05-10
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts (last updated v4.8.0) (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 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)
        }
    }
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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

// File: FourClaims.sol


pragma solidity ^0.8.19;




interface Four {
    function transfer(address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract FourClaims is Ownable, ReentrancyGuard {

    Four public four;
    address public treasury;

    bytes32 public root;
    uint public constant amount = 5351009340000000000000000;
    mapping(address => bool) public claimed;

    constructor(address _four, bytes32 _merkleRoot, address _treasury) {
      four = Four(_four);
      root = _merkleRoot;
      treasury = _treasury;
    }

    //================================
    // Claim
    //================================

    event Claimed(address indexed user, uint256 amount);
    function claim(bytes32[] calldata proof) public nonReentrant {
      require(_verify(_leaf(msg.sender), proof), "INVALID_MERKLE_PROOF");
      require(!claimed[msg.sender], "ALREADY_CLAIMED");
      require(four.balanceOf(address(this)) >= amount, "OUT_OF_FUNDS");

      claimed[msg.sender] = true;
      four.transfer(msg.sender, amount);
      emit Claimed(msg.sender, amount);
    }

    function _leaf(address account)
    private pure returns (bytes32)
    {
      return keccak256(abi.encodePacked(account));
    }

    function _verify(bytes32 leaf, bytes32[] memory proof)
    private view returns (bool)
    {
      return MerkleProof.verify(proof, root, leaf);
    }

    //================================
    // Admin Functions
    //================================
    function setMerkleRoot(bytes32 _newRoot) public onlyOwner {
      root = _newRoot;
    }
    function setTreasury(address _newTreasury) public onlyOwner {
      treasury = _newTreasury;
    }

    function withdraw(uint _amount) public onlyOwner {
      four.transfer(treasury, _amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_four","type":"address"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"internalType":"address","name":"_treasury","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","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"},{"inputs":[],"name":"amount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"four","outputs":[{"internalType":"contract Four","name":"","type":"address"}],"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":[],"name":"root","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_newRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newTreasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000244b797d622d4dee8b188b03546acaabd0cf91a01162de3a915be35a00eaeb486dae82ee921c08a6411f92b91f499b4353da0712000000000000000000000000526254c12360d68d8f90c0cd9cfe5a32002e845a

-----Decoded View---------------
Arg [0] : _four (address): 0x244b797d622D4DEe8b188b03546ACAAbD0Cf91A0
Arg [1] : _merkleRoot (bytes32): 0x1162de3a915be35a00eaeb486dae82ee921c08a6411f92b91f499b4353da0712
Arg [2] : _treasury (address): 0x526254C12360D68D8F90c0cD9cFE5a32002e845A

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000244b797d622d4dee8b188b03546acaabd0cf91a0
Arg [1] : 1162de3a915be35a00eaeb486dae82ee921c08a6411f92b91f499b4353da0712
Arg [2] : 000000000000000000000000526254c12360d68d8f90c0cd9cfe5a32002e845a

16369:1682:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17950:98;;;;;;:::i;:::-;;:::i;:::-;;16449:23;;;;;-1:-1:-1;;;;;16449:23:0;;;;;;-1:-1:-1;;;;;363:32:1;;;345:51;;333:2;318:18;16449:23:0;;;;;;;;15316:103;;;:::i;17746:90::-;;;;;;:::i;:::-;;:::i;14668:87::-;14714:7;14741:6;-1:-1:-1;;;;;14741:6:0;14668:87;;16426:16;;;;;-1:-1:-1;;;;;16426:16:0;;;16507:55;;16537:25;16507:55;;;;;958:25:1;;;946:2;931:18;16507:55:0;812:177:1;16937:394:0;;;;;;:::i;:::-;;:::i;16569:39::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2070:14:1;;2063:22;2045:41;;2033:2;2018:18;16569:39:0;1905:187:1;16481:19:0;;;;;;17842:100;;;;;;:::i;:::-;;:::i;15574:201::-;;;;;;:::i;:::-;;:::i;17950:98::-;14554:13;:11;:13::i;:::-;18008:4:::1;::::0;18022:8:::1;::::0;18008:32:::1;::::0;-1:-1:-1;;;18008:32:0;;-1:-1:-1;;;;;18022:8:0;;::::1;18008:32;::::0;::::1;2453:51:1::0;2520:18;;;2513:34;;;18008:4:0;::::1;::::0;:13:::1;::::0;2426:18:1;;18008:32:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;17950:98:::0;:::o;15316:103::-;14554:13;:11;:13::i;:::-;15381:30:::1;15408:1;15381:18;:30::i;:::-;15316:103::o:0;17746:90::-;14554:13;:11;:13::i;:::-;17813:4:::1;:15:::0;17746:90::o;16937:394::-;11939:21;:19;:21::i;:::-;17438:25;;;17029:10:::1;5340:2:1::0;5336:15;-1:-1:-1;;5332:53:1;17438:25:0;;;;5320:66:1;;;;17438:25:0;;;;;;;;;5402:12:1;;;;17438:25:0;;;17428:36;;;;;17015:33:::1;::::0;17042:5:::1;;17015:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;17015:7:0::1;::::0;-1:-1:-1;;;17015:33:0:i:1;:::-;17007:66;;;::::0;-1:-1:-1;;;17007:66:0;;3042:2:1;17007:66:0::1;::::0;::::1;3024:21:1::0;3081:2;3061:18;;;3054:30;-1:-1:-1;;;3100:18:1;;;3093:50;3160:18;;17007:66:0::1;;;;;;;;;17099:10;17091:19;::::0;;;:7:::1;:19;::::0;;;;;::::1;;17090:20;17082:48;;;::::0;-1:-1:-1;;;17082:48:0;;3391:2:1;17082:48:0::1;::::0;::::1;3373:21:1::0;3430:2;3410:18;;;3403:30;-1:-1:-1;;;3449:18:1;;;3442:45;3504:18;;17082:48:0::1;3189:339:1::0;17082:48:0::1;17147:4;::::0;:29:::1;::::0;-1:-1:-1;;;17147:29:0;;17170:4:::1;17147:29;::::0;::::1;345:51:1::0;16537:25:0::1;::::0;-1:-1:-1;;;;;17147:4:0::1;::::0;:14:::1;::::0;318:18:1;;17147:29:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:39;;17139:64;;;::::0;-1:-1:-1;;;17139:64:0;;3924:2:1;17139:64:0::1;::::0;::::1;3906:21:1::0;3963:2;3943:18;;;3936:30;-1:-1:-1;;;3982:18:1;;;3975:42;4034:18;;17139:64:0::1;3722:336:1::0;17139:64:0::1;17222:10;17214:19;::::0;;;:7:::1;:19;::::0;;;;;;:26;;-1:-1:-1;;17214:26:0::1;17236:4;17214:26;::::0;;17249:4:::1;::::0;:33;;-1:-1:-1;;;17249:33:0;;::::1;::::0;::::1;2453:51:1::0;;;;16537:25:0::1;2520:18:1::0;;;2513:34;-1:-1:-1;;;;;17249:4:0::1;::::0;:13:::1;::::0;2426:18:1;;17249:33:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;17296:27:0::1;::::0;16537:25:::1;958::1::0;;17304:10:0::1;::::0;17296:27:::1;::::0;946:2:1;931:18;17296:27:0::1;;;;;;;11983:20:::0;11377:1;12503:22;;12320:213;17842:100;14554:13;:11;:13::i;:::-;17911:8:::1;:23:::0;;-1:-1:-1;;;;;;17911:23:0::1;-1:-1:-1::0;;;;;17911:23:0;;;::::1;::::0;;;::::1;::::0;;17842:100::o;15574:201::-;14554:13;:11;:13::i;:::-;-1:-1:-1;;;;;15663:22:0;::::1;15655:73;;;::::0;-1:-1:-1;;;15655:73:0;;4265:2:1;15655:73:0::1;::::0;::::1;4247:21:1::0;4304:2;4284:18;;;4277:30;4343:34;4323:18;;;4316:62;-1:-1:-1;;;4394:18:1;;;4387:36;4440:19;;15655:73:0::1;4063:402:1::0;15655:73:0::1;15739:28;15758:8;15739:18;:28::i;:::-;15574:201:::0;:::o;14833:132::-;14714:7;14741:6;-1:-1:-1;;;;;14741:6:0;13299:10;14897:23;14889:68;;;;-1:-1:-1;;;14889:68:0;;4672:2:1;14889:68:0;;;4654:21:1;;;4691:18;;;4684:30;4750:34;4730:18;;;4723:62;4802:18;;14889:68:0;4470:356:1;15935:191:0;16009:16;16028:6;;-1:-1:-1;;;;;16045:17:0;;;-1:-1:-1;;;;;;16045:17:0;;;;;;16078:40;;16028:6;;;;;;;16078:40;;16009:16;16078:40;15998:128;15935:191;:::o;12019:293::-;11421:1;12153:7;;:19;12145:63;;;;-1:-1:-1;;;12145:63:0;;5033:2:1;12145:63:0;;;5015:21:1;5072:2;5052:18;;;5045:30;5111:33;5091:18;;;5084:61;5162:18;;12145:63:0;4831:355:1;12145:63:0;11421:1;12286:7;:18;12019:293::o;17480:154::-;17562:4;17589:37;17608:5;17615:4;;17621;17589:18;:37::i;:::-;17582:44;17480:154;-1:-1:-1;;;17480:154:0:o;1255:190::-;1380:4;1433;1404:25;1417:5;1424:4;1404:12;:25::i;:::-;:33;;1255:190;-1:-1:-1;;;;1255:190:0:o;2122:296::-;2205:7;2248:4;2205:7;2263:118;2287:5;:12;2283:1;:16;2263:118;;;2336:33;2346:12;2360:5;2366:1;2360:8;;;;;;;;:::i;:::-;;;;;;;2336:9;:33::i;:::-;2321:48;-1:-1:-1;2301:3:0;;;;:::i;:::-;;;;2263:118;;;-1:-1:-1;2398:12:0;2122:296;-1:-1:-1;;;2122:296:0:o;9162:149::-;9225:7;9256:1;9252;:5;:51;;9387:13;9481:15;;;9517:4;9510:15;;;9564:4;9548:21;;9252:51;;;9387:13;9481:15;;;9517:4;9510:15;;;9564:4;9548:21;;9260:20;9319:268;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;994:615::-;1080:6;1088;1141:2;1129:9;1120:7;1116:23;1112:32;1109:52;;;1157:1;1154;1147:12;1109:52;1197:9;1184:23;1226:18;1267:2;1259:6;1256:14;1253:34;;;1283:1;1280;1273:12;1253:34;1321:6;1310:9;1306:22;1296:32;;1366:7;1359:4;1355:2;1351:13;1347:27;1337:55;;1388:1;1385;1378:12;1337:55;1428:2;1415:16;1454:2;1446:6;1443:14;1440:34;;;1470:1;1467;1460:12;1440:34;1523:7;1518:2;1508:6;1505:1;1501:14;1497:2;1493:23;1489:32;1486:45;1483:65;;;1544:1;1541;1534:12;1483:65;1575:2;1567:11;;;;;1597:6;;-1:-1:-1;994:615:1;;-1:-1:-1;;;;994:615:1:o;1614:286::-;1673:6;1726:2;1714:9;1705:7;1701:23;1697:32;1694:52;;;1742:1;1739;1732:12;1694:52;1768:23;;-1:-1:-1;;;;;1820:31:1;;1810:42;;1800:70;;1866:1;1863;1856:12;2558:277;2625:6;2678:2;2666:9;2657:7;2653:23;2649:32;2646:52;;;2694:1;2691;2684:12;2646:52;2726:9;2720:16;2779:5;2772:13;2765:21;2758:5;2755:32;2745:60;;2801:1;2798;2791:12;3533:184;3603:6;3656:2;3644:9;3635:7;3631:23;3627:32;3624:52;;;3672:1;3669;3662:12;3624:52;-1:-1:-1;3695:16:1;;3533:184;-1:-1:-1;3533:184:1:o;5425:127::-;5486:10;5481:3;5477:20;5474:1;5467:31;5517:4;5514:1;5507:15;5541:4;5538:1;5531:15;5557:232;5596:3;5617:17;;;5614:140;;5676:10;5671:3;5667:20;5664:1;5657:31;5711:4;5708:1;5701:15;5739:4;5736:1;5729:15;5614:140;-1:-1:-1;5781:1:1;5770:13;;5557:232::o

ipfs://720ac6d6783e5a41fdf6729c76b8877e95c4cbc6e479cce6b31a5e1a88748e36