Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library MerkleProof
•    - function verify(bytes32[] memory proo ...
•    - function verifyCalldata(bytes32[] cal ...
•    - 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 _msgSender()
•    - function _msgData()
•    - function _contextSuffixLength()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address from, a ...
•  contract bitcoinAirdrop is Ownable ... *
•    - function onlyOwner_updateAirdropOpen( ...
•    - function onlyOwner_setRound(uint256 _ ...
•    - function claim(
•    - function verify(
•    - function currentRound(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-05-03
*/

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


// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.20;

/**
 * @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 The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @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}
     */
    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.
     */
    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}
     */
    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.
     */
    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.
     */
    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).
     */
    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.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // 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) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            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.
     */
    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.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // 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) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Sorts the pair (a, b) and hashes the result.
     */
    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    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 (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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 v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// File: bitcoinAirdrop.sol


pragma solidity ^0.8.20;




contract bitcoinAirdrop is Ownable(msg.sender) {

    uint256 decimalMultiplier = 100000000; //decimals 8
    uint256 roundNumber = 1;
    address public airdropTokenAddress;
    address public tokenOwner;
    bool public airdropOpen = true;
    bytes32 public merkleRoot;

    mapping(address => uint256) public claimedByWallet;

    constructor(bytes32 _merkleRoot, address _airdropTokenAddress, address _tokenOwner)  {
        merkleRoot = _merkleRoot;
        airdropTokenAddress = _airdropTokenAddress;
        tokenOwner = _tokenOwner;
    }

    function onlyOwner_updateAirdropOpen(bool _airdropOpen) public onlyOwner {
        airdropOpen = _airdropOpen;
    }

    function onlyOwner_setRound(uint256 _roundNumber, bytes32 _merkleRoot) public onlyOwner {
        roundNumber = _roundNumber;
        merkleRoot = _merkleRoot;
    }

    function claim(
        address _receiver,
        uint256 _amount,
        bytes32[] calldata _proof
    ) external {
        uint256 amount = _amount*decimalMultiplier;
        require(airdropOpen, "Airdrop not open");
        require(claimedByWallet[_receiver] < roundNumber, "Address already claimed this round");
        require(verify(_receiver, _amount, _proof), "Invalid proof and/or amount");

        claimedByWallet[_receiver] = roundNumber;

        require(IERC20(airdropTokenAddress).transferFrom(tokenOwner, _receiver, amount), "transfer failed");
    }

    function verify(
        address _receiver,
        uint256 _amount,
        bytes32[] calldata _proof
    ) public view returns (bool){
        bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(_receiver, _amount))));
        return MerkleProof.verify(_proof, merkleRoot, leaf);
    }
   
    function currentRound(
    ) public view returns (uint256){
        return roundNumber;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"internalType":"address","name":"_airdropTokenAddress","type":"address"},{"internalType":"address","name":"_tokenOwner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","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":[],"name":"airdropOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"airdropTokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimedByWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentRound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_roundNumber","type":"uint256"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"onlyOwner_setRound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_airdropOpen","type":"bool"}],"name":"onlyOwner_updateAirdropOpen","outputs":[],"stateMutability":"nonpayable","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":"tokenOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"verify","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

123c5d072e1473597fa06d685f53b296040c3f1538bf8017b3ea0bad73c929d1000000000000000000000000c0bc84e95864bdfdcd1ccfb8a3aa522e79ca14100000000000000000000000007ad001328f039fd07d4cb77a82eafb309dae6790

-----Decoded View---------------
Arg [0] : _merkleRoot (bytes32): 0x123c5d072e1473597fa06d685f53b296040c3f1538bf8017b3ea0bad73c929d1
Arg [1] : _airdropTokenAddress (address): 0xC0BC84e95864BdfDCd1CCFB8A3AA522E79Ca1410
Arg [2] : _tokenOwner (address): 0x7AD001328f039Fd07d4cB77a82eAfB309dae6790

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 123c5d072e1473597fa06d685f53b296040c3f1538bf8017b3ea0bad73c929d1
Arg [1] : 000000000000000000000000c0bc84e95864bdfdcd1ccfb8a3aa522e79ca1410
Arg [2] : 0000000000000000000000007ad001328f039fd07d4cb77a82eafb309dae6790

17186:1872:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17439:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;17882:168;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;18058:581;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;17402:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13395:103;;;:::i;:::-;;17473:50;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18959:96;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18647:301;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12720:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;17370:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;17329:34;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13653:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;17756:118;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;17439:25;;;;:::o;17882:168::-;12606:13;:11;:13::i;:::-;17995:12:::1;17981:11;:26;;;;18031:11;18018:10;:24;;;;17882:168:::0;;:::o;18058:581::-;18190:14;18215:17;;18207:7;:25;;;;:::i;:::-;18190:42;;18251:11;;;;;;;;;;;18243:40;;;;;;;;;;;;:::i;:::-;;;;;;;;;18331:11;;18302:15;:26;18318:9;18302:26;;;;;;;;;;;;;;;;:40;18294:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;18400:34;18407:9;18418:7;18427:6;;18400;:34::i;:::-;18392:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;18508:11;;18479:15;:26;18495:9;18479:26;;;;;;;;;;;;;;;:40;;;;18547:19;;;;;;;;;;;18540:40;;;18581:10;;;;;;;;;;;18593:9;18604:6;18540:71;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18532:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;18179:460;18058:581;;;;:::o;17402:30::-;;;;;;;;;;;;;:::o;13395:103::-;12606:13;:11;:13::i;:::-;13460:30:::1;13487:1;13460:18;:30::i;:::-;13395:103::o:0;17473:50::-;;;;;;;;;;;;;;;;;:::o;18959:96::-;19010:7;19036:11;;19029:18;;18959:96;:::o;18647:301::-;18781:4;18797:12;18856:9;18867:7;18845:30;;;;;;;;;:::i;:::-;;;;;;;;;;;;;18835:41;;;;;;18822:55;;;;;;;;:::i;:::-;;;;;;;;;;;;;18812:66;;;;;;18797:81;;18896:44;18915:6;;18896:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18923:10;;18935:4;18896:18;:44::i;:::-;18889:51;;;18647:301;;;;;;:::o;12720:87::-;12766:7;12793:6;;;;;;;;;;;12786:13;;12720:87;:::o;17370:25::-;;;;;;;;;;;;;:::o;17329:34::-;;;;;;;;;;;;;:::o;13653:220::-;12606:13;:11;:13::i;:::-;13758:1:::1;13738:22;;:8;:22;;::::0;13734:93:::1;;13812:1;13784:31;;;;;;;;;;;:::i;:::-;;;;;;;;13734:93;13837:28;13856:8;13837:18;:28::i;:::-;13653:220:::0;:::o;17756:118::-;12606:13;:11;:13::i;:::-;17854:12:::1;17840:11;;:26;;;;;;;;;;;;;;;;;;17756:118:::0;:::o;12885:166::-;12956:12;:10;:12::i;:::-;12945:23;;:7;:5;:7::i;:::-;:23;;;12941:103;;13019:12;:10;:12::i;:::-;12992:40;;;;;;;;;;;:::i;:::-;;;;;;;;12941:103;12885:166::o;14033:191::-;14107:16;14126:6;;;;;;;;;;;14107:25;;14152:8;14143:6;;:17;;;;;;;;;;;;;;;;;;14207:8;14176:40;;14197:8;14176:40;;;;;;;;;;;;14096:128;14033:191;:::o;1336:156::-;1427:4;1480;1451:25;1464:5;1471:4;1451:12;:25::i;:::-;:33;1444:40;;1336:156;;;;;:::o;10729:98::-;10782:7;10809:10;10802:17;;10729:98;:::o;2055:296::-;2138:7;2158:20;2181:4;2158:27;;2201:9;2196:118;2220:5;:12;2216:1;:16;2196:118;;;2269:33;2279:12;2293:5;2299:1;2293:8;;;;;;;;:::i;:::-;;;;;;;;2269:9;:33::i;:::-;2254:48;;2234:3;;;;;:::i;:::-;;;;2196:118;;;;2331:12;2324:19;;;2055:296;;;;:::o;9485:149::-;9548:7;9579:1;9575;:5;:51;;9606:20;9621:1;9624;9606:14;:20::i;:::-;9575:51;;;9583:20;9598:1;9601;9583:14;:20::i;:::-;9575:51;9568:58;;9485:149;;;;:::o;9759:268::-;9827:13;9934:1;9928:4;9921:15;9963:1;9957:4;9950:15;10004:4;9998;9988:21;9979:30;;9759:268;;;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;523:117::-;632:1;629;622:12;646:117;755:1;752;745:12;769:77;806:7;835:5;824:16;;769:77;;;:::o;852:122::-;925:24;943:5;925:24;:::i;:::-;918:5;915:35;905:63;;964:1;961;954:12;905:63;852:122;:::o;980:139::-;1026:5;1064:6;1051:20;1042:29;;1080:33;1107:5;1080:33;:::i;:::-;980:139;;;;:::o;1125:122::-;1198:24;1216:5;1198:24;:::i;:::-;1191:5;1188:35;1178:63;;1237:1;1234;1227:12;1178:63;1125:122;:::o;1253:139::-;1299:5;1337:6;1324:20;1315:29;;1353:33;1380:5;1353:33;:::i;:::-;1253:139;;;;:::o;1398:474::-;1466:6;1474;1523:2;1511:9;1502:7;1498:23;1494:32;1491:119;;;1529:79;;:::i;:::-;1491:119;1649:1;1674:53;1719:7;1710:6;1699:9;1695:22;1674:53;:::i;:::-;1664:63;;1620:117;1776:2;1802:53;1847:7;1838:6;1827:9;1823:22;1802:53;:::i;:::-;1792:63;;1747:118;1398:474;;;;;:::o;1878:126::-;1915:7;1955:42;1948:5;1944:54;1933:65;;1878:126;;;:::o;2010:96::-;2047:7;2076:24;2094:5;2076:24;:::i;:::-;2065:35;;2010:96;;;:::o;2112:122::-;2185:24;2203:5;2185:24;:::i;:::-;2178:5;2175:35;2165:63;;2224:1;2221;2214:12;2165:63;2112:122;:::o;2240:139::-;2286:5;2324:6;2311:20;2302:29;;2340:33;2367:5;2340:33;:::i;:::-;2240:139;;;;:::o;2385:117::-;2494:1;2491;2484:12;2508:117;2617:1;2614;2607:12;2631:117;2740:1;2737;2730:12;2771:568;2844:8;2854:6;2904:3;2897:4;2889:6;2885:17;2881:27;2871:122;;2912:79;;:::i;:::-;2871:122;3025:6;3012:20;3002:30;;3055:18;3047:6;3044:30;3041:117;;;3077:79;;:::i;:::-;3041:117;3191:4;3183:6;3179:17;3167:29;;3245:3;3237:4;3229:6;3225:17;3215:8;3211:32;3208:41;3205:128;;;3252:79;;:::i;:::-;3205:128;2771:568;;;;;:::o;3345:849::-;3449:6;3457;3465;3473;3522:2;3510:9;3501:7;3497:23;3493:32;3490:119;;;3528:79;;:::i;:::-;3490:119;3648:1;3673:53;3718:7;3709:6;3698:9;3694:22;3673:53;:::i;:::-;3663:63;;3619:117;3775:2;3801:53;3846:7;3837:6;3826:9;3822:22;3801:53;:::i;:::-;3791:63;;3746:118;3931:2;3920:9;3916:18;3903:32;3962:18;3954:6;3951:30;3948:117;;;3984:79;;:::i;:::-;3948:117;4097:80;4169:7;4160:6;4149:9;4145:22;4097:80;:::i;:::-;4079:98;;;;3874:313;3345:849;;;;;;;:::o;4200:90::-;4234:7;4277:5;4270:13;4263:21;4252:32;;4200:90;;;:::o;4296:109::-;4377:21;4392:5;4377:21;:::i;:::-;4372:3;4365:34;4296:109;;:::o;4411:210::-;4498:4;4536:2;4525:9;4521:18;4513:26;;4549:65;4611:1;4600:9;4596:17;4587:6;4549:65;:::i;:::-;4411:210;;;;:::o;4627:329::-;4686:6;4735:2;4723:9;4714:7;4710:23;4706:32;4703:119;;;4741:79;;:::i;:::-;4703:119;4861:1;4886:53;4931:7;4922:6;4911:9;4907:22;4886:53;:::i;:::-;4876:63;;4832:117;4627:329;;;;:::o;4962:118::-;5049:24;5067:5;5049:24;:::i;:::-;5044:3;5037:37;4962:118;;:::o;5086:222::-;5179:4;5217:2;5206:9;5202:18;5194:26;;5230:71;5298:1;5287:9;5283:17;5274:6;5230:71;:::i;:::-;5086:222;;;;:::o;5314:118::-;5401:24;5419:5;5401:24;:::i;:::-;5396:3;5389:37;5314:118;;:::o;5438:222::-;5531:4;5569:2;5558:9;5554:18;5546:26;;5582:71;5650:1;5639:9;5635:17;5626:6;5582:71;:::i;:::-;5438:222;;;;:::o;5666:116::-;5736:21;5751:5;5736:21;:::i;:::-;5729:5;5726:32;5716:60;;5772:1;5769;5762:12;5716:60;5666:116;:::o;5788:133::-;5831:5;5869:6;5856:20;5847:29;;5885:30;5909:5;5885:30;:::i;:::-;5788:133;;;;:::o;5927:323::-;5983:6;6032:2;6020:9;6011:7;6007:23;6003:32;6000:119;;;6038:79;;:::i;:::-;6000:119;6158:1;6183:50;6225:7;6216:6;6205:9;6201:22;6183:50;:::i;:::-;6173:60;;6129:114;5927:323;;;;:::o;6256:180::-;6304:77;6301:1;6294:88;6401:4;6398:1;6391:15;6425:4;6422:1;6415:15;6442:410;6482:7;6505:20;6523:1;6505:20;:::i;:::-;6500:25;;6539:20;6557:1;6539:20;:::i;:::-;6534:25;;6594:1;6591;6587:9;6616:30;6634:11;6616:30;:::i;:::-;6605:41;;6795:1;6786:7;6782:15;6779:1;6776:22;6756:1;6749:9;6729:83;6706:139;;6825:18;;:::i;:::-;6706:139;6490:362;6442:410;;;;:::o;6858:169::-;6942:11;6976:6;6971:3;6964:19;7016:4;7011:3;7007:14;6992:29;;6858:169;;;;:::o;7033:166::-;7173:18;7169:1;7161:6;7157:14;7150:42;7033:166;:::o;7205:366::-;7347:3;7368:67;7432:2;7427:3;7368:67;:::i;:::-;7361:74;;7444:93;7533:3;7444:93;:::i;:::-;7562:2;7557:3;7553:12;7546:19;;7205:366;;;:::o;7577:419::-;7743:4;7781:2;7770:9;7766:18;7758:26;;7830:9;7824:4;7820:20;7816:1;7805:9;7801:17;7794:47;7858:131;7984:4;7858:131;:::i;:::-;7850:139;;7577:419;;;:::o;8002:221::-;8142:34;8138:1;8130:6;8126:14;8119:58;8211:4;8206:2;8198:6;8194:15;8187:29;8002:221;:::o;8229:366::-;8371:3;8392:67;8456:2;8451:3;8392:67;:::i;:::-;8385:74;;8468:93;8557:3;8468:93;:::i;:::-;8586:2;8581:3;8577:12;8570:19;;8229:366;;;:::o;8601:419::-;8767:4;8805:2;8794:9;8790:18;8782:26;;8854:9;8848:4;8844:20;8840:1;8829:9;8825:17;8818:47;8882:131;9008:4;8882:131;:::i;:::-;8874:139;;8601:419;;;:::o;9026:177::-;9166:29;9162:1;9154:6;9150:14;9143:53;9026:177;:::o;9209:366::-;9351:3;9372:67;9436:2;9431:3;9372:67;:::i;:::-;9365:74;;9448:93;9537:3;9448:93;:::i;:::-;9566:2;9561:3;9557:12;9550:19;;9209:366;;;:::o;9581:419::-;9747:4;9785:2;9774:9;9770:18;9762:26;;9834:9;9828:4;9824:20;9820:1;9809:9;9805:17;9798:47;9862:131;9988:4;9862:131;:::i;:::-;9854:139;;9581:419;;;:::o;10006:442::-;10155:4;10193:2;10182:9;10178:18;10170:26;;10206:71;10274:1;10263:9;10259:17;10250:6;10206:71;:::i;:::-;10287:72;10355:2;10344:9;10340:18;10331:6;10287:72;:::i;:::-;10369;10437:2;10426:9;10422:18;10413:6;10369:72;:::i;:::-;10006:442;;;;;;:::o;10454:137::-;10508:5;10539:6;10533:13;10524:22;;10555:30;10579:5;10555:30;:::i;:::-;10454:137;;;;:::o;10597:345::-;10664:6;10713:2;10701:9;10692:7;10688:23;10684:32;10681:119;;;10719:79;;:::i;:::-;10681:119;10839:1;10864:61;10917:7;10908:6;10897:9;10893:22;10864:61;:::i;:::-;10854:71;;10810:125;10597:345;;;;:::o;10948:165::-;11088:17;11084:1;11076:6;11072:14;11065:41;10948:165;:::o;11119:366::-;11261:3;11282:67;11346:2;11341:3;11282:67;:::i;:::-;11275:74;;11358:93;11447:3;11358:93;:::i;:::-;11476:2;11471:3;11467:12;11460:19;;11119:366;;;:::o;11491:419::-;11657:4;11695:2;11684:9;11680:18;11672:26;;11744:9;11738:4;11734:20;11730:1;11719:9;11715:17;11708:47;11772:131;11898:4;11772:131;:::i;:::-;11764:139;;11491:419;;;:::o;11916:332::-;12037:4;12075:2;12064:9;12060:18;12052:26;;12088:71;12156:1;12145:9;12141:17;12132:6;12088:71;:::i;:::-;12169:72;12237:2;12226:9;12222:18;12213:6;12169:72;:::i;:::-;11916:332;;;;;:::o;12254:79::-;12293:7;12322:5;12311:16;;12254:79;;;:::o;12339:157::-;12444:45;12464:24;12482:5;12464:24;:::i;:::-;12444:45;:::i;:::-;12439:3;12432:58;12339:157;;:::o;12502:256::-;12614:3;12629:75;12700:3;12691:6;12629:75;:::i;:::-;12729:2;12724:3;12720:12;12713:19;;12749:3;12742:10;;12502:256;;;;:::o;12764:180::-;12812:77;12809:1;12802:88;12909:4;12906:1;12899:15;12933:4;12930:1;12923:15;12950:233;12989:3;13012:24;13030:5;13012:24;:::i;:::-;13003:33;;13058:66;13051:5;13048:77;13045:103;;13128:18;;:::i;:::-;13045:103;13175:1;13168:5;13164:13;13157:20;;12950:233;;;:::o

ipfs://c9b71308cbf70a72e00f30d1bae78534644b7313d28391842ae8af3852470711