Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import '@openzeppelin/contracts/access/AccessControl.sol';
import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/security/Pausable.sol';
import '@openzeppelin/contracts/security/ReentrancyGuard.sol';
import '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';

interface IHedzOriginals {
  function balanceOf(address owner) external view returns (uint256 balance);
}

interface IPepeEditions {
  function burn(address __account, uint256 __tokenID, uint256 __amount) external;
}

interface IZogzEditions {
  function balanceOf(address account, uint256 id) external view returns (uint256);

  function burn(address __account, uint256 __tokenID, uint256 __amount) external;
}

interface IPeplicatorNFT {
  function mint(address __account, uint256 __amount) external;
}

contract PeplicatorSales is AccessControl, Ownable, Pausable, ReentrancyGuard {
  error Forbidden();
  error IncorrectPrice();
  error InvalidAddress();
  error InvalidAmount();
  error InvalidProof();
  error MerkleRootNotSet();
  error NotEnoughClaims();
  error WithdrawFailed();

  event DiscountedMintPriceUpdate(uint256 __discountedMintPrice);
  event FullSetOwnersUpdate();
  event HedzOriginalsContractUpdate(address __hedzOriginalsContractUpdate);
  event MerkleRootUpdate(bytes32 __merkleRoot);
  event MintPriceUpdate(uint256 __mintPrice);
  event NFTContractUpdate(address __nftContractUpdate);
  event PepeEditionsContractUpdate(address __pepeEditionsContractAddress);
  event Withdraw(uint256 __amount);
  event ZogzEditionsContractUpdate(address __zogzEditionsContractAddress);

  IPeplicatorNFT private _nftContract;

  IHedzOriginals private _hedzOriginalsContract;
  IPepeEditions private _pepeEditionsContract;
  IZogzEditions private _zogzEditionsContract;

  uint256 private _discountedMintPrice = 0.042 ether;
  uint256 private _mintPrice = 0.1 ether;

  mapping(uint256 => uint256) private _burnForCreditsMap;
  mapping(address => uint256) private _hedzClaims;
  bytes32 private _merkleRoot;

  constructor(
    address __nftContractAddress,
    address __hedzOriginalsContract,
    address __pepeEditionsContractAddress,
    address __zogzEditionsContractAddress
  ) {
    if (
      __nftContractAddress == address(0) ||
      __hedzOriginalsContract == address(0) ||
      __pepeEditionsContractAddress == address(0) ||
      __zogzEditionsContractAddress == address(0)
    ) {
      revert InvalidAddress();
    }

    address sender = _msgSender();

    _nftContract = IPeplicatorNFT(__nftContractAddress);
    _hedzOriginalsContract = IHedzOriginals(__hedzOriginalsContract);
    _pepeEditionsContract = IPepeEditions(__pepeEditionsContractAddress);
    _zogzEditionsContract = IZogzEditions(__zogzEditionsContractAddress);

    _burnForCreditsMap[1] = 1; // ZOGZ Pepe
    _burnForCreditsMap[3] = 10; // ZOGGED Pepe
    _burnForCreditsMap[2] = 50; // HEDZ Pepe
    _burnForCreditsMap[5] = 500; // RARE Pepe
    _burnForCreditsMap[4] = 600; // PEGZ Pepe

    _pause();

    _grantRole(DEFAULT_ADMIN_ROLE, sender);
  }

  ////////////////////////////////////////////////////////////////////////////
  // MODIFIERS
  ////////////////////////////////////////////////////////////////////////////

  modifier onlyEOA() {
    if (tx.origin != msg.sender) {
      revert Forbidden();
    }
    _;
  }

  ////////////////////////////////////////////////////////////////////////////
  // OWNER
  ////////////////////////////////////////////////////////////////////////////

  /**
   * @dev Used to set HEDZ Originals contract.
   *
   * Emits {HedzOriginalsContractUpdate} event.
   *
   */
  function setHedzOriginalsContract(address __hedzOriginalsContractAddress) external onlyOwner {
    _hedzOriginalsContract = IHedzOriginals(__hedzOriginalsContractAddress);

    emit HedzOriginalsContractUpdate(__hedzOriginalsContractAddress);
  }

  /**
   * @dev Used to set NFT contract.
   *
   * Emits {NFTContractUpdate} event.
   *
   */
  function setNFTContract(address __nftContractAddress) external onlyOwner {
    _nftContract = IPeplicatorNFT(__nftContractAddress);

    emit NFTContractUpdate(__nftContractAddress);
  }

  /**
   * @dev Used to set Pepe Editions contract.
   *
   * Emits {PepeEditionsContractUpdate} event.
   *
   */
  function setPepeEditionsContract(address __pepeEditionsContractAddress) external onlyOwner {
    _pepeEditionsContract = IPepeEditions(__pepeEditionsContractAddress);

    emit PepeEditionsContractUpdate(__pepeEditionsContractAddress);
  }

  /**
   * @dev Used to set ZOGZ Editions contract.
   *
   * Emits {ZogzEditionsContractUpdate} event.
   *
   */
  function setZogzEditionsContract(address __zogzEditionsContractAddress) external onlyOwner {
    _zogzEditionsContract = IZogzEditions(__zogzEditionsContractAddress);

    emit ZogzEditionsContractUpdate(__zogzEditionsContractAddress);
  }

  /**
   * @dev Used to set HEDZ Originals contract.
   *
   * Emits {HedzOriginalsContractUpdate} event.
   *
   */
  function setMerkleRoot(bytes32 __merkleRoot) external onlyOwner {
    _merkleRoot = __merkleRoot;

    emit MerkleRootUpdate(__merkleRoot);
  }

  /**
   * @dev Used to withdraw funds from the contract.
   */
  function withdraw(uint256 __amount) external onlyOwner {
    (bool success, ) = owner().call{value: __amount}('');

    if (!success) revert WithdrawFailed();

    emit Withdraw(__amount);
  }

  /**
   * @dev Used to withdraw all funds from the contract.
   */
  function withdrawAll() external onlyOwner {
    uint256 amount = address(this).balance;

    (bool success, ) = owner().call{value: amount}('');

    if (!success) revert WithdrawFailed();

    emit Withdraw(amount);
  }

  ////////////////////////////////////////////////////////////////////////////
  // ADMIN
  ////////////////////////////////////////////////////////////////////////////

  /**
   * @dev Used to set discounted mint price.
   *
   * Emits {DiscountedMintPriceUpdate} event.
   *
   */
  function setDiscountedMintPrice(
    uint256 __discountedMintPrice
  ) external onlyRole(DEFAULT_ADMIN_ROLE) {
    _discountedMintPrice = __discountedMintPrice;

    emit DiscountedMintPriceUpdate(__discountedMintPrice);
  }

  /**
   * @dev Used to set mint price.
   *
   * Emits {MintPriceUpdate} event(s).
   *
   */
  function setMintPrice(uint256 __mintPrice) external onlyRole(DEFAULT_ADMIN_ROLE) {
    _mintPrice = __mintPrice;

    emit MintPriceUpdate(__mintPrice);
  }

  /**
   * @dev Used to pause sale.
   *
   * Emits {Paused} event(s).
   *
   */
  function pause() external onlyRole(DEFAULT_ADMIN_ROLE) {
    _pause();
  }

  /**
   * @dev Used to unpause sale.
   *
   * Emits {Unpaused} event(s).
   *
   */
  function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) {
    _unpause();
  }

  ////////////////////////////////////////////////////////////////////////////
  // WRITES
  ////////////////////////////////////////////////////////////////////////////

  /**
   * @dev Used to mint token(s).
   */
  function mint(uint256 __amount) external payable nonReentrant onlyEOA whenNotPaused {
    address sender = _msgSender();

    if (_mintPrice * __amount != msg.value) {
      revert IncorrectPrice();
    }

    _nftContract.mint(sender, __amount);
  }

  /**
   * @dev Used to mint token(s) with Pepe Editions burn.
   */
  function mintWithPepeEditionsBurn(
    uint256 __amount,
    uint256 __tokenID,
    uint256 __burnAmount
  ) external payable nonReentrant onlyEOA whenNotPaused {
    address sender = _msgSender();

    if (__amount != _burnForCreditsMap[__tokenID] * __burnAmount) {
      revert InvalidAmount();
    }
    if ((_mintPrice * __amount) / 2 != msg.value) {
      revert IncorrectPrice();
    }
    _pepeEditionsContract.burn(sender, __tokenID, __burnAmount);
    _nftContract.mint(sender, __amount);
  }

  /**
   * @dev Used to mint token(s) with ZOGZ Editions burn.
   */
  function mintWithZogzEditionsBurn(
    uint256 __amount,
    uint256 __tokenID
  ) external payable nonReentrant onlyEOA whenNotPaused {
    address sender = _msgSender();

    if ((_mintPrice * __amount) / 2 != msg.value) {
      revert IncorrectPrice();
    }
    _zogzEditionsContract.burn(sender, __tokenID, __amount);
    _nftContract.mint(sender, __amount);
  }

  /**
   * @dev Used to mint token(s) with claims discount.
   */
  function mintWithClaimsDiscount(
    uint256 __amount
  ) external payable nonReentrant onlyEOA whenNotPaused {
    address sender = _msgSender();

    if (_discountedMintPrice * __amount != msg.value) {
      revert IncorrectPrice();
    }
    if (_hedzOriginalsContract.balanceOf(sender) - _hedzClaims[sender] < __amount) {
      revert NotEnoughClaims();
    }
    _hedzClaims[sender] += __amount;
    _nftContract.mint(sender, __amount);
  }

  /**
   * @dev Used to mint token(s) with owner discount.
   */
  function mintWithOwnerDiscount(
    uint256 __amount,
    bytes32[] calldata __proof
  ) external payable nonReentrant onlyEOA whenNotPaused {
    address sender = _msgSender();

    if ((_mintPrice * __amount) / 2 != msg.value) {
      revert IncorrectPrice();
    }

    if (_merkleRoot == 0x0) revert MerkleRootNotSet();

    bool verified = MerkleProof.verify(__proof, _merkleRoot, keccak256(abi.encodePacked(sender)));

    if (!verified) revert Forbidden();

    _nftContract.mint(sender, __amount);
  }

  ////////////////////////////////////////////////////////////////////////////
  // READS
  ////////////////////////////////////////////////////////////////////////////

  /**
   * @dev Returns the discounted mint price.
   */
  function discountedMintPrice() external view returns (uint256) {
    return _discountedMintPrice;
  }

  /**
   * @dev Returns the number of HEDZ claims.
   */
  function hedzClaims(address __account) external view returns (uint256) {
    return _hedzClaims[__account];
  }

  /**
   * @dev Returns the mint price.
   */
  function mintPrice() external view returns (uint256) {
    return _mintPrice;
  }

  /**
   * @dev Returns the merkle root.
   */
  function merkleRoot() external view returns (bytes32) {
    return _merkleRoot;
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;

import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(account),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

{
  "remappings": [
    "@openzeppelin/=lib/openzeppelin-contracts/",
    "forge-std/=lib/forge-std/src/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 1000000
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"__nftContractAddress","type":"address"},{"internalType":"address","name":"__hedzOriginalsContract","type":"address"},{"internalType":"address","name":"__pepeEditionsContractAddress","type":"address"},{"internalType":"address","name":"__zogzEditionsContractAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"Forbidden","type":"error"},{"inputs":[],"name":"IncorrectPrice","type":"error"},{"inputs":[],"name":"InvalidAddress","type":"error"},{"inputs":[],"name":"InvalidAmount","type":"error"},{"inputs":[],"name":"InvalidProof","type":"error"},{"inputs":[],"name":"MerkleRootNotSet","type":"error"},{"inputs":[],"name":"NotEnoughClaims","type":"error"},{"inputs":[],"name":"WithdrawFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"__discountedMintPrice","type":"uint256"}],"name":"DiscountedMintPriceUpdate","type":"event"},{"anonymous":false,"inputs":[],"name":"FullSetOwnersUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"__hedzOriginalsContractUpdate","type":"address"}],"name":"HedzOriginalsContractUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"__merkleRoot","type":"bytes32"}],"name":"MerkleRootUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"__mintPrice","type":"uint256"}],"name":"MintPriceUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"__nftContractUpdate","type":"address"}],"name":"NFTContractUpdate","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"__pepeEditionsContractAddress","type":"address"}],"name":"PepeEditionsContractUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"__amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"__zogzEditionsContractAddress","type":"address"}],"name":"ZogzEditionsContractUpdate","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"discountedMintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"__account","type":"address"}],"name":"hedzClaims","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":"__amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"__amount","type":"uint256"}],"name":"mintWithClaimsDiscount","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"__amount","type":"uint256"},{"internalType":"bytes32[]","name":"__proof","type":"bytes32[]"}],"name":"mintWithOwnerDiscount","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"__amount","type":"uint256"},{"internalType":"uint256","name":"__tokenID","type":"uint256"},{"internalType":"uint256","name":"__burnAmount","type":"uint256"}],"name":"mintWithPepeEditionsBurn","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"__amount","type":"uint256"},{"internalType":"uint256","name":"__tokenID","type":"uint256"}],"name":"mintWithZogzEditionsBurn","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"__discountedMintPrice","type":"uint256"}],"name":"setDiscountedMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"__hedzOriginalsContractAddress","type":"address"}],"name":"setHedzOriginalsContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"__merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"__mintPrice","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"__nftContractAddress","type":"address"}],"name":"setNFTContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"__pepeEditionsContractAddress","type":"address"}],"name":"setPepeEditionsContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"__zogzEditionsContractAddress","type":"address"}],"name":"setZogzEditionsContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"__amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"}]

6080604052669536c70891000060075567016345785d8a00006008553480156200002857600080fd5b50604051620026d1380380620026d18339810160408190526200004b91620003c2565b6200005633620001f4565b6001805460ff60a01b191681556002556001600160a01b03841615806200008457506001600160a01b038316155b806200009757506001600160a01b038216155b80620000aa57506001600160a01b038116155b15620000c95760405163e6c4247b60e01b815260040160405180910390fd5b600380546001600160a01b03199081166001600160a01b038781169190911790925560048054821686841617815560058054831686851617905560068054909216928416929092179055600960205260017f92e85d02570a8092d09a6e3a57665bc3815a2699a4074001bf1ccabf660f5a3655600a7fc575c31fea594a6eb97c8e9d3f9caee4c16218c6ef37e923234c0fe9014a61e75560327f6cde3cea4b3a3fb2488b2808bae7556f4a405e50f65e1794383bc026131b13c3556101f47f74b05292d1d4b2b48b65261b07099d24244bcb069f138d9a6bfdcf776becac4c556000526102587f8dc18c4ccfd75f5c815b63770fa542fd953e8fef7e0e44bbdd4913470ce7e9cb5533620001dc62000246565b620001e9600082620002a9565b50505050506200041f565b600180546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b620002506200034a565b6001805460ff60a01b1916600160a01b1790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586200028c3390565b6040516001600160a01b03909116815260200160405180910390a1565b6000828152602081815260408083206001600160a01b038516845290915290205460ff1662000346576000828152602081815260408083206001600160a01b03851684529091529020805460ff19166001179055620003053390565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45b5050565b6200035e600154600160a01b900460ff1690565b15620003a35760405162461bcd60e51b815260206004820152601060248201526f14185d5cd8589b194e881c185d5cd95960821b604482015260640160405180910390fd5b565b80516001600160a01b0381168114620003bd57600080fd5b919050565b60008060008060808587031215620003d957600080fd5b620003e485620003a5565b9350620003f460208601620003a5565b92506200040460408601620003a5565b91506200041460608601620003a5565b905092959194509250565b6122a2806200042f6000396000f3fe6080604052600436106101d85760003560e01c80637cb6475911610102578063a7ccabdf11610095578063ee1810e211610064578063ee1810e21461055f578063f01cd52c1461057f578063f2fde38b14610592578063f4a0a528146105b257600080fd5b8063a7ccabdf146104ec578063ab2704761461050c578063d547741f1461052c578063e601c5871461054c57600080fd5b8063903f16a3116100d1578063903f16a31461045e57806391d1485414610473578063a0712d68146104c4578063a217fddf146104d757600080fd5b80637cb64759146103df5780638456cb59146103ff578063853828b6146104145780638da5cb5b1461042957600080fd5b8063355b14cd1161017a5780635dcfc5e7116101495780635dcfc5e71461035f57806367bda1fe146103725780636817c76c146103b5578063715018a6146103ca57600080fd5b8063355b14cd146102da57806336568abe146102fa5780633f4ba83a1461031a5780635c975abb1461032f57600080fd5b8063248a9ca3116101b6578063248a9ca3146102475780632e1a7d4d146102855780632eb4a7ab146102a55780632f2ff15d146102ba57600080fd5b806301a51d4f146101dd57806301ffc9a7146101ff5780630249c30214610234575b600080fd5b3480156101e957600080fd5b506101fd6101f8366004611e7c565b6105d2565b005b34801561020b57600080fd5b5061021f61021a366004611e97565b610654565b60405190151581526020015b60405180910390f35b6101fd610242366004611ed9565b6106ed565b34801561025357600080fd5b50610277610262366004611efb565b60009081526020819052604090206001015490565b60405190815260200161022b565b34801561029157600080fd5b506101fd6102a0366004611efb565b6108bb565b3480156102b157600080fd5b50600b54610277565b3480156102c657600080fd5b506101fd6102d5366004611f14565b6109b3565b3480156102e657600080fd5b506101fd6102f5366004611efb565b6109dd565b34801561030657600080fd5b506101fd610315366004611f14565b610a1d565b34801561032657600080fd5b506101fd610ad1565b34801561033b57600080fd5b5060015474010000000000000000000000000000000000000000900460ff1661021f565b6101fd61036d366004611f40565b610ae7565b34801561037e57600080fd5b5061027761038d366004611e7c565b73ffffffffffffffffffffffffffffffffffffffff166000908152600a602052604090205490565b3480156103c157600080fd5b50600854610277565b3480156103d657600080fd5b506101fd610d1f565b3480156103eb57600080fd5b506101fd6103fa366004611efb565b610d33565b34801561040b57600080fd5b506101fd610d70565b34801561042057600080fd5b506101fd610d83565b34801561043557600080fd5b5060015460405173ffffffffffffffffffffffffffffffffffffffff909116815260200161022b565b34801561046a57600080fd5b50600754610277565b34801561047f57600080fd5b5061021f61048e366004611f14565b60009182526020828152604080842073ffffffffffffffffffffffffffffffffffffffff93909316845291905290205460ff1690565b6101fd6104d2366004611efb565b610dad565b3480156104e357600080fd5b50610277600081565b3480156104f857600080fd5b506101fd610507366004611e7c565b610ed7565b34801561051857600080fd5b506101fd610527366004611e7c565b610f52565b34801561053857600080fd5b506101fd610547366004611f14565b610fcd565b6101fd61055a366004611efb565b610ff2565b34801561056b57600080fd5b506101fd61057a366004611e7c565b611209565b6101fd61058d366004611fbf565b611284565b34801561059e57600080fd5b506101fd6105ad366004611e7c565b61149d565b3480156105be57600080fd5b506101fd6105cd366004611efb565b611551565b6105da611591565b600680547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527f7a26fd23eb2bf78a831367b34cefbf214038d6a8cb8f964c1dd82b69153daffb906020015b60405180910390a150565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f7965db0b0000000000000000000000000000000000000000000000000000000014806106e757507f01ffc9a7000000000000000000000000000000000000000000000000000000007fffffffff000000000000000000000000000000000000000000000000000000008316145b92915050565b6106f5611612565b32331461072e576040517fee90c46800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610736611683565b60003390503460028460085461074c919061201a565b6107569190612031565b1461078d576040517f99b5cb1d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6006546040517ff5298aca00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff838116600483015260248201859052604482018690529091169063f5298aca90606401600060405180830381600087803b15801561080857600080fd5b505af115801561081c573d6000803e3d6000fd5b50506003546040517f40c10f1900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85811660048301526024820188905290911692506340c10f199150604401600060405180830381600087803b15801561089457600080fd5b505af11580156108a8573d6000803e3d6000fd5b50505050506108b76001600255565b5050565b6108c3611591565b60006108e460015473ffffffffffffffffffffffffffffffffffffffff1690565b73ffffffffffffffffffffffffffffffffffffffff168260405160006040518083038185875af1925050503d806000811461093b576040519150601f19603f3d011682016040523d82523d6000602084013e610940565b606091505b505090508061097b576040517f750b219c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040518281527f5b6b431d4476a211bb7d41c20d1aab9ae2321deee0d20be3d9fc9b1093fa6e3d906020015b60405180910390a15050565b6000828152602081905260409020600101546109ce81611708565b6109d88383611712565b505050565b60006109e881611708565b60078290556040518281527ffe13cadd4f938dbd8f1835194f0b85803dfdcbee0c61ffe464b587bb2eb34b72906020016109a7565b73ffffffffffffffffffffffffffffffffffffffff81163314610ac7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602f60248201527f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560448201527f20726f6c657320666f722073656c66000000000000000000000000000000000060648201526084015b60405180910390fd5b6108b78282611802565b6000610adc81611708565b610ae46118b9565b50565b610aef611612565b323314610b28576040517fee90c46800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610b30611683565b600033905034600285600854610b46919061201a565b610b509190612031565b14610b87576040517f99b5cb1d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600b54600003610bc3576040517f9f8a28f200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610c4e84848080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525050600b546040517fffffffffffffffffffffffffffffffffffffffff000000000000000000000000606089901b166020820152909250603401905060405160208183030381529060405280519060200120611936565b905080610c87576040517fee90c46800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6003546040517f40c10f1900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff848116600483015260248201889052909116906340c10f1990604401600060405180830381600087803b158015610cfb57600080fd5b505af1158015610d0f573d6000803e3d6000fd5b5050505050506109d86001600255565b610d27611591565b610d31600061194c565b565b610d3b611591565b600b8190556040518181527f504f6d8b1719b8a7c8c1a29372a6ccc5cc7223e099f5fef8bea38a566fca44a090602001610649565b6000610d7b81611708565b610ae46119c3565b610d8b611591565b4760006108e460015473ffffffffffffffffffffffffffffffffffffffff1690565b610db5611612565b323314610dee576040517fee90c46800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610df6611683565b60085433903490610e0890849061201a565b14610e3f576040517f99b5cb1d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6003546040517f40c10f1900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff838116600483015260248201859052909116906340c10f19906044015b600060405180830381600087803b158015610eb457600080fd5b505af1158015610ec8573d6000803e3d6000fd5b5050505050610ae46001600255565b610edf611591565b600380547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527f95251946d3665c6d527d12324c6b604b14fd6c335d1c42d3269a9efd52cb873d90602001610649565b610f5a611591565b600480547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527f08f3c61fe28061177b189973d0be0936a9ce588617dd7f10ea485e9f49cceac790602001610649565b600082815260208190526040902060010154610fe881611708565b6109d88383611802565b610ffa611612565b323314611033576040517fee90c46800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61103b611683565b6007543390349061104d90849061201a565b14611084576040517f99b5cb1d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff8181166000818152600a602052604090819020546004805492517f70a0823100000000000000000000000000000000000000000000000000000000815290810193909352859390929116906370a0823190602401602060405180830381865afa15801561110a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061112e919061206c565b6111389190612085565b1015611170576040517fee3e74af00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff81166000908152600a6020526040812080548492906111a5908490612098565b90915550506003546040517f40c10f1900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff838116600483015260248201859052909116906340c10f1990604401610e9a565b611211611591565b600580547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527f1fe4fb26619133516e006c9fc509f156618eb41656bfbee890ae2f9c819bdd7390602001610649565b61128c611612565b3233146112c5576040517fee90c46800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6112cd611683565b60008281526009602052604090205433906112e990839061201a565b8414611321576040517f2c5211c600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b34600285600854611332919061201a565b61133c9190612031565b14611373576040517f99b5cb1d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6005546040517ff5298aca00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff838116600483015260248201869052604482018590529091169063f5298aca90606401600060405180830381600087803b1580156113ee57600080fd5b505af1158015611402573d6000803e3d6000fd5b50506003546040517f40c10f1900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85811660048301526024820189905290911692506340c10f199150604401600060405180830381600087803b15801561147a57600080fd5b505af115801561148e573d6000803e3d6000fd5b50505050506109d86001600255565b6114a5611591565b73ffffffffffffffffffffffffffffffffffffffff8116611548576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f64647265737300000000000000000000000000000000000000000000000000006064820152608401610abe565b610ae48161194c565b600061155c81611708565b60088290556040518281527f23050b539195eebd064c1bec834445b7d028a20c345600e868a74d7ca93c5e86906020016109a7565b60015473ffffffffffffffffffffffffffffffffffffffff163314610d31576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610abe565b600280540361167d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610abe565b60028055565b60015474010000000000000000000000000000000000000000900460ff1615610d31576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601060248201527f5061757361626c653a20706175736564000000000000000000000000000000006044820152606401610abe565b610ae48133611a32565b60008281526020818152604080832073ffffffffffffffffffffffffffffffffffffffff8516845290915290205460ff166108b75760008281526020818152604080832073ffffffffffffffffffffffffffffffffffffffff85168452909152902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660011790556117a43390565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b60008281526020818152604080832073ffffffffffffffffffffffffffffffffffffffff8516845290915290205460ff16156108b75760008281526020818152604080832073ffffffffffffffffffffffffffffffffffffffff8516808552925280832080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b6118c1611aea565b600180547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff1690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa335b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390a1565b6000826119438584611b6e565b14949350505050565b6001805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6119cb611683565b600180547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff16740100000000000000000000000000000000000000001790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a25861190c3390565b60008281526020818152604080832073ffffffffffffffffffffffffffffffffffffffff8516845290915290205460ff166108b757611a7081611bbb565b611a7b836020611bda565b604051602001611a8c9291906120cf565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152908290527f08c379a0000000000000000000000000000000000000000000000000000000008252610abe91600401612150565b60015474010000000000000000000000000000000000000000900460ff16610d31576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601460248201527f5061757361626c653a206e6f74207061757365640000000000000000000000006044820152606401610abe565b600081815b8451811015611bb357611b9f82868381518110611b9257611b926121a1565b6020026020010151611e24565b915080611bab816121d0565b915050611b73565b509392505050565b60606106e773ffffffffffffffffffffffffffffffffffffffff831660145b60606000611be983600261201a565b611bf4906002612098565b67ffffffffffffffff811115611c0c57611c0c612208565b6040519080825280601f01601f191660200182016040528015611c36576020820181803683370190505b5090507f300000000000000000000000000000000000000000000000000000000000000081600081518110611c6d57611c6d6121a1565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053507f780000000000000000000000000000000000000000000000000000000000000081600181518110611cd057611cd06121a1565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053506000611d0c84600261201a565b611d17906001612098565b90505b6001811115611db4577f303132333435363738396162636465660000000000000000000000000000000085600f1660108110611d5857611d586121a1565b1a60f81b828281518110611d6e57611d6e6121a1565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a90535060049490941c93611dad81612237565b9050611d1a565b508315611e1d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e746044820152606401610abe565b9392505050565b6000818310611e40576000828152602084905260409020611e1d565b6000838152602083905260409020611e1d565b803573ffffffffffffffffffffffffffffffffffffffff81168114611e7757600080fd5b919050565b600060208284031215611e8e57600080fd5b611e1d82611e53565b600060208284031215611ea957600080fd5b81357fffffffff0000000000000000000000000000000000000000000000000000000081168114611e1d57600080fd5b60008060408385031215611eec57600080fd5b50508035926020909101359150565b600060208284031215611f0d57600080fd5b5035919050565b60008060408385031215611f2757600080fd5b82359150611f3760208401611e53565b90509250929050565b600080600060408486031215611f5557600080fd5b83359250602084013567ffffffffffffffff80821115611f7457600080fd5b818601915086601f830112611f8857600080fd5b813581811115611f9757600080fd5b8760208260051b8501011115611fac57600080fd5b6020830194508093505050509250925092565b600080600060608486031215611fd457600080fd5b505081359360208301359350604090920135919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b80820281158282048414176106e7576106e7611feb565b600082612067577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b60006020828403121561207e57600080fd5b5051919050565b818103818111156106e7576106e7611feb565b808201808211156106e7576106e7611feb565b60005b838110156120c65781810151838201526020016120ae565b50506000910152565b7f416363657373436f6e74726f6c3a206163636f756e74200000000000000000008152600083516121078160178501602088016120ab565b7f206973206d697373696e6720726f6c652000000000000000000000000000000060179184019182015283516121448160288401602088016120ab565b01602801949350505050565b602081526000825180602084015261216f8160408501602087016120ab565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169190910160400192915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361220157612201611feb565b5060010190565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60008161224657612246611feb565b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff019056fea26469706673582212206d3608ec3699aecf3c335aab8b45c7ac84d92effffdfdfefea654f788664ee3a64736f6c634300081300330000000000000000000000000baeccd651cf4692a8790bcc4f606e79bf7a3b1c000000000000000000000000efed2a58cc6a5b81f9158b231847f005cf086c010000000000000000000000004faab2f1851b58c26028ab7ba2873ff3c7b52d4c000000000000000000000000808e5cd160d8819ca24c2053037049eb611d0542

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

0000000000000000000000000baeccd651cf4692a8790bcc4f606e79bf7a3b1c000000000000000000000000efed2a58cc6a5b81f9158b231847f005cf086c010000000000000000000000004faab2f1851b58c26028ab7ba2873ff3c7b52d4c000000000000000000000000808e5cd160d8819ca24c2053037049eb611d0542

-----Decoded View---------------
Arg [0] : __nftContractAddress (address): 0x0BaECcD651cf4692A8790BCC4f606E79bF7A3B1c
Arg [1] : __hedzOriginalsContract (address): 0xEfed2A58cC6A5b81f9158B231847f005cF086c01
Arg [2] : __pepeEditionsContractAddress (address): 0x4fAAB2f1851B58c26028ab7bA2873Ff3c7B52D4C
Arg [3] : __zogzEditionsContractAddress (address): 0x808E5Cd160d8819CA24C2053037049EB611D0542

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000baeccd651cf4692a8790bcc4f606e79bf7a3b1c
Arg [1] : 000000000000000000000000efed2a58cc6a5b81f9158b231847f005cf086c01
Arg [2] : 0000000000000000000000004faab2f1851b58c26028ab7ba2873ff3c7b52d4c
Arg [3] : 000000000000000000000000808e5cd160d8819ca24c2053037049eb611d0542