Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at basescan.org on 2024-04-13
*/

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


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

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
     *   {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
     *   a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// 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/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// 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: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.20;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys a `value` amount of tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 value) public virtual {
        _burn(_msgSender(), value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, deducting from
     * the caller's allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `value`.
     */
    function burnFrom(address account, uint256 value) public virtual {
        _spendAllowance(account, _msgSender(), value);
        _burn(account, value);
    }
}

// File: contracts/FellaToken.sol


pragma solidity ^0.8.25;







contract FELLA is ERC20, Ownable, ERC20Burnable{
    using Address for address;

    address public basedFellas = 0x217Ec1aC929a17481446A76Ff9B95B9a64F298cF;
    address public taxHandler = 0xB5875473AC9e5dc4614905C46b2EA7712f296e30;
    address[] public sushiRouters;
    uint256 public phase = 0;
    bytes32 public merkleRoot;
    uint256 public constant maxPhase1Tokens = 100000 * 10**18;
    uint256 public taxPercentage = 1;
    bool public isTaxPaused = true;

    mapping(address => bytes32[]) private merkleProof;

    constructor() ERC20("FELLA", "FELLA") Ownable(msg.sender) {
        address[] memory routers = new address[](2);
        routers[0] = 0x6BDED42c6DA8FBf0d2bA55B2fa120C5e0c8D7891;
        routers[1] = 0x0389879e0156033202C44BF784ac18fC02edeE4f;
        setSushiRouters(routers);
        _mint(msg.sender, 100000000 * 10**18);
    }

    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        bool isEOA = !isContract(recipient);
        bool sushiSwap = isSushiContracts(msg.sender) || isSushiContracts(recipient);
        uint256 _phase = phase;

        require(_phase != 0 || msg.sender == owner() || recipient == owner(), "Fella paused or unauthorized");
        require(_phase != 1 || isWhitelisted(recipient) || sushiSwap, "Not allowed to transfer during phase 1");
        require(_phase != 2 || ownsFella(msg.sender) || ownsFella(recipient), "You must own a Based Fella for phase 2!");

        if (isEOA) {
            require(_phase != 1 || balanceOf(recipient) + amount <= maxPhase1Tokens, "Token limit exceeded for phase 1");
        }

        return _transferWithTax(recipient, amount);
    }

    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        bool isEOA = !isContract(recipient);
        bool sushiSwap = isSushiContracts(msg.sender) || isSushiContracts(recipient) || isSushiContracts(sender);
        uint256 _phase = phase;

        require(_phase != 0 || msg.sender == owner() || sender == owner() || recipient == owner(), "Fella paused or unauthorized");
        require(_phase != 1 || isWhitelisted(recipient) || sushiSwap, "Not allowed to transfer during phase 1");
        require(_phase != 2 || ownsFella(msg.sender) || ownsFella(sender) || ownsFella(recipient), "You must own a Based Fella for phase 2!");

        if (isEOA) {
            require(_phase != 1 || balanceOf(recipient) + amount <= maxPhase1Tokens, "Token limit exceeded for phase 1");
        }

        return _transferFromWithTax(sender, recipient, amount);
    }

    function _transferWithTax(address recipient, uint256 amount) private returns (bool) {
        if (!isTaxPaused) {
            uint256 taxAmount = (amount * taxPercentage) / 100;
            uint256 amountAfterTax = amount - taxAmount;
            super.transfer(taxHandler, taxAmount);
            return super.transfer(recipient, amountAfterTax);
        } else {
            return super.transfer(recipient, amount);
        }
    }

    function _transferFromWithTax(address sender, address recipient, uint256 amount) private returns (bool) {
        if (!isTaxPaused) {
            uint256 taxAmount = (amount * taxPercentage) / 100;
            uint256 amountAfterTax = amount - taxAmount;
            super.transferFrom(sender, taxHandler, taxAmount);
            return super.transferFrom(sender, recipient, amountAfterTax);
        } else {
            return super.transferFrom(sender, recipient, amount);
        }
    }

    function isContract(address _addr) internal view returns (bool) {
        uint32 size;
        assembly {
            size := extcodesize(_addr)
        }
        return (size > 0);
    }

    function isSushiContracts(address _address) internal view returns (bool) {
        for (uint256 i = 0; i < sushiRouters.length; i++) {
            if (_address == sushiRouters[i]) {
                return true;
            }
        }
        return false;
    }

    function setSushiRouters(address[] memory _sushiRouters) internal onlyOwner {
        sushiRouters = _sushiRouters;
    }

    function setPhase(uint256 _phase) external onlyOwner {
        phase = _phase;
    }

    function setMerkleRoot(bytes32 _whitelistMerkleRoot) external onlyOwner {
        merkleRoot = _whitelistMerkleRoot;
    }

    function setTaxHandler(address _taxHandler) external onlyOwner {
        taxHandler = _taxHandler;
    }

    function setMerkleProof(bytes32[] memory _merkleProof) external {
        merkleProof[msg.sender] = _merkleProof;
    }

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

    function ownsFella(address _address) public view returns (bool) {
        return IERC721(basedFellas).balanceOf(_address) > 0;
    }

    function toggleTax() external onlyOwner {
        isTaxPaused = !isTaxPaused;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"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":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"basedFellas","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isTaxPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPhase1Tokens","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":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"ownsFella","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"phase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"setMerkleProof","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_whitelistMerkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_phase","type":"uint256"}],"name":"setPhase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_taxHandler","type":"address"}],"name":"setTaxHandler","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"sushiRouters","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxHandler","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

49510:5153:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38920:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41213:190;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54575:85;;;:::i;:::-;;49676:70;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40022:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51233:932;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53740:86;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49820:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39873:84;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49598:71;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54209:216;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48845:89;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53966:106;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54080:121;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54433:134;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40184:118;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;32533:103;;;:::i;:::-;;49263:161;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53834:124;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49852:57;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31858:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;39130:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49955:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50395:830;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49916:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49753:29;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49789:24;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40752:142;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;32791:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;38920:91;38965:13;38998:5;38991:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38920:91;:::o;41213:190::-;41286:4;41303:13;41319:12;:10;:12::i;:::-;41303:28;;41342:31;41351:5;41358:7;41367:5;41342:8;:31::i;:::-;41391:4;41384:11;;;41213:190;;;;:::o;54575:85::-;31744:13;:11;:13::i;:::-;54641:11:::1;;;;;;;;;;;54640:12;54626:11;;:26;;;;;;;;;;;;;;;;;;54575:85::o:0;49676:70::-;;;;;;;;;;;;;:::o;40022:99::-;40074:7;40101:12;;40094:19;;40022:99;:::o;51233:932::-;51339:4;51356:10;51370:21;51381:9;51370:10;:21::i;:::-;51369:22;51356:35;;51402:14;51419:28;51436:10;51419:16;:28::i;:::-;:59;;;;51451:27;51468:9;51451:16;:27::i;:::-;51419:59;:87;;;;51482:24;51499:6;51482:16;:24::i;:::-;51419:87;51402:104;;51517:14;51534:5;;51517:22;;51570:1;51560:6;:11;;:36;;;;51589:7;:5;:7::i;:::-;51575:21;;:10;:21;;;51560:36;:57;;;;51610:7;:5;:7::i;:::-;51600:17;;:6;:17;;;51560:57;:81;;;;51634:7;:5;:7::i;:::-;51621:20;;:9;:20;;;51560:81;51552:122;;;;;;;;;;;;:::i;:::-;;;;;;;;;51703:1;51693:6;:11;;:39;;;;51708:24;51722:9;51708:13;:24::i;:::-;51693:39;:52;;;;51736:9;51693:52;51685:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;51817:1;51807:6;:11;;:36;;;;51822:21;51832:10;51822:9;:21::i;:::-;51807:36;:57;;;;51847:17;51857:6;51847:9;:17::i;:::-;51807:57;:81;;;;51868:20;51878:9;51868;:20::i;:::-;51807:81;51799:133;;;;;;;;;;;;:::i;:::-;;;;;;;;;51949:5;51945:146;;;51989:1;51979:6;:11;;:63;;;;49894:15;52017:6;51994:20;52004:9;51994;:20::i;:::-;:29;;;;:::i;:::-;:48;;51979:63;51971:108;;;;;;;;;;;;:::i;:::-;;;;;;;;;51945:146;52110:47;52131:6;52139:9;52150:6;52110:20;:47::i;:::-;52103:54;;;;;51233:932;;;;;:::o;53740:86::-;31744:13;:11;:13::i;:::-;53812:6:::1;53804:5;:14;;;;53740:86:::0;:::o;49820:25::-;;;;:::o;39873:84::-;39922:5;39947:2;39940:9;;39873:84;:::o;49598:71::-;;;;;;;;;;;;;:::o;54209:216::-;54271:4;54288:12;54330:8;54313:26;;;;;;;;:::i;:::-;;;;;;;;;;;;;54303:37;;;;;;54288:52;;54358:59;54377:11;:21;54389:8;54377:21;;;;;;;;;;;;;;;54358:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54400:10;;54412:4;54358:18;:59::i;:::-;54351:66;;;54209:216;;;:::o;48845:89::-;48900:26;48906:12;:10;:12::i;:::-;48920:5;48900;:26::i;:::-;48845:89;:::o;53966:106::-;31744:13;:11;:13::i;:::-;54053:11:::1;54040:10;;:24;;;;;;;;;;;;;;;;;;53966:106:::0;:::o;54080:121::-;54181:12;54155:11;:23;54167:10;54155:23;;;;;;;;;;;;;;;:38;;;;;;;;;;;;:::i;:::-;;54080:121;:::o;54433:134::-;54491:4;54558:1;54523:11;;;;;;;;;;;54515:30;;;54546:8;54515:40;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;54508:51;;54433:134;;;:::o;40184:118::-;40249:7;40276:9;:18;40286:7;40276:18;;;;;;;;;;;;;;;;40269:25;;40184:118;;;:::o;32533:103::-;31744:13;:11;:13::i;:::-;32598:30:::1;32625:1;32598:18;:30::i;:::-;32533:103::o:0;49263:161::-;49339:45;49355:7;49364:12;:10;:12::i;:::-;49378:5;49339:15;:45::i;:::-;49395:21;49401:7;49410:5;49395;:21::i;:::-;49263:161;;:::o;53834:124::-;31744:13;:11;:13::i;:::-;53930:20:::1;53917:10;:33;;;;53834:124:::0;:::o;49852:57::-;49894:15;49852:57;:::o;31858:87::-;31904:7;31931:6;;;;;;;;;;;31924:13;;31858:87;:::o;39130:95::-;39177:13;39210:7;39203:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39130:95;:::o;49955:30::-;;;;;;;;;;;;;:::o;50395:830::-;50481:4;50498:10;50512:21;50523:9;50512:10;:21::i;:::-;50511:22;50498:35;;50544:14;50561:28;50578:10;50561:16;:28::i;:::-;:59;;;;50593:27;50610:9;50593:16;:27::i;:::-;50561:59;50544:76;;50631:14;50648:5;;50631:22;;50684:1;50674:6;:11;;:36;;;;50703:7;:5;:7::i;:::-;50689:21;;:10;:21;;;50674:36;:60;;;;50727:7;:5;:7::i;:::-;50714:20;;:9;:20;;;50674:60;50666:101;;;;;;;;;;;;:::i;:::-;;;;;;;;;50796:1;50786:6;:11;;:39;;;;50801:24;50815:9;50801:13;:24::i;:::-;50786:39;:52;;;;50829:9;50786:52;50778:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;50910:1;50900:6;:11;;:36;;;;50915:21;50925:10;50915:9;:21::i;:::-;50900:36;:60;;;;50940:20;50950:9;50940;:20::i;:::-;50900:60;50892:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;51021:5;51017:146;;;51061:1;51051:6;:11;;:63;;;;49894:15;51089:6;51066:20;51076:9;51066;:20::i;:::-;:29;;;;:::i;:::-;:48;;51051:63;51043:108;;;;;;;;;;;;:::i;:::-;;;;;;;;;51017:146;51182:35;51199:9;51210:6;51182:16;:35::i;:::-;51175:42;;;;;50395:830;;;;:::o;49916:32::-;;;;:::o;49753:29::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;49789:24::-;;;;:::o;40752:142::-;40832:7;40859:11;:18;40871:5;40859:18;;;;;;;;;;;;;;;:27;40878:7;40859:27;;;;;;;;;;;;;;;;40852:34;;40752:142;;;;:::o;32791:220::-;31744:13;:11;:13::i;:::-;32896:1:::1;32876:22;;:8;:22;;::::0;32872:93:::1;;32950:1;32922:31;;;;;;;;;;;:::i;:::-;;;;;;;;32872:93;32975:28;32994:8;32975:18;:28::i;:::-;32791:220:::0;:::o;29867:98::-;29920:7;29947:10;29940:17;;29867:98;:::o;46040:130::-;46125:37;46134:5;46141:7;46150:5;46157:4;46125:8;:37::i;:::-;46040:130;;;:::o;32023:166::-;32094:12;:10;:12::i;:::-;32083:23;;:7;:5;:7::i;:::-;:23;;;32079:103;;32157:12;:10;:12::i;:::-;32130:40;;;;;;;;;;;:::i;:::-;;;;;;;;32079:103;32023:166::o;53131:193::-;53189:4;53206:11;53272:5;53260:18;53252:26;;53314:1;53307:4;:8;;;53299:17;;;53131:193;;;:::o;53332:269::-;53399:4;53421:9;53433:1;53421:13;;53416:155;53440:12;:19;;;;53436:1;:23;53416:155;;;53497:12;53510:1;53497:15;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;53485:27;;:8;:27;;;53481:79;;53540:4;53533:11;;;;;53481:79;53461:3;;;;;;;53416:155;;;;53588:5;53581:12;;53332:269;;;;:::o;52624:499::-;52722:4;52744:11;;;;;;;;;;;52739:377;;52772:17;52819:3;52802:13;;52793:6;:22;;;;:::i;:::-;52792:30;;;;:::i;:::-;52772:50;;52837:22;52871:9;52862:6;:18;;;;:::i;:::-;52837:43;;52895:49;52914:6;52922:10;;;;;;;;;;;52934:9;52895:18;:49::i;:::-;;52966:53;52985:6;52993:9;53004:14;52966:18;:53::i;:::-;52959:60;;;;;;52739:377;53059:45;53078:6;53086:9;53097:6;53059:18;:45::i;:::-;53052:52;;52624:499;;;;;;:::o;13744:156::-;13835:4;13888;13859:25;13872:5;13879:4;13859:12;:25::i;:::-;:33;13852:40;;13744:156;;;;;:::o;45276:211::-;45366:1;45347:21;;:7;:21;;;45343:91;;45419:1;45392:30;;;;;;;;;;;:::i;:::-;;;;;;;;45343:91;45444:35;45452:7;45469:1;45473:5;45444:7;:35::i;:::-;45276:211;;:::o;33171:191::-;33245:16;33264:6;;;;;;;;;;;33245:25;;33290:8;33281:6;;:17;;;;;;;;;;;;;;;;;;33345:8;33314:40;;33335:8;33314:40;;;;;;;;;;;;33234:128;33171:191;:::o;47756:487::-;47856:24;47883:25;47893:5;47900:7;47883:9;:25::i;:::-;47856:52;;47943:17;47923:16;:37;47919:317;;48000:5;47981:16;:24;47977:132;;;48060:7;48069:16;48087:5;48033:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;47977:132;48152:57;48161:5;48168:7;48196:5;48177:16;:24;48203:5;48152:8;:57::i;:::-;47919:317;47845:398;47756:487;;;:::o;52173:443::-;52251:4;52273:11;;;;;;;;;;;52268:341;;52301:17;52348:3;52331:13;;52322:6;:22;;;;:::i;:::-;52321:30;;;;:::i;:::-;52301:50;;52366:22;52400:9;52391:6;:18;;;;:::i;:::-;52366:43;;52424:37;52439:10;;;;;;;;;;;52451:9;52424:14;:37::i;:::-;;52483:41;52498:9;52509:14;52483;:41::i;:::-;52476:48;;;;;;52268:341;52564:33;52579:9;52590:6;52564:14;:33::i;:::-;52557:40;;52173:443;;;;;:::o;47021:::-;47151:1;47134:19;;:5;:19;;;47130:91;;47206:1;47177:32;;;;;;;;;;;:::i;:::-;;;;;;;;47130:91;47254:1;47235:21;;:7;:21;;;47231:92;;47308:1;47280:31;;;;;;;;;;;:::i;:::-;;;;;;;;47231:92;47363:5;47333:11;:18;47345:5;47333:18;;;;;;;;;;;;;;;:27;47352:7;47333:27;;;;;;;;;;;;;;;:35;;;;47383:9;47379:78;;;47430:7;47414:31;;47423:5;47414:31;;;47439:5;47414:31;;;;;;:::i;:::-;;;;;;;;47379:78;47021:443;;;;:::o;41981:249::-;42068:4;42085:15;42103:12;:10;:12::i;:::-;42085:30;;42126:37;42142:4;42148:7;42157:5;42126:15;:37::i;:::-;42174:26;42184:4;42190:2;42194:5;42174:9;:26::i;:::-;42218:4;42211:11;;;41981:249;;;;;:::o;14463:296::-;14546:7;14566:20;14589:4;14566:27;;14609:9;14604:118;14628:5;:12;14624:1;:16;14604:118;;;14677:33;14687:12;14701:5;14707:1;14701:8;;;;;;;;:::i;:::-;;;;;;;;14677:9;:33::i;:::-;14662:48;;14642:3;;;;;;;14604:118;;;;14739:12;14732:19;;;14463:296;;;;:::o;43247:1135::-;43353:1;43337:18;;:4;:18;;;43333:552;;43491:5;43475:12;;:21;;;;;;;:::i;:::-;;;;;;;;43333:552;;;43529:19;43551:9;:15;43561:4;43551:15;;;;;;;;;;;;;;;;43529:37;;43599:5;43585:11;:19;43581:117;;;43657:4;43663:11;43676:5;43632:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;43581:117;43853:5;43839:11;:19;43821:9;:15;43831:4;43821:15;;;;;;;;;;;;;;;:37;;;;43514:371;43333:552;43915:1;43901:16;;:2;:16;;;43897:435;;44083:5;44067:12;;:21;;;;;;;;;;;43897:435;;;44300:5;44283:9;:13;44293:2;44283:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;43897:435;44364:2;44349:25;;44358:4;44349:25;;;44368:5;44349:25;;;;;;:::i;:::-;;;;;;;;43247:1135;;;:::o;40507:182::-;40576:4;40593:13;40609:12;:10;:12::i;:::-;40593:28;;40632:27;40642:5;40649:2;40653:5;40632:9;:27::i;:::-;40677:4;40670:11;;;40507:182;;;;:::o;42615:308::-;42715:1;42699:18;;:4;:18;;;42695:88;;42768:1;42741:30;;;;;;;;;;;:::i;:::-;;;;;;;;42695:88;42811:1;42797:16;;:2;:16;;;42793:88;;42866:1;42837:32;;;;;;;;;;;:::i;:::-;;;;;;;;42793:88;42891:24;42899:4;42905:2;42909:5;42891:7;:24::i;:::-;42615:308;;;:::o;21893:149::-;21956:7;21987:1;21983;:5;:51;;22014:20;22029:1;22032;22014:14;:20::i;:::-;21983:51;;;21991:20;22006:1;22009;21991:14;:20::i;:::-;21983:51;21976:58;;21893:149;;;;:::o;22167:268::-;22235:13;22342:1;22336:4;22329:15;22371:1;22365:4;22358:15;22412:4;22406;22396:21;22387:30;;22167:268;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:139::-;376:6;371:3;366;360:23;417:1;408:6;403:3;399:16;392:27;287:139;;;:::o;432:102::-;473:6;524:2;520:7;515:2;508:5;504:14;500:28;490:38;;432:102;;;:::o;540:377::-;628:3;656:39;689:5;656:39;:::i;:::-;711:71;775:6;770:3;711:71;:::i;:::-;704:78;;791:65;849:6;844:3;837:4;830:5;826:16;791:65;:::i;:::-;881:29;903:6;881:29;:::i;:::-;876:3;872:39;865:46;;632:285;540:377;;;;:::o;923:313::-;1036:4;1074:2;1063:9;1059:18;1051:26;;1123:9;1117:4;1113:20;1109:1;1098:9;1094:17;1087:47;1151:78;1224:4;1215:6;1151:78;:::i;:::-;1143:86;;923:313;;;;:::o;1242:75::-;1275:6;1308:2;1302:9;1292:19;;1242:75;:::o;1323:117::-;1432:1;1429;1422:12;1446:117;1555:1;1552;1545:12;1569:126;1606:7;1646:42;1639:5;1635:54;1624:65;;1569:126;;;:::o;1701:96::-;1738:7;1767:24;1785:5;1767:24;:::i;:::-;1756:35;;1701:96;;;:::o;1803:122::-;1876:24;1894:5;1876:24;:::i;:::-;1869:5;1866:35;1856:63;;1915:1;1912;1905:12;1856:63;1803:122;:::o;1931:139::-;1977:5;2015:6;2002:20;1993:29;;2031:33;2058:5;2031:33;:::i;:::-;1931:139;;;;:::o;2076:77::-;2113:7;2142:5;2131:16;;2076:77;;;:::o;2159:122::-;2232:24;2250:5;2232:24;:::i;:::-;2225:5;2222:35;2212:63;;2271:1;2268;2261:12;2212:63;2159:122;:::o;2287:139::-;2333:5;2371:6;2358:20;2349:29;;2387:33;2414:5;2387:33;:::i;:::-;2287:139;;;;:::o;2432:474::-;2500:6;2508;2557:2;2545:9;2536:7;2532:23;2528:32;2525:119;;;2563:79;;:::i;:::-;2525:119;2683:1;2708:53;2753:7;2744:6;2733:9;2729:22;2708:53;:::i;:::-;2698:63;;2654:117;2810:2;2836:53;2881:7;2872:6;2861:9;2857:22;2836:53;:::i;:::-;2826:63;;2781:118;2432:474;;;;;:::o;2912:90::-;2946:7;2989:5;2982:13;2975:21;2964:32;;2912:90;;;:::o;3008:109::-;3089:21;3104:5;3089:21;:::i;:::-;3084:3;3077:34;3008:109;;:::o;3123:210::-;3210:4;3248:2;3237:9;3233:18;3225:26;;3261:65;3323:1;3312:9;3308:17;3299:6;3261:65;:::i;:::-;3123:210;;;;:::o;3339:118::-;3426:24;3444:5;3426:24;:::i;:::-;3421:3;3414:37;3339:118;;:::o;3463:222::-;3556:4;3594:2;3583:9;3579:18;3571:26;;3607:71;3675:1;3664:9;3660:17;3651:6;3607:71;:::i;:::-;3463:222;;;;:::o;3691:118::-;3778:24;3796:5;3778:24;:::i;:::-;3773:3;3766:37;3691:118;;:::o;3815:222::-;3908:4;3946:2;3935:9;3931:18;3923:26;;3959:71;4027:1;4016:9;4012:17;4003:6;3959:71;:::i;:::-;3815:222;;;;:::o;4043:619::-;4120:6;4128;4136;4185:2;4173:9;4164:7;4160:23;4156:32;4153:119;;;4191:79;;:::i;:::-;4153:119;4311:1;4336:53;4381:7;4372:6;4361:9;4357:22;4336:53;:::i;:::-;4326:63;;4282:117;4438:2;4464:53;4509:7;4500:6;4489:9;4485:22;4464:53;:::i;:::-;4454:63;;4409:118;4566:2;4592:53;4637:7;4628:6;4617:9;4613:22;4592:53;:::i;:::-;4582:63;;4537:118;4043:619;;;;;:::o;4668:329::-;4727:6;4776:2;4764:9;4755:7;4751:23;4747:32;4744:119;;;4782:79;;:::i;:::-;4744:119;4902:1;4927:53;4972:7;4963:6;4952:9;4948:22;4927:53;:::i;:::-;4917:63;;4873:117;4668:329;;;;:::o;5003:77::-;5040:7;5069:5;5058:16;;5003:77;;;:::o;5086:118::-;5173:24;5191:5;5173:24;:::i;:::-;5168:3;5161:37;5086:118;;:::o;5210:222::-;5303:4;5341:2;5330:9;5326:18;5318:26;;5354:71;5422:1;5411:9;5407:17;5398:6;5354:71;:::i;:::-;5210:222;;;;:::o;5438:86::-;5473:7;5513:4;5506:5;5502:16;5491:27;;5438:86;;;:::o;5530:112::-;5613:22;5629:5;5613:22;:::i;:::-;5608:3;5601:35;5530:112;;:::o;5648:214::-;5737:4;5775:2;5764:9;5760:18;5752:26;;5788:67;5852:1;5841:9;5837:17;5828:6;5788:67;:::i;:::-;5648:214;;;;:::o;5868:329::-;5927:6;5976:2;5964:9;5955:7;5951:23;5947:32;5944:119;;;5982:79;;:::i;:::-;5944:119;6102:1;6127:53;6172:7;6163:6;6152:9;6148:22;6127:53;:::i;:::-;6117:63;;6073:117;5868:329;;;;:::o;6203:117::-;6312:1;6309;6302:12;6326:180;6374:77;6371:1;6364:88;6471:4;6468:1;6461:15;6495:4;6492:1;6485:15;6512:281;6595:27;6617:4;6595:27;:::i;:::-;6587:6;6583:40;6725:6;6713:10;6710:22;6689:18;6677:10;6674:34;6671:62;6668:88;;;6736:18;;:::i;:::-;6668:88;6776:10;6772:2;6765:22;6555:238;6512:281;;:::o;6799:129::-;6833:6;6860:20;;:::i;:::-;6850:30;;6889:33;6917:4;6909:6;6889:33;:::i;:::-;6799:129;;;:::o;6934:311::-;7011:4;7101:18;7093:6;7090:30;7087:56;;;7123:18;;:::i;:::-;7087:56;7173:4;7165:6;7161:17;7153:25;;7233:4;7227;7223:15;7215:23;;6934:311;;;:::o;7251:117::-;7360:1;7357;7350:12;7374:122;7447:24;7465:5;7447:24;:::i;:::-;7440:5;7437:35;7427:63;;7486:1;7483;7476:12;7427:63;7374:122;:::o;7502:139::-;7548:5;7586:6;7573:20;7564:29;;7602:33;7629:5;7602:33;:::i;:::-;7502:139;;;;:::o;7664:710::-;7760:5;7785:81;7801:64;7858:6;7801:64;:::i;:::-;7785:81;:::i;:::-;7776:90;;7886:5;7915:6;7908:5;7901:21;7949:4;7942:5;7938:16;7931:23;;8002:4;7994:6;7990:17;7982:6;7978:30;8031:3;8023:6;8020:15;8017:122;;;8050:79;;:::i;:::-;8017:122;8165:6;8148:220;8182:6;8177:3;8174:15;8148:220;;;8257:3;8286:37;8319:3;8307:10;8286:37;:::i;:::-;8281:3;8274:50;8353:4;8348:3;8344:14;8337:21;;8224:144;8208:4;8203:3;8199:14;8192:21;;8148:220;;;8152:21;7766:608;;7664:710;;;;;:::o;8397:370::-;8468:5;8517:3;8510:4;8502:6;8498:17;8494:27;8484:122;;8525:79;;:::i;:::-;8484:122;8642:6;8629:20;8667:94;8757:3;8749:6;8742:4;8734:6;8730:17;8667:94;:::i;:::-;8658:103;;8474:293;8397:370;;;;:::o;8773:539::-;8857:6;8906:2;8894:9;8885:7;8881:23;8877:32;8874:119;;;8912:79;;:::i;:::-;8874:119;9060:1;9049:9;9045:17;9032:31;9090:18;9082:6;9079:30;9076:117;;;9112:79;;:::i;:::-;9076:117;9217:78;9287:7;9278:6;9267:9;9263:22;9217:78;:::i;:::-;9207:88;;9003:302;8773:539;;;;:::o;9318:329::-;9377:6;9426:2;9414:9;9405:7;9401:23;9397:32;9394:119;;;9432:79;;:::i;:::-;9394:119;9552:1;9577:53;9622:7;9613:6;9602:9;9598:22;9577:53;:::i;:::-;9567:63;;9523:117;9318:329;;;;:::o;9653:474::-;9721:6;9729;9778:2;9766:9;9757:7;9753:23;9749:32;9746:119;;;9784:79;;:::i;:::-;9746:119;9904:1;9929:53;9974:7;9965:6;9954:9;9950:22;9929:53;:::i;:::-;9919:63;;9875:117;10031:2;10057:53;10102:7;10093:6;10082:9;10078:22;10057:53;:::i;:::-;10047:63;;10002:118;9653:474;;;;;:::o;10133:180::-;10181:77;10178:1;10171:88;10278:4;10275:1;10268:15;10302:4;10299:1;10292:15;10319:320;10363:6;10400:1;10394:4;10390:12;10380:22;;10447:1;10441:4;10437:12;10468:18;10458:81;;10524:4;10516:6;10512:17;10502:27;;10458:81;10586:2;10578:6;10575:14;10555:18;10552:38;10549:84;;10605:18;;:::i;:::-;10549:84;10370:269;10319:320;;;:::o;10645:178::-;10785:30;10781:1;10773:6;10769:14;10762:54;10645:178;:::o;10829:366::-;10971:3;10992:67;11056:2;11051:3;10992:67;:::i;:::-;10985:74;;11068:93;11157:3;11068:93;:::i;:::-;11186:2;11181:3;11177:12;11170:19;;10829:366;;;:::o;11201:419::-;11367:4;11405:2;11394:9;11390:18;11382:26;;11454:9;11448:4;11444:20;11440:1;11429:9;11425:17;11418:47;11482:131;11608:4;11482:131;:::i;:::-;11474:139;;11201:419;;;:::o;11626:225::-;11766:34;11762:1;11754:6;11750:14;11743:58;11835:8;11830:2;11822:6;11818:15;11811:33;11626:225;:::o;11857:366::-;11999:3;12020:67;12084:2;12079:3;12020:67;:::i;:::-;12013:74;;12096:93;12185:3;12096:93;:::i;:::-;12214:2;12209:3;12205:12;12198:19;;11857:366;;;:::o;12229:419::-;12395:4;12433:2;12422:9;12418:18;12410:26;;12482:9;12476:4;12472:20;12468:1;12457:9;12453:17;12446:47;12510:131;12636:4;12510:131;:::i;:::-;12502:139;;12229:419;;;:::o;12654:226::-;12794:34;12790:1;12782:6;12778:14;12771:58;12863:9;12858:2;12850:6;12846:15;12839:34;12654:226;:::o;12886:366::-;13028:3;13049:67;13113:2;13108:3;13049:67;:::i;:::-;13042:74;;13125:93;13214:3;13125:93;:::i;:::-;13243:2;13238:3;13234:12;13227:19;;12886:366;;;:::o;13258:419::-;13424:4;13462:2;13451:9;13447:18;13439:26;;13511:9;13505:4;13501:20;13497:1;13486:9;13482:17;13475:47;13539:131;13665:4;13539:131;:::i;:::-;13531:139;;13258:419;;;:::o;13683:180::-;13731:77;13728:1;13721:88;13828:4;13825:1;13818:15;13852:4;13849:1;13842:15;13869:191;13909:3;13928:20;13946:1;13928:20;:::i;:::-;13923:25;;13962:20;13980:1;13962:20;:::i;:::-;13957:25;;14005:1;14002;13998:9;13991:16;;14026:3;14023:1;14020:10;14017:36;;;14033:18;;:::i;:::-;14017:36;13869:191;;;;:::o;14066:182::-;14206:34;14202:1;14194:6;14190:14;14183:58;14066:182;:::o;14254:366::-;14396:3;14417:67;14481:2;14476:3;14417:67;:::i;:::-;14410:74;;14493:93;14582:3;14493:93;:::i;:::-;14611:2;14606:3;14602:12;14595:19;;14254:366;;;:::o;14626:419::-;14792:4;14830:2;14819:9;14815:18;14807:26;;14879:9;14873:4;14869:20;14865:1;14854:9;14850:17;14843:47;14907:131;15033:4;14907:131;:::i;:::-;14899:139;;14626:419;;;:::o;15051:94::-;15084:8;15132:5;15128:2;15124:14;15103:35;;15051:94;;;:::o;15151:::-;15190:7;15219:20;15233:5;15219:20;:::i;:::-;15208:31;;15151:94;;;:::o;15251:100::-;15290:7;15319:26;15339:5;15319:26;:::i;:::-;15308:37;;15251:100;;;:::o;15357:157::-;15462:45;15482:24;15500:5;15482:24;:::i;:::-;15462:45;:::i;:::-;15457:3;15450:58;15357:157;;:::o;15520:256::-;15632:3;15647:75;15718:3;15709:6;15647:75;:::i;:::-;15747:2;15742:3;15738:12;15731:19;;15767:3;15760:10;;15520:256;;;;:::o;15782:143::-;15839:5;15870:6;15864:13;15855:22;;15886:33;15913:5;15886:33;:::i;:::-;15782:143;;;;:::o;15931:351::-;16001:6;16050:2;16038:9;16029:7;16025:23;16021:32;16018:119;;;16056:79;;:::i;:::-;16018:119;16176:1;16201:64;16257:7;16248:6;16237:9;16233:22;16201:64;:::i;:::-;16191:74;;16147:128;15931:351;;;;:::o;16288:180::-;16336:77;16333:1;16326:88;16433:4;16430:1;16423:15;16457:4;16454:1;16447:15;16474:410;16514:7;16537:20;16555:1;16537:20;:::i;:::-;16532:25;;16571:20;16589:1;16571:20;:::i;:::-;16566:25;;16626:1;16623;16619:9;16648:30;16666:11;16648:30;:::i;:::-;16637:41;;16827:1;16818:7;16814:15;16811:1;16808:22;16788:1;16781:9;16761:83;16738:139;;16857:18;;:::i;:::-;16738:139;16522:362;16474:410;;;;:::o;16890:180::-;16938:77;16935:1;16928:88;17035:4;17032:1;17025:15;17059:4;17056:1;17049:15;17076:185;17116:1;17133:20;17151:1;17133:20;:::i;:::-;17128:25;;17167:20;17185:1;17167:20;:::i;:::-;17162:25;;17206:1;17196:35;;17211:18;;:::i;:::-;17196:35;17253:1;17250;17246:9;17241:14;;17076:185;;;;:::o;17267:194::-;17307:4;17327:20;17345:1;17327:20;:::i;:::-;17322:25;;17361:20;17379:1;17361:20;:::i;:::-;17356:25;;17405:1;17402;17398:9;17390:17;;17429:1;17423:4;17420:11;17417:37;;;17434:18;;:::i;:::-;17417:37;17267:194;;;;:::o;17467:442::-;17616:4;17654:2;17643:9;17639:18;17631:26;;17667:71;17735:1;17724:9;17720:17;17711:6;17667:71;:::i;:::-;17748:72;17816:2;17805:9;17801:18;17792:6;17748:72;:::i;:::-;17830;17898:2;17887:9;17883:18;17874:6;17830:72;:::i;:::-;17467:442;;;;;;:::o

ipfs://13faf6b9d6e1c18d31faa0a2ea5ea2fef0fcf912778139e317f4908d45ca5baf