Token

Decal by Panter Xhita (DECAL)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

100 DECAL

Holders

Total Transfers

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x5bef711d0b73bac12b0a0479d1ba7b6668ada471

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Panter_Xhita_Decal

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

Yes with 1 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-07-18
*/

// Sources flattened with hardhat v2.14.0 https://hardhat.org
// File @openzeppelin/contracts/access/[email protected]

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

// File @openzeppelin/contracts/utils/[email protected]

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

pragma solidity ^0.8.0;

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

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

// File @openzeppelin/contracts/utils/introspection/[email protected]

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

// File @openzeppelin/contracts/utils/introspection/[email protected]

// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/utils/math/[email protected]

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

// File @openzeppelin/contracts/utils/[email protected]

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/access/[email protected]

// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/access/[email protected]

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

// File @openzeppelin/contracts/token/ERC721/[email protected]

// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

/**
 * @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 caller.
   *
   * 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/token/ERC721/extensions/[email protected]

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
  /**
   * @dev Returns the token collection name.
   */
  function name() external view returns (string memory);

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

  /**
   * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
   */
  function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File @openzeppelin/contracts/token/ERC721/[email protected]

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
  /**
   * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
   * by `operator` from `from`, this function is called.
   *
   * It must return its Solidity selector to confirm the token transfer.
   * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
   *
   * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
   */
  function onERC721Received(
    address operator,
    address from,
    uint256 tokenId,
    bytes calldata data
  ) external returns (bytes4);
}

// File @openzeppelin/contracts/utils/[email protected]

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
  /**
   * @dev Returns true if `account` is a contract.
   *
   * [IMPORTANT]
   * ====
   * It is unsafe to assume that an address for which this function returns
   * false is an externally-owned account (EOA) and not a contract.
   *
   * Among others, `isContract` will return false for the following
   * types of addresses:
   *
   *  - an externally-owned account
   *  - a contract in construction
   *  - an address where a contract will be created
   *  - an address where a contract lived, but was destroyed
   * ====
   *
   * [IMPORTANT]
   * ====
   * You shouldn't rely on `isContract` to protect against flash loan attacks!
   *
   * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
   * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
   * constructor.
   * ====
   */
  function isContract(address account) internal view returns (bool) {
    // This method relies on extcodesize/address.code.length, which returns 0
    // for contracts in construction, since the code is only stored at the end
    // of the constructor execution.

    return account.code.length > 0;
  }

  /**
   * @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://diligence.consensys.net/posts/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.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
   */
  function sendValue(address payable recipient, uint256 amount) internal {
    require(address(this).balance >= amount, "Address: insufficient balance");

    (bool success, ) = recipient.call{value: amount}("");
    require(
      success,
      "Address: unable to send value, recipient may have reverted"
    );
  }

  /**
   * @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, it is bubbled up by this
   * function (like regular Solidity function calls).
   *
   * 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.
   *
   * _Available since v3.1._
   */
  function functionCall(
    address target,
    bytes memory data
  ) internal returns (bytes memory) {
    return
      functionCallWithValue(target, data, 0, "Address: low-level call failed");
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
   * `errorMessage` as a fallback revert reason when `target` reverts.
   *
   * _Available since v3.1._
   */
  function functionCall(
    address target,
    bytes memory data,
    string memory errorMessage
  ) internal returns (bytes memory) {
    return functionCallWithValue(target, data, 0, errorMessage);
  }

  /**
   * @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`.
   *
   * _Available since v3.1._
   */
  function functionCallWithValue(
    address target,
    bytes memory data,
    uint256 value
  ) internal returns (bytes memory) {
    return
      functionCallWithValue(
        target,
        data,
        value,
        "Address: low-level call with value failed"
      );
  }

  /**
   * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
   * with `errorMessage` as a fallback revert reason when `target` reverts.
   *
   * _Available since v3.1._
   */
  function functionCallWithValue(
    address target,
    bytes memory data,
    uint256 value,
    string memory errorMessage
  ) internal returns (bytes memory) {
    require(
      address(this).balance >= value,
      "Address: insufficient balance for call"
    );
    (bool success, bytes memory returndata) = target.call{value: value}(data);
    return
      verifyCallResultFromTarget(target, success, returndata, errorMessage);
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
   * but performing a static call.
   *
   * _Available since v3.3._
   */
  function functionStaticCall(
    address target,
    bytes memory data
  ) internal view returns (bytes memory) {
    return
      functionStaticCall(target, data, "Address: low-level static call failed");
  }

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

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
   * but performing a delegate call.
   *
   * _Available since v3.4._
   */
  function functionDelegateCall(
    address target,
    bytes memory data
  ) internal returns (bytes memory) {
    return
      functionDelegateCall(
        target,
        data,
        "Address: low-level delegate call failed"
      );
  }

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

  /**
   * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
   * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
   *
   * _Available since v4.8._
   */
  function verifyCallResultFromTarget(
    address target,
    bool success,
    bytes memory returndata,
    string memory errorMessage
  ) internal view returns (bytes memory) {
    if (success) {
      if (returndata.length == 0) {
        // only check isContract if the call was successful and the return data is empty
        // otherwise we already know that it was a contract
        require(isContract(target), "Address: call to non-contract");
      }
      return returndata;
    } else {
      _revert(returndata, errorMessage);
    }
  }

  /**
   * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
   * revert reason or using the provided one.
   *
   * _Available since v4.3._
   */
  function verifyCallResult(
    bool success,
    bytes memory returndata,
    string memory errorMessage
  ) internal pure returns (bytes memory) {
    if (success) {
      return returndata;
    } else {
      _revert(returndata, errorMessage);
    }
  }

  function _revert(
    bytes memory returndata,
    string memory errorMessage
  ) 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(errorMessage);
    }
  }
}

// File @openzeppelin/contracts/token/ERC721/[email protected]

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
  using Address for address;
  using Strings for uint256;

  // Token name
  string private _name;

  // Token symbol
  string private _symbol;

  // Mapping from token ID to owner address
  mapping(uint256 => address) private _owners;

  // Mapping owner address to token count
  mapping(address => uint256) private _balances;

  // Mapping from token ID to approved address
  mapping(uint256 => address) private _tokenApprovals;

  // Mapping from owner to operator approvals
  mapping(address => mapping(address => bool)) private _operatorApprovals;

  /**
   * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
   */
  constructor(string memory name_, string memory symbol_) {
    _name = name_;
    _symbol = symbol_;
  }

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

  /**
   * @dev See {IERC721-balanceOf}.
   */
  function balanceOf(
    address owner
  ) public view virtual override returns (uint256) {
    require(owner != address(0), "ERC721: address zero is not a valid owner");
    return _balances[owner];
  }

  /**
   * @dev See {IERC721-ownerOf}.
   */
  function ownerOf(
    uint256 tokenId
  ) public view virtual override returns (address) {
    address owner = _ownerOf(tokenId);
    require(owner != address(0), "ERC721: invalid token ID");
    return owner;
  }

  /**
   * @dev See {IERC721Metadata-name}.
   */
  function name() public view virtual override returns (string memory) {
    return _name;
  }

  /**
   * @dev See {IERC721Metadata-symbol}.
   */
  function symbol() public view virtual override returns (string memory) {
    return _symbol;
  }

  /**
   * @dev See {IERC721Metadata-tokenURI}.
   */
  function tokenURI(
    uint256 tokenId
  ) public view virtual override returns (string memory) {
    _requireMinted(tokenId);

    string memory baseURI = _baseURI();
    return
      bytes(baseURI).length > 0
        ? string(abi.encodePacked(baseURI, tokenId.toString()))
        : "";
  }

  /**
   * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
   * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
   * by default, can be overridden in child contracts.
   */
  function _baseURI() internal view virtual returns (string memory) {
    return "";
  }

  /**
   * @dev See {IERC721-approve}.
   */
  function approve(address to, uint256 tokenId) public virtual override {
    address owner = ERC721.ownerOf(tokenId);
    require(to != owner, "ERC721: approval to current owner");

    require(
      _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
      "ERC721: approve caller is not token owner or approved for all"
    );

    _approve(to, tokenId);
  }

  /**
   * @dev See {IERC721-getApproved}.
   */
  function getApproved(
    uint256 tokenId
  ) public view virtual override returns (address) {
    _requireMinted(tokenId);

    return _tokenApprovals[tokenId];
  }

  /**
   * @dev See {IERC721-setApprovalForAll}.
   */
  function setApprovalForAll(
    address operator,
    bool approved
  ) public virtual override {
    _setApprovalForAll(_msgSender(), operator, approved);
  }

  /**
   * @dev See {IERC721-isApprovedForAll}.
   */
  function isApprovedForAll(
    address owner,
    address operator
  ) public view virtual override returns (bool) {
    return _operatorApprovals[owner][operator];
  }

  /**
   * @dev See {IERC721-transferFrom}.
   */
  function transferFrom(
    address from,
    address to,
    uint256 tokenId
  ) public virtual override {
    //solhint-disable-next-line max-line-length
    require(
      _isApprovedOrOwner(_msgSender(), tokenId),
      "ERC721: caller is not token owner or approved"
    );

    _transfer(from, to, tokenId);
  }

  /**
   * @dev See {IERC721-safeTransferFrom}.
   */
  function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId
  ) public virtual override {
    safeTransferFrom(from, to, tokenId, "");
  }

  /**
   * @dev See {IERC721-safeTransferFrom}.
   */
  function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId,
    bytes memory data
  ) public virtual override {
    require(
      _isApprovedOrOwner(_msgSender(), tokenId),
      "ERC721: caller is not token owner or approved"
    );
    _safeTransfer(from, to, tokenId, data);
  }

  /**
   * @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.
   *
   * `data` is additional data, it has no specified format and it is sent in call to `to`.
   *
   * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
   * implement alternative mechanisms to perform token transfer, such as signature-based.
   *
   * Requirements:
   *
   * - `from` cannot be the zero address.
   * - `to` cannot be the zero address.
   * - `tokenId` token must exist and be owned by `from`.
   * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
   *
   * Emits a {Transfer} event.
   */
  function _safeTransfer(
    address from,
    address to,
    uint256 tokenId,
    bytes memory data
  ) internal virtual {
    _transfer(from, to, tokenId);
    require(
      _checkOnERC721Received(from, to, tokenId, data),
      "ERC721: transfer to non ERC721Receiver implementer"
    );
  }

  /**
   * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
   */
  function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
    return _owners[tokenId];
  }

  /**
   * @dev Returns whether `tokenId` exists.
   *
   * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
   *
   * Tokens start existing when they are minted (`_mint`),
   * and stop existing when they are burned (`_burn`).
   */
  function _exists(uint256 tokenId) internal view virtual returns (bool) {
    return _ownerOf(tokenId) != address(0);
  }

  /**
   * @dev Returns whether `spender` is allowed to manage `tokenId`.
   *
   * Requirements:
   *
   * - `tokenId` must exist.
   */
  function _isApprovedOrOwner(
    address spender,
    uint256 tokenId
  ) internal view virtual returns (bool) {
    address owner = ERC721.ownerOf(tokenId);
    return (spender == owner ||
      isApprovedForAll(owner, spender) ||
      getApproved(tokenId) == spender);
  }

  /**
   * @dev Safely mints `tokenId` and transfers it to `to`.
   *
   * Requirements:
   *
   * - `tokenId` must not exist.
   * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
   *
   * Emits a {Transfer} event.
   */
  function _safeMint(address to, uint256 tokenId) internal virtual {
    _safeMint(to, tokenId, "");
  }

  /**
   * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
   * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
   */
  function _safeMint(
    address to,
    uint256 tokenId,
    bytes memory data
  ) internal virtual {
    _mint(to, tokenId);
    require(
      _checkOnERC721Received(address(0), to, tokenId, data),
      "ERC721: transfer to non ERC721Receiver implementer"
    );
  }

  /**
   * @dev Mints `tokenId` and transfers it to `to`.
   *
   * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
   *
   * Requirements:
   *
   * - `tokenId` must not exist.
   * - `to` cannot be the zero address.
   *
   * Emits a {Transfer} event.
   */
  function _mint(address to, uint256 tokenId) internal virtual {
    require(to != address(0), "ERC721: mint to the zero address");
    require(!_exists(tokenId), "ERC721: token already minted");

    _beforeTokenTransfer(address(0), to, tokenId, 1);

    // Check that tokenId was not minted by `_beforeTokenTransfer` hook
    require(!_exists(tokenId), "ERC721: token already minted");

    unchecked {
      // Will not overflow unless all 2**256 token ids are minted to the same owner.
      // Given that tokens are minted one by one, it is impossible in practice that
      // this ever happens. Might change if we allow batch minting.
      // The ERC fails to describe this case.
      _balances[to] += 1;
    }

    _owners[tokenId] = to;

    emit Transfer(address(0), to, tokenId);

    _afterTokenTransfer(address(0), to, tokenId, 1);
  }

  /**
   * @dev Destroys `tokenId`.
   * The approval is cleared when the token is burned.
   * This is an internal function that does not check if the sender is authorized to operate on the token.
   *
   * Requirements:
   *
   * - `tokenId` must exist.
   *
   * Emits a {Transfer} event.
   */
  function _burn(uint256 tokenId) internal virtual {
    address owner = ERC721.ownerOf(tokenId);

    _beforeTokenTransfer(owner, address(0), tokenId, 1);

    // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
    owner = ERC721.ownerOf(tokenId);

    // Clear approvals
    delete _tokenApprovals[tokenId];

    unchecked {
      // Cannot overflow, as that would require more tokens to be burned/transferred
      // out than the owner initially received through minting and transferring in.
      _balances[owner] -= 1;
    }
    delete _owners[tokenId];

    emit Transfer(owner, address(0), tokenId);

    _afterTokenTransfer(owner, address(0), tokenId, 1);
  }

  /**
   * @dev Transfers `tokenId` from `from` to `to`.
   *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
   *
   * Requirements:
   *
   * - `to` cannot be the zero address.
   * - `tokenId` token must be owned by `from`.
   *
   * Emits a {Transfer} event.
   */
  function _transfer(
    address from,
    address to,
    uint256 tokenId
  ) internal virtual {
    require(
      ERC721.ownerOf(tokenId) == from,
      "ERC721: transfer from incorrect owner"
    );
    require(to != address(0), "ERC721: transfer to the zero address");

    _beforeTokenTransfer(from, to, tokenId, 1);

    // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
    require(
      ERC721.ownerOf(tokenId) == from,
      "ERC721: transfer from incorrect owner"
    );

    // Clear approvals from the previous owner
    delete _tokenApprovals[tokenId];

    unchecked {
      // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
      // `from`'s balance is the number of token held, which is at least one before the current
      // transfer.
      // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
      // all 2**256 token ids to be minted, which in practice is impossible.
      _balances[from] -= 1;
      _balances[to] += 1;
    }
    _owners[tokenId] = to;

    emit Transfer(from, to, tokenId);

    _afterTokenTransfer(from, to, tokenId, 1);
  }

  /**
   * @dev Approve `to` to operate on `tokenId`
   *
   * Emits an {Approval} event.
   */
  function _approve(address to, uint256 tokenId) internal virtual {
    _tokenApprovals[tokenId] = to;
    emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
  }

  /**
   * @dev Approve `operator` to operate on all of `owner` tokens
   *
   * Emits an {ApprovalForAll} event.
   */
  function _setApprovalForAll(
    address owner,
    address operator,
    bool approved
  ) internal virtual {
    require(owner != operator, "ERC721: approve to caller");
    _operatorApprovals[owner][operator] = approved;
    emit ApprovalForAll(owner, operator, approved);
  }

  /**
   * @dev Reverts if the `tokenId` has not been minted yet.
   */
  function _requireMinted(uint256 tokenId) internal view virtual {
    require(_exists(tokenId), "ERC721: invalid token ID");
  }

  /**
   * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
   * The call is not executed if the target address is not a contract.
   *
   * @param from address representing the previous owner of the given token ID
   * @param to target address that will receive the tokens
   * @param tokenId uint256 ID of the token to be transferred
   * @param data bytes optional data to send along with the call
   * @return bool whether the call correctly returned the expected magic value
   */
  function _checkOnERC721Received(
    address from,
    address to,
    uint256 tokenId,
    bytes memory data
  ) private returns (bool) {
    if (to.isContract()) {
      try
        IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data)
      returns (bytes4 retval) {
        return retval == IERC721Receiver.onERC721Received.selector;
      } catch (bytes memory reason) {
        if (reason.length == 0) {
          revert("ERC721: transfer to non ERC721Receiver implementer");
        } else {
          /// @solidity memory-safe-assembly
          assembly {
            revert(add(32, reason), mload(reason))
          }
        }
      }
    } else {
      return true;
    }
  }

  /**
   * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
   * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
   *
   * Calling conditions:
   *
   * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
   * - When `from` is zero, the tokens will be minted for `to`.
   * - When `to` is zero, ``from``'s tokens will be burned.
   * - `from` and `to` are never both zero.
   * - `batchSize` is non-zero.
   *
   * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
   */
  function _beforeTokenTransfer(
    address from,
    address to,
    uint256 /* firstTokenId */,
    uint256 batchSize
  ) internal virtual {
    if (batchSize > 1) {
      if (from != address(0)) {
        _balances[from] -= batchSize;
      }
      if (to != address(0)) {
        _balances[to] += batchSize;
      }
    }
  }

  /**
   * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
   * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
   *
   * Calling conditions:
   *
   * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
   * - When `from` is zero, the tokens were minted for `to`.
   * - When `to` is zero, ``from``'s tokens were burned.
   * - `from` and `to` are never both zero.
   * - `batchSize` is non-zero.
   *
   * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
   */
  function _afterTokenTransfer(
    address from,
    address to,
    uint256 firstTokenId,
    uint256 batchSize
  ) internal virtual {}
}

// File @openzeppelin/contracts/security/[email protected]

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

pragma solidity ^0.8.0;

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

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

  uint256 private _status;

  constructor() {
    _status = _NOT_ENTERED;
  }

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

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

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

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

// File @openzeppelin/contracts/utils/cryptography/[email protected]

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File contracts/utils/Errors.sol

pragma solidity ^0.8.17;

error MaxSupplyReached();
error AlreadyMinted();
error NotOnAllowlist();
error CannotMintFromContract();
error NotArtist();
error NoArtist();
error MaxArtistSupplyReached();
error CannotMintZero();
error MaxPublicSupplyReached();

// File contracts/utils/lib/Constants.sol

pragma solidity ^0.8.13;

address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E;
address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;

// File contracts/utils/IOperatorFilterRegistry.sol

pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
  /**
   * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
   *         true if supplied registrant address is not registered.
   */
  function isOperatorAllowed(
    address registrant,
    address operator
  ) external view returns (bool);

  /**
   * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
   */
  function register(address registrant) external;

  /**
   * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
   */
  function registerAndSubscribe(
    address registrant,
    address subscription
  ) external;

  /**
   * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
   *         address without subscribing.
   */
  function registerAndCopyEntries(
    address registrant,
    address registrantToCopy
  ) external;

  /**
   * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
   *         Note that this does not remove any filtered addresses or codeHashes.
   *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
   */
  function unregister(address addr) external;

  /**
   * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
   */
  function updateOperator(
    address registrant,
    address operator,
    bool filtered
  ) external;

  /**
   * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
   */
  function updateOperators(
    address registrant,
    address[] calldata operators,
    bool filtered
  ) external;

  /**
   * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
   */
  function updateCodeHash(
    address registrant,
    bytes32 codehash,
    bool filtered
  ) external;

  /**
   * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
   */
  function updateCodeHashes(
    address registrant,
    bytes32[] calldata codeHashes,
    bool filtered
  ) external;

  /**
   * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
   *         subscription if present.
   *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
   *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
   *         used.
   */
  function subscribe(
    address registrant,
    address registrantToSubscribe
  ) external;

  /**
   * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
   */
  function unsubscribe(address registrant, bool copyExistingEntries) external;

  /**
   * @notice Get the subscription address of a given registrant, if any.
   */
  function subscriptionOf(address addr) external returns (address registrant);

  /**
   * @notice Get the set of addresses subscribed to a given registrant.
   *         Note that order is not guaranteed as updates are made.
   */
  function subscribers(address registrant) external returns (address[] memory);

  /**
   * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
   *         Note that order is not guaranteed as updates are made.
   */
  function subscriberAt(
    address registrant,
    uint256 index
  ) external returns (address);

  /**
   * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
   */
  function copyEntriesOf(address registrant, address registrantToCopy) external;

  /**
   * @notice Returns true if operator is filtered by a given address or its subscription.
   */
  function isOperatorFiltered(
    address registrant,
    address operator
  ) external returns (bool);

  /**
   * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
   */
  function isCodeHashOfFiltered(
    address registrant,
    address operatorWithCode
  ) external returns (bool);

  /**
   * @notice Returns true if a codeHash is filtered by a given address or its subscription.
   */
  function isCodeHashFiltered(
    address registrant,
    bytes32 codeHash
  ) external returns (bool);

  /**
   * @notice Returns a list of filtered operators for a given address or its subscription.
   */
  function filteredOperators(address addr) external returns (address[] memory);

  /**
   * @notice Returns the set of filtered codeHashes for a given address or its subscription.
   *         Note that order is not guaranteed as updates are made.
   */
  function filteredCodeHashes(address addr) external returns (bytes32[] memory);

  /**
   * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
   *         its subscription.
   *         Note that order is not guaranteed as updates are made.
   */
  function filteredOperatorAt(
    address registrant,
    uint256 index
  ) external returns (address);

  /**
   * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
   *         its subscription.
   *         Note that order is not guaranteed as updates are made.
   */
  function filteredCodeHashAt(
    address registrant,
    uint256 index
  ) external returns (bytes32);

  /**
   * @notice Returns true if an address has registered
   */
  function isRegistered(address addr) external returns (bool);

  /**
   * @dev Convenience method to compute the code hash of an arbitrary contract
   */
  function codeHashOf(address addr) external returns (bytes32);
}

// File contracts/utils/UpdatableOperatorFilterer.sol

pragma solidity ^0.8.13;

/**
 * @title  UpdatableOperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry. This contract allows the Owner to update the
 *         OperatorFilterRegistry address via updateOperatorFilterRegistryAddress, including to the zero address,
 *         which will bypass registry checks.
 *         Note that OpenSea will still disable creator earnings enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract UpdatableOperatorFilterer {
  /// @dev Emitted when an operator is not allowed.
  error OperatorNotAllowed(address operator);
  /// @dev Emitted when someone other than the owner is trying to call an only owner function.
  error OnlyOwner();

  event OperatorFilterRegistryAddressUpdated(address newRegistry);

  IOperatorFilterRegistry public operatorFilterRegistry;

  /// @dev The constructor that is called when the contract is being deployed.
  constructor(
    address _registry,
    address subscriptionOrRegistrantToCopy,
    bool subscribe
  ) {
    IOperatorFilterRegistry registry = IOperatorFilterRegistry(_registry);
    operatorFilterRegistry = registry;
    // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
    // will not revert, but the contract will need to be registered with the registry once it is deployed in
    // order for the modifier to filter addresses.
    if (address(registry).code.length > 0) {
      if (subscribe) {
        registry.registerAndSubscribe(
          address(this),
          subscriptionOrRegistrantToCopy
        );
      } else {
        if (subscriptionOrRegistrantToCopy != address(0)) {
          registry.registerAndCopyEntries(
            address(this),
            subscriptionOrRegistrantToCopy
          );
        } else {
          registry.register(address(this));
        }
      }
    }
  }

  /**
   * @dev A helper function to check if the operator is allowed.
   */
  modifier onlyAllowedOperator(address from) virtual {
    // Allow spending tokens from addresses with balance
    // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
    // from an EOA.
    if (from != msg.sender) {
      _checkFilterOperator(msg.sender);
    }
    _;
  }

  /**
   * @dev A helper function to check if the operator approval is allowed.
   */
  modifier onlyAllowedOperatorApproval(address operator) virtual {
    _checkFilterOperator(operator);
    _;
  }

  /**
   * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero
   *         address, checks will be bypassed. OnlyOwner.
   */
  function updateOperatorFilterRegistryAddress(
    address newRegistry
  ) public virtual {
    if (msg.sender != owner()) {
      revert OnlyOwner();
    }
    operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
    emit OperatorFilterRegistryAddressUpdated(newRegistry);
  }

  /**
   * @dev Assume the contract has an owner, but leave specific Ownable implementation up to inheriting contract.
   */
  function owner() public view virtual returns (address);

  /**
   * @dev A helper function to check if the operator is allowed.
   */
  function _checkFilterOperator(address operator) internal view virtual {
    IOperatorFilterRegistry registry = operatorFilterRegistry;
    // Check registry code length to facilitate testing in environments without a deployed registry.
    if (address(registry) != address(0) && address(registry).code.length > 0) {
      // under normal circumstances, this function will revert rather than return false, but inheriting contracts
      // may specify their own OperatorFilterRegistry implementations, which may behave differently
      if (!registry.isOperatorAllowed(address(this), operator)) {
        revert OperatorNotAllowed(operator);
      }
    }
  }
}

// File contracts/utils/RevokableOperatorFilterer.sol

pragma solidity ^0.8.13;

/**
 * @title  RevokableOperatorFilterer
 * @notice This contract is meant to allow contracts to permanently skip OperatorFilterRegistry checks if desired. The
 *         Registry itself has an "unregister" function, but if the contract is ownable, the owner can re-register at
 *         any point. As implemented, this abstract contract allows the contract owner to permanently skip the
 *         OperatorFilterRegistry checks by calling revokeOperatorFilterRegistry. Once done, the registry
 *         address cannot be further updated.
 *         Note that OpenSea will still disable creator earnings enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 */
abstract contract RevokableOperatorFilterer is UpdatableOperatorFilterer {
  /// @dev Emitted when the registry has already been revoked.
  error RegistryHasBeenRevoked();
  /// @dev Emitted when the initial registry address is attempted to be set to the zero address.
  error InitialRegistryAddressCannotBeZeroAddress();

  event OperatorFilterRegistryRevoked();

  bool public isOperatorFilterRegistryRevoked;

  /// @dev The constructor that is called when the contract is being deployed.
  constructor(
    address _registry,
    address subscriptionOrRegistrantToCopy,
    bool subscribe
  )
    UpdatableOperatorFilterer(
      _registry,
      subscriptionOrRegistrantToCopy,
      subscribe
    )
  {
    // don't allow creating a contract with a permanently revoked registry
    if (_registry == address(0)) {
      revert InitialRegistryAddressCannotBeZeroAddress();
    }
  }

  /**
   * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero
   *         address, checks will be permanently bypassed, and the address cannot be updated again. OnlyOwner.
   */
  function updateOperatorFilterRegistryAddress(
    address newRegistry
  ) public override {
    if (msg.sender != owner()) {
      revert OnlyOwner();
    }
    // if registry has been revoked, do not allow further updates
    if (isOperatorFilterRegistryRevoked) {
      revert RegistryHasBeenRevoked();
    }

    operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
    emit OperatorFilterRegistryAddressUpdated(newRegistry);
  }

  /**
   * @notice Revoke the OperatorFilterRegistry address, permanently bypassing checks. OnlyOwner.
   */
  function revokeOperatorFilterRegistry() public {
    if (msg.sender != owner()) {
      revert OnlyOwner();
    }
    // if registry has been revoked, do not allow further updates
    if (isOperatorFilterRegistryRevoked) {
      revert RegistryHasBeenRevoked();
    }

    // set to zero address to bypass checks
    operatorFilterRegistry = IOperatorFilterRegistry(address(0));
    isOperatorFilterRegistryRevoked = true;
    emit OperatorFilterRegistryRevoked();
  }
}

// File contracts/utils/RevokableDefaultOperatorFilterer.sol

pragma solidity ^0.8.13;

/**
 * @title  RevokableDefaultOperatorFilterer
 * @notice Inherits from RevokableOperatorFilterer and automatically subscribes to the default OpenSea subscription.
 *         Note that OpenSea will disable creator earnings enforcement if filtered operators begin fulfilling orders
 *         on-chain, eg, if the registry is revoked or bypassed.
 */

abstract contract RevokableDefaultOperatorFilterer is
  RevokableOperatorFilterer
{
  /// @dev The constructor that is called when the contract is being deployed.
  constructor()
    RevokableOperatorFilterer(
      CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS,
      CANONICAL_CORI_SUBSCRIPTION,
      true
    )
  {}
}

// File contracts/Panter_Xhita_Decal.sol

pragma solidity ^0.8.17;

/// @author @0x__jj, @llio (Deca)
contract Panter_Xhita_Decal is
  ERC721,
  ReentrancyGuard,
  AccessControl,
  RevokableDefaultOperatorFilterer,
  Ownable
{
  using Address for address;
  using Strings for *;

  event ArtistMinted(uint256 numberOfTokens, uint256 remainingArtistSupply);

  mapping(address => bool) public minted;

  uint256 public totalSupply = 0;

  uint256 public constant MAX_SUPPLY = 100;

  bytes32 public merkleRoot;

  uint256 public artistMaxSupply;

  uint256 public artistSupply;

  address public artist;

  string public baseUri;

  constructor(
    string memory _baseUri,
    address[] memory _admins,
    uint256 _artistMaxSupply,
    address _artist
  ) ERC721("Decal by Panter Xhita", "DECAL") {
    if (_artistMaxSupply > MAX_SUPPLY) revert MaxSupplyReached();
    _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    for (uint256 i = 0; i < _admins.length; i++) {
      _grantRole(DEFAULT_ADMIN_ROLE, _admins[i]);
    }
    baseUri = _baseUri;
    artistMaxSupply = _artistMaxSupply;
    artist = _artist;
  }

  function setArtist(address _artist) external onlyRole(DEFAULT_ADMIN_ROLE) {
    artist = _artist;
  }

  function setArtistMaxSupply(
    uint256 _artistMaxSupply
  ) external onlyRole(DEFAULT_ADMIN_ROLE) {
    if ((_artistMaxSupply - artistSupply) > (MAX_SUPPLY - totalSupply))
      revert MaxArtistSupplyReached();
    artistMaxSupply = _artistMaxSupply;
  }

  function setMerkleRoot(
    bytes32 _merkleRoot
  ) external onlyRole(DEFAULT_ADMIN_ROLE) {
    merkleRoot = _merkleRoot;
  }

  function setBaseUri(
    string memory _newBaseUri
  ) external onlyRole(DEFAULT_ADMIN_ROLE) {
    baseUri = _newBaseUri;
  }

  function mint(
    bytes32[] calldata _merkleProof
  ) external nonReentrant returns (uint256 tokenId) {
    if (minted[msg.sender]) revert AlreadyMinted();
    if (totalSupply >= MAX_SUPPLY) revert MaxSupplyReached();
    if (publicSupplyRemaining() < 1) revert MaxPublicSupplyReached();
    if (msg.sender.isContract()) revert CannotMintFromContract();
    bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
    if (!MerkleProof.verify(_merkleProof, merkleRoot, leaf))
      revert NotOnAllowlist();
    minted[msg.sender] = true;
    tokenId = totalSupply;
    totalSupply++;
    _safeMint(msg.sender, tokenId);
  }

  function artistMintForAdmin(
    uint256 _numberOfTokens
  ) external nonReentrant onlyRole(DEFAULT_ADMIN_ROLE) {
    if (_numberOfTokens == 0) revert CannotMintZero();
    if (artist == address(0)) revert NoArtist();
    uint256 remaining = artistMaxSupply - artistSupply;
    if (remaining == 0) revert MaxArtistSupplyReached();
    _numberOfTokens = uint256(Math.min(_numberOfTokens, remaining));
    uint256 tokenId = totalSupply;
    for (uint256 i = 0; i < _numberOfTokens; i++) {
      _safeMint(artist, tokenId);
      tokenId++;
    }
    artistSupply += _numberOfTokens;
    totalSupply = tokenId;
    emit ArtistMinted(_numberOfTokens, remaining);
  }

  function artistMint(uint256 _numberOfTokens) external nonReentrant {
    if (_numberOfTokens == 0) revert CannotMintZero();
    if (artist == address(0)) revert NoArtist();
    if (msg.sender != artist) revert NotArtist();
    uint256 remaining = artistMaxSupply - artistSupply;
    if (remaining == 0) revert MaxArtistSupplyReached();
    _numberOfTokens = uint256(Math.min(_numberOfTokens, remaining));
    uint256 tokenId = totalSupply;
    for (uint256 i = 0; i < _numberOfTokens; i++) {
      _safeMint(msg.sender, tokenId);
      tokenId++;
    }
    artistSupply += _numberOfTokens;
    totalSupply = tokenId;
    emit ArtistMinted(_numberOfTokens, remaining);
  }

  function publicSupplyRemaining() public view returns (uint256) {
    return MAX_SUPPLY - totalSupply - (artistMaxSupply - artistSupply);
  }

  function artistSupplyRemaining() external view returns (uint256) {
    return artistMaxSupply - artistSupply;
  }

  function tokenURI(
    uint256 _tokenId
  ) public view override(ERC721) returns (string memory) {
    require(_exists(_tokenId), "DECAL: URI query for nonexistent token");
    string memory baseURI = _baseURI();
    require(bytes(baseURI).length > 0, "baseURI not set");
    return string(abi.encodePacked(baseURI, _tokenId.toString()));
  }

  function getTokensOfOwner(
    address owner_
  ) external view returns (uint256[] memory) {
    uint256 tokenCount = balanceOf(owner_);
    uint256[] memory tokenIds = new uint256[](tokenCount);
    uint256 seen = 0;
    for (uint256 i = 0; i < totalSupply; i++) {
      if (ownerOf(i) == owner_) {
        tokenIds[seen] = i;
        seen++;
      }
      if (seen == tokenCount) break;
    }
    return tokenIds;
  }

  /**
   * @dev See {IERC165-supportsInterface}.
   */
  function supportsInterface(
    bytes4 interfaceId
  ) public view virtual override(ERC721, AccessControl) returns (bool) {
    return super.supportsInterface(interfaceId);
  }

  function _baseURI() internal view override(ERC721) returns (string memory) {
    return baseUri;
  }

  function setApprovalForAll(
    address operator,
    bool approved
  ) public override onlyAllowedOperatorApproval(operator) {
    super.setApprovalForAll(operator, approved);
  }

  function approve(
    address operator,
    uint256 tokenId
  ) public override onlyAllowedOperatorApproval(operator) {
    super.approve(operator, tokenId);
  }

  function transferFrom(
    address from,
    address to,
    uint256 tokenId
  ) public override onlyAllowedOperator(from) {
    super.transferFrom(from, to, tokenId);
  }

  function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId
  ) public override onlyAllowedOperator(from) {
    super.safeTransferFrom(from, to, tokenId);
  }

  function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId,
    bytes memory data
  ) public override onlyAllowedOperator(from) {
    super.safeTransferFrom(from, to, tokenId, data);
  }

  function owner()
    public
    view
    virtual
    override(Ownable, UpdatableOperatorFilterer)
    returns (address)
  {
    return Ownable.owner();
  }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_baseUri","type":"string"},{"internalType":"address[]","name":"_admins","type":"address[]"},{"internalType":"uint256","name":"_artistMaxSupply","type":"uint256"},{"internalType":"address","name":"_artist","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyMinted","type":"error"},{"inputs":[],"name":"CannotMintFromContract","type":"error"},{"inputs":[],"name":"CannotMintZero","type":"error"},{"inputs":[],"name":"InitialRegistryAddressCannotBeZeroAddress","type":"error"},{"inputs":[],"name":"MaxArtistSupplyReached","type":"error"},{"inputs":[],"name":"MaxPublicSupplyReached","type":"error"},{"inputs":[],"name":"MaxSupplyReached","type":"error"},{"inputs":[],"name":"NoArtist","type":"error"},{"inputs":[],"name":"NotArtist","type":"error"},{"inputs":[],"name":"NotOnAllowlist","type":"error"},{"inputs":[],"name":"OnlyOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"RegistryHasBeenRevoked","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"numberOfTokens","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"remainingArtistSupply","type":"uint256"}],"name":"ArtistMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newRegistry","type":"address"}],"name":"OperatorFilterRegistryAddressUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"OperatorFilterRegistryRevoked","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":"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":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"artist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"artistMaxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numberOfTokens","type":"uint256"}],"name":"artistMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numberOfTokens","type":"uint256"}],"name":"artistMintForAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"artistSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"artistSupplyRemaining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"address","name":"owner_","type":"address"}],"name":"getTokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"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":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOperatorFilterRegistryRevoked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"mint","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorFilterRegistry","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSupplyRemaining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"revokeOperatorFilterRegistry","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":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_artist","type":"address"}],"name":"setArtist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_artistMaxSupply","type":"uint256"}],"name":"setArtistMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseUri","type":"string"}],"name":"setBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","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":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRegistry","type":"address"}],"name":"updateOperatorFilterRegistryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

60806040526000600b553480156200001657600080fd5b50604051620031903803806200319083398101604081905262000039916200050f565b6daaeb6d7670e522a718067333cd4e733cc6cdda760b79bafa08df41ecfa224f810dceb660018282826040518060400160405280601581526020017f446563616c2062792050616e746572205868697461000000000000000000000081525060405180604001604052806005815260200164111150d05360da1b8152508160009081620000c7919062000696565b506001620000d6828262000696565b5050600160065550600880546001600160a01b0319166001600160a01b03851690811790915583903b15620002125781156200017657604051633e9f1edf60e11b81526001600160a01b03821690637d3e3dbe906200013c903090879060040162000762565b600060405180830381600087803b1580156200015757600080fd5b505af11580156200016c573d6000803e3d6000fd5b5050505062000212565b6001600160a01b03831615620001b65760405163a0af290360e01b81526001600160a01b0382169063a0af2903906200013c903090879060040162000762565b604051632210724360e11b81523060048201526001600160a01b03821690634420e48690602401600060405180830381600087803b158015620001f857600080fd5b505af11580156200020d573d6000803e3d6000fd5b505050505b5050506001600160a01b03841690506200023f5760405163c49d17ad60e01b815260040160405180910390fd5b5050506200025c620002566200031d60201b60201c565b62000321565b60648211156200027f5760405163d05cb60960e01b815260040160405180910390fd5b6200028c60003362000373565b60005b8351811015620002df57620002ca6000801b858381518110620002b657620002b66200077c565b60200260200101516200037360201b60201c565b80620002d68162000792565b9150506200028f565b506010620002ee858262000696565b50600d91909155600f80546001600160a01b0319166001600160a01b0390921691909117905550620007ba9050565b3390565b600980546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60008281526007602090815260408083206001600160a01b038516845290915290205460ff16620004145760008281526007602090815260408083206001600160a01b03851684529091529020805460ff19166001179055620003d33390565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45b5050565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f191681016001600160401b038111828210171562000459576200045962000418565b604052919050565b80516001600160a01b03811681146200047957600080fd5b919050565b600082601f8301126200049057600080fd5b815160206001600160401b03821115620004ae57620004ae62000418565b8160051b620004bf8282016200042e565b9283528481018201928281019087851115620004da57600080fd5b83870192505b848310156200050457620004f48362000461565b82529183019190830190620004e0565b979650505050505050565b600080600080608085870312156200052657600080fd5b84516001600160401b03808211156200053e57600080fd5b818701915087601f8301126200055357600080fd5b81518181111562000568576200056862000418565b60206200057e601f8301601f191682016200042e565b8281528a828487010111156200059357600080fd5b60005b83811015620005b357858101830151828201840152820162000596565b506000928101820192909252880151909650915080821115620005d557600080fd5b50620005e4878288016200047e565b93505060408501519150620005fc6060860162000461565b905092959194509250565b600181811c908216806200061c57607f821691505b6020821081036200063d57634e487b7160e01b600052602260045260246000fd5b50919050565b601f8211156200069157600081815260208120601f850160051c810160208610156200066c5750805b601f850160051c820191505b818110156200068d5782815560010162000678565b5050505b505050565b81516001600160401b03811115620006b257620006b262000418565b620006ca81620006c3845462000607565b8462000643565b602080601f831160018114620007025760008415620006e95750858301515b600019600386901b1c1916600185901b1785556200068d565b600085815260208120601f198616915b82811015620007335788860151825594840194600190910190840162000712565b5085821015620007525787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b6001600160a01b0392831681529116602082015260400190565b634e487b7160e01b600052603260045260246000fd5b600060018201620007b357634e487b7160e01b600052601160045260246000fd5b5060010190565b6129c680620007ca6000396000f3fe608060405234801561001057600080fd5b50600436106102045760003560e01c806301ffc9a71461020957806306fdde03146102315780630798f69714610246578063081812fc1461025b578063095ea7b31461027b57806318160ddd1461028e5780631e7269c5146102a557806323b872dd146102c8578063248a9ca3146102db5780632eb4a7ab146102ee5780632f2ff15d146102f757806332cb6b0c1461030a57806336568abe1461031257806342842e0e1461032557806343bc1612146103385780635de6dc551461034b5780635ef9432a1461036b5780636352211e1461037357806370a0823114610386578063715018a61461039957806371a4c485146103a15780637cb64759146103aa5780637e5b8106146103bd5780638da5cb5b146103c657806391d14854146103ce57806395d89b41146103e15780639abc8320146103e95780639f3632fb146103f1578063a0bcfc7f14610404578063a217fddf14610417578063a22cb4651461041f578063a96f38dd14610432578063b0ccc31e1461043a578063b77a147b1461044d578063b88d4fde14610460578063b8d1e53214610473578063bf113baf14610486578063c3ad8e9814610499578063c87b56dd146104a1578063d4c97533146104b4578063d547741f146104c7578063e985e9c5146104da578063ecba222a146104ed578063f2fde38b14610501575b600080fd5b61021c610217366004612124565b610514565b60405190151581526020015b60405180910390f35b610239610525565b6040516102289190612191565b6102596102543660046121a4565b6105b7565b005b61026e6102693660046121a4565b610602565b60405161022891906121bd565b6102596102893660046121ed565b610629565b610297600b5481565b604051908152602001610228565b61021c6102b3366004612217565b600a6020526000908152604090205460ff1681565b6102596102d6366004612232565b610642565b6102976102e93660046121a4565b61066d565b610297600c5481565b61025961030536600461226e565b610682565b610297606481565b61025961032036600461226e565b61069e565b610259610333366004612232565b610721565b600f5461026e906001600160a01b031681565b61035e610359366004612217565b610746565b604051610228919061229a565b610259610819565b61026e6103813660046121a4565b6108be565b610297610394366004612217565b6108f2565b610259610978565b610297600d5481565b6102596103b83660046121a4565b61098c565b610297600e5481565b61026e61099d565b61021c6103dc36600461226e565b6109b6565b6102396109e1565b6102396109f0565b6102596103ff3660046121a4565b610a7e565b610259610412366004612369565b610bb5565b610297600081565b61025961042d3660046123bf565b610bcc565b610297610be0565b60085461026e906001600160a01b031681565b61029761045b3660046123f6565b610c0a565b61025961046e36600461246a565b610d8f565b610259610481366004612217565b610dbc565b6102596104943660046121a4565b610e76565b610297610fbd565b6102396104af3660046121a4565b610fcf565b6102596104c2366004612217565b6110b6565b6102596104d536600461226e565b6110e4565b61021c6104e83660046124e5565b611100565b60085461021c90600160a01b900460ff1681565b61025961050f366004612217565b61112e565b600061051f826111a4565b92915050565b6060600080546105349061250f565b80601f01602080910402602001604051908101604052809291908181526020018280546105609061250f565b80156105ad5780601f10610582576101008083540402835291602001916105ad565b820191906000526020600020905b81548152906001019060200180831161059057829003601f168201915b5050505050905090565b60006105c2816111c9565b600b546105d090606461255f565b600e546105dd908461255f565b11156105fc5760405163d5c4417960e01b815260040160405180910390fd5b50600d55565b600061060d826111d3565b506000908152600460205260409020546001600160a01b031690565b81610633816111f8565b61063d83836112b1565b505050565b826001600160a01b038116331461065c5761065c336111f8565b6106678484846113c1565b50505050565b60009081526007602052604090206001015490565b61068b8261066d565b610694816111c9565b61063d83836113f2565b6001600160a01b03811633146107135760405162461bcd60e51b815260206004820152602f60248201527f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560448201526e103937b632b9903337b91039b2b63360891b60648201526084015b60405180910390fd5b61071d8282611478565b5050565b826001600160a01b038116331461073b5761073b336111f8565b6106678484846114df565b60606000610753836108f2565b90506000816001600160401b0381111561076f5761076f6122de565b604051908082528060200260200182016040528015610798578160200160208202803683370190505b5090506000805b600b5481101561080f57856001600160a01b03166107bc826108be565b6001600160a01b0316036107f657808383815181106107dd576107dd612572565b6020908102919091010152816107f281612588565b9250505b81841461080f578061080781612588565b91505061079f565b5090949350505050565b61082161099d565b6001600160a01b0316336001600160a01b03161461085257604051635fc483c560e01b815260040160405180910390fd5b600854600160a01b900460ff161561087d57604051631551a48f60e11b815260040160405180910390fd5b600880546001600160a81b031916600160a01b1790556040517f51e2d870cc2e10853e38dc06fcdae46ad3c3f588f326608803dac6204541ad1690600090a1565b6000806108ca836114fa565b90506001600160a01b03811661051f5760405162461bcd60e51b815260040161070a906125a1565b60006001600160a01b03821661095c5760405162461bcd60e51b815260206004820152602960248201527f4552433732313a2061646472657373207a65726f206973206e6f7420612076616044820152683634b21037bbb732b960b91b606482015260840161070a565b506001600160a01b031660009081526003602052604090205490565b610980611515565b61098a6000611574565b565b6000610997816111c9565b50600c55565b60006109b16009546001600160a01b031690565b905090565b60009182526007602090815260408084206001600160a01b0393909316845291905290205460ff1690565b6060600180546105349061250f565b601080546109fd9061250f565b80601f0160208091040260200160405190810160405280929190818152602001828054610a299061250f565b8015610a765780601f10610a4b57610100808354040283529160200191610a76565b820191906000526020600020905b815481529060010190602001808311610a5957829003601f168201915b505050505081565b610a866115c6565b6000610a91816111c9565b81600003610ab257604051632a6ce29960e11b815260040160405180910390fd5b600f546001600160a01b0316610adb576040516340f028e160e11b815260040160405180910390fd5b6000600e54600d54610aed919061255f565b905080600003610b105760405163d5c4417960e01b815260040160405180910390fd5b610b1a838261161f565b600b5490935060005b84811015610b6157600f54610b41906001600160a01b031683611637565b81610b4b81612588565b9250508080610b5990612588565b915050610b23565b5083600e6000828254610b7491906125d3565b9091555050600b8190556040805185815260208101849052600080516020612971833981519152910160405180910390a1505050610bb26001600655565b50565b6000610bc0816111c9565b601061063d8382612634565b81610bd6816111f8565b61063d8383611651565b6000600e54600d54610bf2919061255f565b600b54610c0090606461255f565b6109b1919061255f565b6000610c146115c6565b336000908152600a602052604090205460ff1615610c4557604051631bbdf5c560e31b815260040160405180910390fd5b6064600b5410610c685760405163d05cb60960e01b815260040160405180910390fd5b6001610c72610be0565b1015610c91576040516321bccf3f60e01b815260040160405180910390fd5b610c9a3361165c565b15610cb8576040516316eab3cb60e11b815260040160405180910390fd5b6040516001600160601b03193360601b166020820152600090603401604051602081830303815290604052805190602001209050610d2d84848080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525050600c54915084905061166b565b610d4a5760405163231e418360e01b815260040160405180910390fd5b336000908152600a60205260408120805460ff19166001179055600b805493508391610d7583612588565b9190505550610d843383611637565b5061051f6001600655565b836001600160a01b0381163314610da957610da9336111f8565b610db585858585611681565b5050505050565b610dc461099d565b6001600160a01b0316336001600160a01b031614610df557604051635fc483c560e01b815260040160405180910390fd5b600854600160a01b900460ff1615610e2057604051631551a48f60e11b815260040160405180910390fd5b600880546001600160a01b0319166001600160a01b0383161790556040517f9f513fe86dc42fdbac355fa4d9b1d5be7b5e6cd2df67e30db8003766568de47690610e6b9083906121bd565b60405180910390a150565b610e7e6115c6565b80600003610e9f57604051632a6ce29960e11b815260040160405180910390fd5b600f546001600160a01b0316610ec8576040516340f028e160e11b815260040160405180910390fd5b600f546001600160a01b03163314610ef357604051636bebaa5360e01b815260040160405180910390fd5b6000600e54600d54610f05919061255f565b905080600003610f285760405163d5c4417960e01b815260040160405180910390fd5b610f32828261161f565b600b5490925060005b83811015610f6d57610f4d3383611637565b81610f5781612588565b9250508080610f6590612588565b915050610f3b565b5082600e6000828254610f8091906125d3565b9091555050600b8190556040805184815260208101849052600080516020612971833981519152910160405180910390a15050610bb26001600655565b6000600e54600d546109b1919061255f565b6060610fda826116b3565b6110355760405162461bcd60e51b815260206004820152602660248201527f444543414c3a2055524920717565727920666f72206e6f6e6578697374656e74604482015265103a37b5b2b760d11b606482015260840161070a565b600061103f6116d0565b905060008151116110845760405162461bcd60e51b815260206004820152600f60248201526e18985cd9555492481b9bdd081cd95d608a1b604482015260640161070a565b8061108e846116df565b60405160200161109f9291906126f3565b604051602081830303815290604052915050919050565b60006110c1816111c9565b50600f80546001600160a01b0319166001600160a01b0392909216919091179055565b6110ed8261066d565b6110f6816111c9565b61063d8383611478565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b611136611515565b6001600160a01b03811661119b5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161070a565b610bb281611574565b60006001600160e01b03198216637965db0b60e01b148061051f575061051f82611771565b610bb281336117c1565b6111dc816116b3565b610bb25760405162461bcd60e51b815260040161070a906125a1565b6008546001600160a01b0316801580159061121d57506000816001600160a01b03163b115b1561071d57604051633185c44d60e21b81523060048201526001600160a01b03838116602483015282169063c617113490604401602060405180830381865afa15801561126e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112929190612722565b61071d5781604051633b79c77360e21b815260040161070a91906121bd565b60006112bc826108be565b9050806001600160a01b0316836001600160a01b0316036113295760405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656044820152603960f91b606482015260840161070a565b336001600160a01b038216148061134557506113458133611100565b6113b75760405162461bcd60e51b815260206004820152603d60248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f7420746f60448201527f6b656e206f776e6572206f7220617070726f76656420666f7220616c6c000000606482015260840161070a565b61063d838361181a565b6113cb3382611888565b6113e75760405162461bcd60e51b815260040161070a9061273f565b61063d8383836118e7565b6113fc82826109b6565b61071d5760008281526007602090815260408083206001600160a01b03851684529091529020805460ff191660011790556114343390565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b61148282826109b6565b1561071d5760008281526007602090815260408083206001600160a01b0385168085529252808320805460ff1916905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b61063d83838360405180602001604052806000815250610d8f565b6000908152600260205260409020546001600160a01b031690565b3361151e61099d565b6001600160a01b03161461098a5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161070a565b600980546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6002600654036116185760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015260640161070a565b6002600655565b600081831061162e5781611630565b825b9392505050565b61071d828260405180602001604052806000815250611a46565b61071d338383611a79565b6001600160a01b03163b151590565b6000826116788584611b43565b14949350505050565b61168b3383611888565b6116a75760405162461bcd60e51b815260040161070a9061273f565b61066784848484611b90565b6000806116bf836114fa565b6001600160a01b0316141592915050565b6060601080546105349061250f565b606060006116ec83611bc3565b60010190506000816001600160401b0381111561170b5761170b6122de565b6040519080825280601f01601f191660200182016040528015611735576020820181803683370190505b5090508181016020015b600019016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a850494508461173f57509392505050565b60006001600160e01b031982166380ac58cd60e01b14806117a257506001600160e01b03198216635b5e139f60e01b145b8061051f57506301ffc9a760e01b6001600160e01b031983161461051f565b6117cb82826109b6565b61071d576117d881611c99565b6117e3836020611cab565b6040516020016117f492919061278c565b60408051601f198184030181529082905262461bcd60e51b825261070a91600401612191565b600081815260046020526040902080546001600160a01b0319166001600160a01b038416908117909155819061184f826108be565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b600080611894836108be565b9050806001600160a01b0316846001600160a01b031614806118bb57506118bb8185611100565b806118df5750836001600160a01b03166118d484610602565b6001600160a01b0316145b949350505050565b826001600160a01b03166118fa826108be565b6001600160a01b0316146119205760405162461bcd60e51b815260040161070a906127fb565b6001600160a01b0382166119825760405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646044820152637265737360e01b606482015260840161070a565b61198f8383836001611e46565b826001600160a01b03166119a2826108be565b6001600160a01b0316146119c85760405162461bcd60e51b815260040161070a906127fb565b600081815260046020908152604080832080546001600160a01b03199081169091556001600160a01b03878116808652600385528386208054600019019055908716808652838620805460010190558686526002909452828520805490921684179091559051849360008051602061295183398151915291a4505050565b611a508383611ece565b611a5d6000848484611fd7565b61063d5760405162461bcd60e51b815260040161070a90612840565b816001600160a01b0316836001600160a01b031603611ad65760405162461bcd60e51b815260206004820152601960248201527822a9219b99189d1030b8383937bb32903a379031b0b63632b960391b604482015260640161070a565b6001600160a01b03838116600081815260056020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b600081815b8451811015611b8857611b7482868381518110611b6757611b67612572565b60200260200101516120df565b915080611b8081612588565b915050611b48565b509392505050565b611b9b8484846118e7565b611ba784848484611fd7565b6106675760405162461bcd60e51b815260040161070a90612840565b60008072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b8310611c025772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6904ee2d6d415b85acef8160201b8310611c2c576904ee2d6d415b85acef8160201b830492506020015b662386f26fc100008310611c4a57662386f26fc10000830492506010015b6305f5e1008310611c62576305f5e100830492506008015b6127108310611c7657612710830492506004015b60648310611c88576064830492506002015b600a831061051f5760010192915050565b606061051f6001600160a01b03831660145b60606000611cba836002612892565b611cc59060026125d3565b6001600160401b03811115611cdc57611cdc6122de565b6040519080825280601f01601f191660200182016040528015611d06576020820181803683370190505b509050600360fc1b81600081518110611d2157611d21612572565b60200101906001600160f81b031916908160001a905350600f60fb1b81600181518110611d5057611d50612572565b60200101906001600160f81b031916908160001a9053506000611d74846002612892565b611d7f9060016125d3565b90505b6001811115611df7576f181899199a1a9b1b9c1cb0b131b232b360811b85600f1660108110611db357611db3612572565b1a60f81b828281518110611dc957611dc9612572565b60200101906001600160f81b031916908160001a90535060049490941c93611df0816128a9565b9050611d82565b5083156116305760405162461bcd60e51b815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e74604482015260640161070a565b6001811115610667576001600160a01b03841615611e8c576001600160a01b03841660009081526003602052604081208054839290611e8690849061255f565b90915550505b6001600160a01b03831615610667576001600160a01b03831660009081526003602052604081208054839290611ec39084906125d3565b909155505050505050565b6001600160a01b038216611f245760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f2061646472657373604482015260640161070a565b611f2d816116b3565b15611f4a5760405162461bcd60e51b815260040161070a906128c0565b611f58600083836001611e46565b611f61816116b3565b15611f7e5760405162461bcd60e51b815260040161070a906128c0565b6001600160a01b038216600081815260036020908152604080832080546001019055848352600290915280822080546001600160a01b031916841790555183929190600080516020612951833981519152908290a45050565b6000611feb846001600160a01b031661165c565b156120d457604051630a85bd0160e11b81526001600160a01b0385169063150b7a02906120229033908990889088906004016128f6565b6020604051808303816000875af192505050801561205d575060408051601f3d908101601f1916820190925261205a91810190612933565b60015b6120ba573d80801561208b576040519150601f19603f3d011682016040523d82523d6000602084013e612090565b606091505b5080516000036120b25760405162461bcd60e51b815260040161070a90612840565b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490506118df565b506001949350505050565b60008183106120fb576000828152602084905260409020611630565b6000838152602083905260409020611630565b6001600160e01b031981168114610bb257600080fd5b60006020828403121561213657600080fd5b81356116308161210e565b60005b8381101561215c578181015183820152602001612144565b50506000910152565b6000815180845261217d816020860160208601612141565b601f01601f19169290920160200192915050565b6020815260006116306020830184612165565b6000602082840312156121b657600080fd5b5035919050565b6001600160a01b0391909116815260200190565b80356001600160a01b03811681146121e857600080fd5b919050565b6000806040838503121561220057600080fd5b612209836121d1565b946020939093013593505050565b60006020828403121561222957600080fd5b611630826121d1565b60008060006060848603121561224757600080fd5b612250846121d1565b925061225e602085016121d1565b9150604084013590509250925092565b6000806040838503121561228157600080fd5b82359150612291602084016121d1565b90509250929050565b6020808252825182820181905260009190848201906040850190845b818110156122d2578351835292840192918401916001016122b6565b50909695505050505050565b634e487b7160e01b600052604160045260246000fd5b60006001600160401b038084111561230e5761230e6122de565b604051601f8501601f19908116603f01168101908282118183101715612336576123366122de565b8160405280935085815286868601111561234f57600080fd5b858560208301376000602087830101525050509392505050565b60006020828403121561237b57600080fd5b81356001600160401b0381111561239157600080fd5b8201601f810184136123a257600080fd5b6118df848235602084016122f4565b8015158114610bb257600080fd5b600080604083850312156123d257600080fd5b6123db836121d1565b915060208301356123eb816123b1565b809150509250929050565b6000806020838503121561240957600080fd5b82356001600160401b038082111561242057600080fd5b818501915085601f83011261243457600080fd5b81358181111561244357600080fd5b8660208260051b850101111561245857600080fd5b60209290920196919550909350505050565b6000806000806080858703121561248057600080fd5b612489856121d1565b9350612497602086016121d1565b92506040850135915060608501356001600160401b038111156124b957600080fd5b8501601f810187136124ca57600080fd5b6124d9878235602084016122f4565b91505092959194509250565b600080604083850312156124f857600080fd5b612501836121d1565b9150612291602084016121d1565b600181811c9082168061252357607f821691505b60208210810361254357634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b8181038181111561051f5761051f612549565b634e487b7160e01b600052603260045260246000fd5b60006001820161259a5761259a612549565b5060010190565b602080825260189082015277115490cdcc8c4e881a5b9d985b1a59081d1bdad95b88125160421b604082015260600190565b8082018082111561051f5761051f612549565b601f82111561063d57600081815260208120601f850160051c8101602086101561260d5750805b601f850160051c820191505b8181101561262c57828155600101612619565b505050505050565b81516001600160401b0381111561264d5761264d6122de565b6126618161265b845461250f565b846125e6565b602080601f831160018114612696576000841561267e5750858301515b600019600386901b1c1916600185901b17855561262c565b600085815260208120601f198616915b828110156126c5578886015182559484019460019091019084016126a6565b50858210156126e35787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b60008351612705818460208801612141565b835190830190612719818360208801612141565b01949350505050565b60006020828403121561273457600080fd5b8151611630816123b1565b6020808252602d908201527f4552433732313a2063616c6c6572206973206e6f7420746f6b656e206f776e6560408201526c1c881bdc88185c1c1c9bdd9959609a1b606082015260800190565b76020b1b1b2b9b9a1b7b73a3937b61d1030b1b1b7bab73a1604d1b8152600083516127be816017850160208801612141565b7001034b99036b4b9b9b4b733903937b6329607d1b60179184019182015283516127ef816028840160208801612141565b01602801949350505050565b60208082526025908201527f4552433732313a207472616e736665722066726f6d20696e636f72726563742060408201526437bbb732b960d91b606082015260800190565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b808202811582820484141761051f5761051f612549565b6000816128b8576128b8612549565b506000190190565b6020808252601c908201527b115490cdcc8c4e881d1bdad95b88185b1c9958591e481b5a5b9d195960221b604082015260600190565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061292990830184612165565b9695505050505050565b60006020828403121561294557600080fd5b81516116308161210e56feddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef0b3544e12b031cb05a003a4e0cb691f6809a97e68d9f3d5d00387b0ee985acbaa2646970667358221220f78074e0896890700ed4d1922fa7fd7a46a453aa209cf931ae4fc666d879d52764736f6c63430008110033000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000005000000000000000000000000dd9e62bc2968ec2b00ebb76d7b384056c4561a2e000000000000000000000000000000000000000000000000000000000000003268747470733a2f2f636c69656e742d6170692e646563612e73797374656d732f646563616c2f6d657461646174612f32322f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a57ec3a618b6969a6b1fec2ef4bf54b2afc5ca30

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000005000000000000000000000000dd9e62bc2968ec2b00ebb76d7b384056c4561a2e000000000000000000000000000000000000000000000000000000000000003268747470733a2f2f636c69656e742d6170692e646563612e73797374656d732f646563616c2f6d657461646174612f32322f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a57ec3a618b6969a6b1fec2ef4bf54b2afc5ca30

-----Decoded View---------------
Arg [0] : _baseUri (string): https://client-api.deca.systems/decal/metadata/22/
Arg [1] : _admins (address[]): 0xA57ec3a618b6969a6B1fEc2eF4BF54B2AfC5ca30
Arg [2] : _artistMaxSupply (uint256): 5
Arg [3] : _artist (address): 0xdd9e62bC2968ec2b00eBB76d7B384056c4561A2e

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [3] : 000000000000000000000000dd9e62bc2968ec2b00ebb76d7b384056c4561a2e
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000032
Arg [5] : 68747470733a2f2f636c69656e742d6170692e646563612e73797374656d732f
Arg [6] : 646563616c2f6d657461646174612f32322f0000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [8] : 000000000000000000000000a57ec3a618b6969a6b1fec2ef4bf54b2afc5ca30

Deployed Bytecode Sourcemap

89232:6261:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;94075:180;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;94075:180:0;;;;;;;;47887:94;;;:::i;:::-;;;;;;;:::i;90397:262::-;;;;;;:::i;:::-;;:::i;:::-;;49324:171;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;94560:166::-;;;;;;:::i;:::-;;:::i;89547:30::-;;;;;;;;;2324:25:1;;;2312:2;2297:18;89547:30:0;2178:177:1;89502:38:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;94732:177;;;;;;:::i;:::-;;:::i;23683:135::-;;;;;;:::i;:::-;;:::i;89631:25::-;;;;;;24102:156;;;;;;:::i;:::-;;:::i;89584:40::-;;89621:3;89584:40;;25206:229;;;;;;:::i;:::-;;:::i;94915:185::-;;;;;;:::i;:::-;;:::i;89734:21::-;;;;;-1:-1:-1;;;;;89734:21:0;;;93578:433;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;87853:481::-;;;:::i;47609:219::-;;;;;;:::i;:::-;;:::i;47348:207::-;;;;;;:::i;:::-;;:::i;29148:97::-;;;:::i;89663:30::-;;;;;;90665:129;;;;;;:::i;:::-;;:::i;89700:27::-;;;;;;95327:163;;;:::i;22307:156::-;;;;;;:::i;:::-;;:::i;48042:98::-;;;:::i;89762:21::-;;;:::i;91578:678::-;;;;;;:::i;:::-;;:::i;90800:129::-;;;;;;:::i;:::-;;:::i;21442:49::-;;21487:4;21442:49;;94369:185;;;;;;:::i;:::-;;:::i;92954:142::-;;;:::i;82106:53::-;;;;;-1:-1:-1;;;;;82106:53:0;;;90935:637;;;;;;:::i;:::-;;:::i;95106:215::-;;;;;;:::i;:::-;;:::i;87280:455::-;;;;;;:::i;:::-;;:::i;92262:686::-;;;;;;:::i;:::-;;:::i;93102:115::-;;;:::i;93223:349::-;;;;;;:::i;:::-;;:::i;90288:103::-;;;;;;:::i;:::-;;:::i;24527:158::-;;;;;;:::i;:::-;;:::i;49786:173::-;;;;;;:::i;:::-;;:::i;86498:43::-;;;;;-1:-1:-1;;;86498:43:0;;;;;;29390:191;;;;;;:::i;:::-;;:::i;94075:180::-;94193:4;94213:36;94237:11;94213:23;:36::i;:::-;94206:43;94075:180;-1:-1:-1;;94075:180:0:o;47887:94::-;47941:13;47970:5;47963:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47887:94;:::o;90397:262::-;21487:4;21907:16;21487:4;21907:10;:16::i;:::-;90560:11:::1;::::0;90547:24:::1;::::0;89621:3:::1;90547:24;:::i;:::-;90530:12;::::0;90511:31:::1;::::0;:16;:31:::1;:::i;:::-;90510:62;90506:106;;;90588:24;;-1:-1:-1::0;;;90588:24:0::1;;;;;;;;;;;90506:106;-1:-1:-1::0;90619:15:0::1;:34:::0;90397:262::o;49324:171::-;49410:7;49426:23;49441:7;49426:14;:23::i;:::-;-1:-1:-1;49465:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;49465:24:0;;49324:171::o;94560:166::-;94671:8;83815:30;83836:8;83815:20;:30::i;:::-;94688:32:::1;94702:8;94712:7;94688:13;:32::i;:::-;94560:166:::0;;;:::o;94732:177::-;94853:4;-1:-1:-1;;;;;83568:18:0;;83576:10;83568:18;83564:73;;83597:32;83618:10;83597:20;:32::i;:::-;94866:37:::1;94885:4;94891:2;94895:7;94866:18;:37::i;:::-;94732:177:::0;;;;:::o;23683:135::-;23767:7;23790:12;;;:6;:12;;;;;:22;;;;23683:135::o;24102:156::-;24200:18;24213:4;24200:12;:18::i;:::-;21907:16;21918:4;21907:10;:16::i;:::-;24227:25:::1;24238:4;24244:7;24227:10;:25::i;25206:229::-:0;-1:-1:-1;;;;;25306:23:0;;3816:10;25306:23;25290:104;;;;-1:-1:-1;;;25290:104:0;;8464:2:1;25290:104:0;;;8446:21:1;8503:2;8483:18;;;8476:30;8542:34;8522:18;;;8515:62;-1:-1:-1;;;8593:18:1;;;8586:45;8648:19;;25290:104:0;;;;;;;;;25403:26;25415:4;25421:7;25403:11;:26::i;:::-;25206:229;;:::o;94915:185::-;95040:4;-1:-1:-1;;;;;83568:18:0;;83576:10;83568:18;83564:73;;83597:32;83618:10;83597:20;:32::i;:::-;95053:41:::1;95076:4;95082:2;95086:7;95053:22;:41::i;93578:433::-:0;93653:16;93678:18;93699:17;93709:6;93699:9;:17::i;:::-;93678:38;;93723:25;93765:10;-1:-1:-1;;;;;93751:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;93751:25:0;;93723:53;;93783:12;93811:9;93806:178;93830:11;;93826:1;:15;93806:178;;;93875:6;-1:-1:-1;;;;;93861:20:0;:10;93869:1;93861:7;:10::i;:::-;-1:-1:-1;;;;;93861:20:0;;93857:82;;93911:1;93894:8;93903:4;93894:14;;;;;;;;:::i;:::-;;;;;;;;;;:18;93923:6;;;;:::i;:::-;;;;93857:82;93947:29;;;93971:5;93947:29;93843:3;;;;:::i;:::-;;;;93806:178;;;-1:-1:-1;93997:8:0;;93578:433;-1:-1:-1;;;;93578:433:0:o;87853:481::-;87925:7;:5;:7::i;:::-;-1:-1:-1;;;;;87911:21:0;:10;-1:-1:-1;;;;;87911:21:0;;87907:62;;87950:11;;-1:-1:-1;;;87950:11:0;;;;;;;;;;;87907:62;88046:31;;-1:-1:-1;;;88046:31:0;;;;88042:85;;;88095:24;;-1:-1:-1;;;88095:24:0;;;;;;;;;;;88042:85;88180:22;:60;;-1:-1:-1;;;;;;88247:38:0;-1:-1:-1;;;88247:38:0;;;88297:31;;;;88237:1;;88297:31;87853:481::o;47609:219::-;47691:7;47707:13;47723:17;47732:7;47723:8;:17::i;:::-;47707:33;-1:-1:-1;;;;;;47755:19:0;;47747:56;;;;-1:-1:-1;;;47747:56:0;;;;;;;:::i;47348:207::-;47430:7;-1:-1:-1;;;;;47454:19:0;;47446:73;;;;-1:-1:-1;;;47446:73:0;;9505:2:1;47446:73:0;;;9487:21:1;9544:2;9524:18;;;9517:30;9583:34;9563:18;;;9556:62;-1:-1:-1;;;9634:18:1;;;9627:39;9683:19;;47446:73:0;9303:405:1;47446:73:0;-1:-1:-1;;;;;;47533:16:0;;;;;:9;:16;;;;;;;47348:207::o;29148:97::-;28436:13;:11;:13::i;:::-;29209:30:::1;29236:1;29209:18;:30::i;:::-;29148:97::o:0;90665:129::-;21487:4;21907:16;21487:4;21907:10;:16::i;:::-;-1:-1:-1;90764:10:0::1;:24:::0;90665:129::o;95327:163::-;95443:7;95469:15;28605:6;;-1:-1:-1;;;;;28605:6:0;;28536:81;95469:15;95462:22;;95327:163;:::o;22307:156::-;22408:4;22428:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;22428:29:0;;;;;;;;;;;;;;;22307:156::o;48042:98::-;48098:13;48127:7;48120:14;;;;;:::i;89762:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;91578:678::-;64163:21;:19;:21::i;:::-;21487:4:::1;21907:16;21487:4:::0;21907:10:::1;:16::i;:::-;91703:15:::2;91722:1;91703:20:::0;91699:49:::2;;91732:16;;-1:-1:-1::0;;;91732:16:0::2;;;;;;;;;;;91699:49;91759:6;::::0;-1:-1:-1;;;;;91759:6:0::2;91755:43;;91788:10;;-1:-1:-1::0;;;91788:10:0::2;;;;;;;;;;;91755:43;91805:17;91843:12;;91825:15;;:30;;;;:::i;:::-;91805:50;;91866:9;91879:1;91866:14:::0;91862:51:::2;;91889:24;;-1:-1:-1::0;;;91889:24:0::2;;;;;;;;;;;91862:51;91946:36;91955:15;91972:9;91946:8;:36::i;:::-;92008:11;::::0;91920:63;;-1:-1:-1;91990:15:0::2;92026:107;92050:15;92046:1;:19;92026:107;;;92091:6;::::0;92081:26:::2;::::0;-1:-1:-1;;;;;92091:6:0::2;92099:7:::0;92081:9:::2;:26::i;:::-;92116:9:::0;::::2;::::0;::::2;:::i;:::-;;;;92067:3;;;;;:::i;:::-;;;;92026:107;;;;92155:15;92139:12;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;92177:11:0::2;:21:::0;;;92210:40:::2;::::0;;10017:25:1;;;10073:2;10058:18;;10051:34;;;-1:-1:-1;;;;;;;;;;;92210:40:0;9990:18:1;92210:40:0::2;;;;;;;91692:564;;64191:1:::1;64199:20:::0;63633:1;64683:7;:22;64512:199;64199:20;91578:678;:::o;90800:129::-;21487:4;21907:16;21487:4;21907:10;:16::i;:::-;90902:7:::1;:21;90912:11:::0;90902:7;:21:::1;:::i;94369:185::-:0;94488:8;83815:30;83836:8;83815:20;:30::i;:::-;94505:43:::1;94529:8;94539;94505:23;:43::i;92954:142::-:0;93008:7;93077:12;;93059:15;;:30;;;;:::i;:::-;93044:11;;93031:24;;89621:3;93031:24;:::i;:::-;:59;;;;:::i;90935:637::-;91023:15;64163:21;:19;:21::i;:::-;91058:10:::1;91051:18;::::0;;;:6:::1;:18;::::0;;;;;::::1;;91047:46;;;91078:15;;-1:-1:-1::0;;;91078:15:0::1;;;;;;;;;;;91047:46;89621:3;91104:11;;:25;91100:56;;91138:18;;-1:-1:-1::0;;;91138:18:0::1;;;;;;;;;;;91100:56;91193:1;91167:23;:21;:23::i;:::-;:27;91163:64;;;91203:24;;-1:-1:-1::0;;;91203:24:0::1;;;;;;;;;;;91163:64;91238:23;:10;:21;:23::i;:::-;91234:60;;;91270:24;;-1:-1:-1::0;;;91270:24:0::1;;;;;;;;;;;91234:60;91326:28;::::0;-1:-1:-1;;;;;;91343:10:0::1;12474:2:1::0;12445:15;12441:45;91326:28:0::1;::::0;::::1;12429:58:1::0;91301:12:0::1;::::0;12503::1;;91326:28:0::1;;;;;;;;;;;;91316:39;;;;;;91301:54;;91367:50;91386:12;;91367:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;91400:10:0::1;::::0;;-1:-1:-1;91412:4:0;;-1:-1:-1;91367:18:0::1;:50::i;:::-;91362:87;;91433:16;;-1:-1:-1::0;;;91433:16:0::1;;;;;;;;;;;91362:87;91463:10;91456:18;::::0;;;:6:::1;:18;::::0;;;;:25;;-1:-1:-1;;91456:25:0::1;91477:4;91456:25;::::0;;91498:11:::1;::::0;;;-1:-1:-1;91498:11:0;;91516:13:::1;91498:11:::0;91516:13:::1;:::i;:::-;;;;;;91536:30;91546:10;91558:7;91536:9;:30::i;:::-;91040:532;64199:20:::0;63633:1;64683:7;:22;64512:199;95106:215;95255:4;-1:-1:-1;;;;;83568:18:0;;83576:10;83568:18;83564:73;;83597:32;83618:10;83597:20;:32::i;:::-;95268:47:::1;95291:4;95297:2;95301:7;95310:4;95268:22;:47::i;:::-;95106:215:::0;;;;;:::o;87280:455::-;87397:7;:5;:7::i;:::-;-1:-1:-1;;;;;87383:21:0;:10;-1:-1:-1;;;;;87383:21:0;;87379:62;;87422:11;;-1:-1:-1;;;87422:11:0;;;;;;;;;;;87379:62;87518:31;;-1:-1:-1;;;87518:31:0;;;;87514:85;;;87567:24;;-1:-1:-1;;;87567:24:0;;;;;;;;;;;87514:85;87607:22;:61;;-1:-1:-1;;;;;;87607:61:0;-1:-1:-1;;;;;87607:61:0;;;;;87680:49;;;;;;87607:61;;87680:49;:::i;:::-;;;;;;;;87280:455;:::o;92262:686::-;64163:21;:19;:21::i;:::-;92340:15:::1;92359:1;92340:20:::0;92336:49:::1;;92369:16;;-1:-1:-1::0;;;92369:16:0::1;;;;;;;;;;;92336:49;92396:6;::::0;-1:-1:-1;;;;;92396:6:0::1;92392:43;;92425:10;;-1:-1:-1::0;;;92425:10:0::1;;;;;;;;;;;92392:43;92460:6;::::0;-1:-1:-1;;;;;92460:6:0::1;92446:10;:20;92442:44;;92475:11;;-1:-1:-1::0;;;92475:11:0::1;;;;;;;;;;;92442:44;92493:17;92531:12;;92513:15;;:30;;;;:::i;:::-;92493:50;;92554:9;92567:1;92554:14:::0;92550:51:::1;;92577:24;;-1:-1:-1::0;;;92577:24:0::1;;;;;;;;;;;92550:51;92634:36;92643:15;92660:9;92634:8;:36::i;:::-;92696:11;::::0;92608:63;;-1:-1:-1;92678:15:0::1;92714:111;92738:15;92734:1;:19;92714:111;;;92769:30;92779:10;92791:7;92769:9;:30::i;:::-;92808:9:::0;::::1;::::0;::::1;:::i;:::-;;;;92755:3;;;;;:::i;:::-;;;;92714:111;;;;92847:15;92831:12;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;92869:11:0::1;:21:::0;;;92902:40:::1;::::0;;10017:25:1;;;10073:2;10058:18;;10051:34;;;-1:-1:-1;;;;;;;;;;;92902:40:0;9990:18:1;92902:40:0::1;;;;;;;92329:619;;64199:20:::0;63633:1;64683:7;:22;64512:199;93102:115;93158:7;93199:12;;93181:15;;:30;;;;:::i;93223:349::-;93307:13;93337:17;93345:8;93337:7;:17::i;:::-;93329:68;;;;-1:-1:-1;;;93329:68:0;;12728:2:1;93329:68:0;;;12710:21:1;12767:2;12747:18;;;12740:30;12806:34;12786:18;;;12779:62;-1:-1:-1;;;12857:18:1;;;12850:36;12903:19;;93329:68:0;12526:402:1;93329:68:0;93404:21;93428:10;:8;:10::i;:::-;93404:34;;93477:1;93459:7;93453:21;:25;93445:53;;;;-1:-1:-1;;;93445:53:0;;13135:2:1;93445:53:0;;;13117:21:1;13174:2;13154:18;;;13147:30;-1:-1:-1;;;13193:18:1;;;13186:45;13248:18;;93445:53:0;12933:339:1;93445:53:0;93536:7;93545:19;:8;:17;:19::i;:::-;93519:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;93505:61;;;93223:349;;;:::o;90288:103::-;21487:4;21907:16;21487:4;21907:10;:16::i;:::-;-1:-1:-1;90369:6:0::1;:16:::0;;-1:-1:-1;;;;;;90369:16:0::1;-1:-1:-1::0;;;;;90369:16:0;;;::::1;::::0;;;::::1;::::0;;90288:103::o;24527:158::-;24626:18;24639:4;24626:12;:18::i;:::-;21907:16;21918:4;21907:10;:16::i;:::-;24653:26:::1;24665:4;24671:7;24653:11;:26::i;49786:173::-:0;-1:-1:-1;;;;;49918:25:0;;;49898:4;49918:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;49786:173::o;29390:191::-;28436:13;:11;:13::i;:::-;-1:-1:-1;;;;;29475:22:0;::::1;29467:73;;;::::0;-1:-1:-1;;;29467:73:0;;13980:2:1;29467:73:0::1;::::0;::::1;13962:21:1::0;14019:2;13999:18;;;13992:30;14058:34;14038:18;;;14031:62;-1:-1:-1;;;14109:18:1;;;14102:36;14155:19;;29467:73:0::1;13778:402:1::0;29467:73:0::1;29547:28;29566:8;29547:18;:28::i;22001:222::-:0;22096:4;-1:-1:-1;;;;;;22123:47:0;;-1:-1:-1;;;22123:47:0;;:94;;;22181:36;22205:11;22181:23;:36::i;22749:99::-;22812:30;22823:4;3816:10;22812;:30::i;58585:129::-;58663:16;58671:7;58663;:16::i;:::-;58655:53;;;;-1:-1:-1;;;58655:53:0;;;;;;;:::i;84620:668::-;84732:22;;-1:-1:-1;;;;;84732:22:0;84867:31;;;;;:68;;;84934:1;84910:8;-1:-1:-1;;;;;84902:29:0;;:33;84867:68;84863:420;;;85167:51;;-1:-1:-1;;;85167:51:0;;85202:4;85167:51;;;14397:34:1;-1:-1:-1;;;;;14467:15:1;;;14447:18;;;14440:43;85167:26:0;;;;;14332:18:1;;85167:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;85162:114;;85257:8;85238:28;;-1:-1:-1;;;85238:28:0;;;;;;;;:::i;48884:382::-;48961:13;48977:23;48992:7;48977:14;:23::i;:::-;48961:39;;49021:5;-1:-1:-1;;;;;49015:11:0;:2;-1:-1:-1;;;;;49015:11:0;;49007:57;;;;-1:-1:-1;;;49007:57:0;;14946:2:1;49007:57:0;;;14928:21:1;14985:2;14965:18;;;14958:30;15024:34;15004:18;;;14997:62;-1:-1:-1;;;15075:18:1;;;15068:31;15116:19;;49007:57:0;14744:397:1;49007:57:0;3816:10;-1:-1:-1;;;;;49089:21:0;;;;:62;;-1:-1:-1;49114:37:0;49131:5;3816:10;49786:173;:::i;49114:37::-;49073:157;;;;-1:-1:-1;;;49073:157:0;;15348:2:1;49073:157:0;;;15330:21:1;15387:2;15367:18;;;15360:30;15426:34;15406:18;;;15399:62;15497:31;15477:18;;;15470:59;15546:19;;49073:157:0;15146:425:1;49073:157:0;49239:21;49248:2;49252:7;49239:8;:21::i;50018:328::-;50199:41;3816:10;50232:7;50199:18;:41::i;:::-;50183:120;;;;-1:-1:-1;;;50183:120:0;;;;;;;:::i;:::-;50312:28;50322:4;50328:2;50332:7;50312:9;:28::i;26724:216::-;26804:22;26812:4;26818:7;26804;:22::i;:::-;26799:136;;26837:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;26837:29:0;;;;;;;;;:36;;-1:-1:-1;;26837:36:0;26869:4;26837:36;;;26914:12;3816:10;;3740:92;26914:12;-1:-1:-1;;;;;26887:40:0;26905:7;-1:-1:-1;;;;;26887:40:0;26899:4;26887:40;;;;;;;;;;26724:216;;:::o;27104:217::-;27184:22;27192:4;27198:7;27184;:22::i;:::-;27180:136;;;27249:5;27217:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;27217:29:0;;;;;;;;;;:37;;-1:-1:-1;;27217:37:0;;;27268:40;3816:10;;27217:12;;27268:40;;27249:5;27268:40;27104:217;;:::o;50409:165::-;50529:39;50546:4;50552:2;50556:7;50529:39;;;;;;;;;;;;:16;:39::i;52207:111::-;52273:7;52296:16;;;:7;:16;;;;;;-1:-1:-1;;;;;52296:16:0;;52207:111::o;28687:126::-;3816:10;28747:7;:5;:7::i;:::-;-1:-1:-1;;;;;28747:23:0;;28739:68;;;;-1:-1:-1;;;28739:68:0;;16192:2:1;28739:68:0;;;16174:21:1;;;16211:18;;;16204:30;16270:34;16250:18;;;16243:62;16322:18;;28739:68:0;15990:356:1;29731:177:0;29820:6;;;-1:-1:-1;;;;;29833:17:0;;;-1:-1:-1;;;;;;29833:17:0;;;;;;;29862:40;;29820:6;;;29833:17;29820:6;;29862:40;;29801:16;;29862:40;29794:114;29731:177;:::o;64231:275::-;63675:1;64357:7;;:19;64349:63;;;;-1:-1:-1;;;64349:63:0;;16553:2:1;64349:63:0;;;16535:21:1;16592:2;16572:18;;;16565:30;16631:33;16611:18;;;16604:61;16682:18;;64349:63:0;16351:355:1;64349:63:0;63675:1;64482:7;:18;64231:275::o;6474:100::-;6532:7;6559:1;6555;:5;:13;;6567:1;6555:13;;;6563:1;6555:13;6548:20;6474:100;-1:-1:-1;;;6474:100:0:o;53489:104::-;53561:26;53571:2;53575:7;53561:26;;;;;;;;;;;;:9;:26::i;49559:164::-;49665:52;3816:10;49698:8;49708;49665:18;:52::i;37795:308::-;-1:-1:-1;;;;;38074:19:0;;:23;;;37795:308::o;65930:170::-;66041:4;66090;66061:25;66074:5;66081:4;66061:12;:25::i;:::-;:33;;65930:170;-1:-1:-1;;;;65930:170:0:o;50637:315::-;50797:41;3816:10;50830:7;50797:18;:41::i;:::-;50781:120;;;;-1:-1:-1;;;50781:120:0;;;;;;;:::i;:::-;50908:38;50922:4;50928:2;50932:7;50941:4;50908:13;:38::i;52613:122::-;52678:4;;52698:17;52707:7;52698:8;:17::i;:::-;-1:-1:-1;;;;;52698:31:0;;;;52613:122;-1:-1:-1;;52613:122:0:o;94261:102::-;94321:13;94350:7;94343:14;;;;;:::i;17793:586::-;17849:13;17890:14;17907:17;17918:5;17907:10;:17::i;:::-;17927:1;17907:21;17890:38;;17937:20;17971:6;-1:-1:-1;;;;;17960:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17960:18:0;-1:-1:-1;17937:41:0;-1:-1:-1;18076:28:0;;;18092:2;18076:28;18121:224;-1:-1:-1;;18145:5:0;-1:-1:-1;;;18256:2:0;18245:14;;18240:30;18145:5;18227:44;18301:2;18292:11;;;-1:-1:-1;18314:21:0;18121:224;18314:21;-1:-1:-1;18360:6:0;17793:586;-1:-1:-1;;;17793:586:0:o;47001:291::-;47113:4;-1:-1:-1;;;;;;47140:40:0;;-1:-1:-1;;;47140:40:0;;:99;;-1:-1:-1;;;;;;;47191:48:0;;-1:-1:-1;;;47191:48:0;47140:99;:146;;;-1:-1:-1;;;;;;;;;;5817:40:0;;;47250:36;5702:161;23122:386;23207:22;23215:4;23221:7;23207;:22::i;:::-;23202:301;;23347:28;23367:7;23347:19;:28::i;:::-;23424:38;23452:4;23459:2;23424:19;:38::i;:::-;23276:199;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;23276:199:0;;;;;;;;;;-1:-1:-1;;;23240:255:0;;;;;;;:::i;57922:164::-;57993:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;57993:29:0;-1:-1:-1;;;;;57993:29:0;;;;;;;;:24;;58043:23;57993:24;58043:14;:23::i;:::-;-1:-1:-1;;;;;58034:46:0;;;;;;;;;;;57922:164;;:::o;52886:283::-;52994:4;53007:13;53023:23;53038:7;53023:14;:23::i;:::-;53007:39;;53072:5;-1:-1:-1;;;;;53061:16:0;:7;-1:-1:-1;;;;;53061:16:0;;:59;;;;53088:32;53105:5;53112:7;53088:16;:32::i;:::-;53061:101;;;;53155:7;-1:-1:-1;;;;;53131:31:0;:20;53143:7;53131:11;:20::i;:::-;-1:-1:-1;;;;;53131:31:0;;53061:101;53053:110;52886:283;-1:-1:-1;;;;52886:283:0:o;56616:1199::-;56765:4;-1:-1:-1;;;;;56738:31:0;:23;56753:7;56738:14;:23::i;:::-;-1:-1:-1;;;;;56738:31:0;;56722:102;;;;-1:-1:-1;;;56722:102:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;56839:16:0;;56831:65;;;;-1:-1:-1;;;56831:65:0;;18268:2:1;56831:65:0;;;18250:21:1;18307:2;18287:18;;;18280:30;18346:34;18326:18;;;18319:62;-1:-1:-1;;;18397:18:1;;;18390:34;18441:19;;56831:65:0;18066:400:1;56831:65:0;56905:42;56926:4;56932:2;56936:7;56945:1;56905:20;:42::i;:::-;57077:4;-1:-1:-1;;;;;57050:31:0;:23;57065:7;57050:14;:23::i;:::-;-1:-1:-1;;;;;57050:31:0;;57034:102;;;;-1:-1:-1;;;57034:102:0;;;;;;;:::i;:::-;57200:24;;;;:15;:24;;;;;;;;57193:31;;-1:-1:-1;;;;;;57193:31:0;;;;;;-1:-1:-1;;;;;57636:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;57636:20:0;;;57665:13;;;;;;;;;:18;;57193:31;57665:18;;;57697:16;;;:7;:16;;;;;;:21;;;;;;;;;;57732:27;;57216:7;;-1:-1:-1;;;;;;;;;;;57732:27:0;;94560:166;;;:::o;53810:279::-;53921:18;53927:2;53931:7;53921:5;:18::i;:::-;53962:53;53993:1;53997:2;54001:7;54010:4;53962:22;:53::i;:::-;53946:137;;;;-1:-1:-1;;;53946:137:0;;;;;;;:::i;58217:287::-;58354:8;-1:-1:-1;;;;;58345:17:0;:5;-1:-1:-1;;;;;58345:17:0;;58337:55;;;;-1:-1:-1;;;58337:55:0;;19092:2:1;58337:55:0;;;19074:21:1;19131:2;19111:18;;;19104:30;-1:-1:-1;;;19150:18:1;;;19143:55;19215:18;;58337:55:0;18890:349:1;58337:55:0;-1:-1:-1;;;;;58399:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;58399:46:0;;;;;;;;;;58457:41;;540::1;;;58457::0;;513:18:1;58457:41:0;;;;;;;58217:287;;;:::o;66727:::-;66825:7;66864:4;66825:7;66875:108;66899:5;:12;66895:1;:16;66875:108;;;66942:33;66952:12;66966:5;66972:1;66966:8;;;;;;;;:::i;:::-;;;;;;;66942:9;:33::i;:::-;66927:48;-1:-1:-1;66913:3:0;;;;:::i;:::-;;;;66875:108;;;-1:-1:-1;66996:12:0;66727:287;-1:-1:-1;;;66727:287:0:o;51795:306::-;51929:28;51939:4;51945:2;51949:7;51929:9;:28::i;:::-;51980:47;52003:4;52009:2;52013:7;52022:4;51980:22;:47::i;:::-;51964:131;;;;-1:-1:-1;;;51964:131:0;;;;;;;:::i;15036:742::-;15089:7;;-1:-1:-1;;;15153:17:0;;15149:84;;-1:-1:-1;;;15183:17:0;;;-1:-1:-1;15221:2:0;15211:12;15149:84;-1:-1:-1;;;15245:5:0;:17;15241:84;;-1:-1:-1;;;15275:17:0;;;-1:-1:-1;15313:2:0;15303:12;15241:84;15346:8;15337:5;:17;15333:84;;15376:8;15367:17;;;-1:-1:-1;15405:2:0;15395:12;15333:84;15438:7;15429:5;:16;15425:81;;15467:7;15458:16;;;-1:-1:-1;15495:1:0;15485:11;15425:81;15527:7;15518:5;:16;15514:81;;15556:7;15547:16;;;-1:-1:-1;15584:1:0;15574:11;15514:81;15616:7;15607:5;:16;15603:81;;15645:7;15636:16;;;-1:-1:-1;15673:1:0;15663:11;15603:81;15705:7;15696:5;:16;15692:54;;15735:1;15725:11;15766:6;15036:742;-1:-1:-1;;15036:742:0:o;19332:145::-;19390:13;19419:52;-1:-1:-1;;;;;19431:22:0;;17692:2;18763:420;18853:13;18875:19;18907:10;18911:6;18907:1;:10;:::i;:::-;:14;;18920:1;18907:14;:::i;:::-;-1:-1:-1;;;;;18897:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18897:25:0;;18875:47;;-1:-1:-1;;;18929:6:0;18936:1;18929:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;18929:15:0;;;;;;;;;-1:-1:-1;;;18951:6:0;18958:1;18951:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;18951:15:0;;;;;;;;-1:-1:-1;18978:9:0;18990:10;18994:6;18990:1;:10;:::i;:::-;:14;;19003:1;18990:14;:::i;:::-;18978:26;;18973:115;19010:1;19006;:5;18973:115;;;-1:-1:-1;;;19048:5:0;19056:3;19048:11;19039:21;;;;;;;:::i;:::-;;;;19027:6;19034:1;19027:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;19027:33:0;;;;;;;;-1:-1:-1;19079:1:0;19069:11;;;;;19013:3;;;:::i;:::-;;;18973:115;;;-1:-1:-1;19102:10:0;;19094:55;;;;-1:-1:-1;;;19094:55:0;;19760:2:1;19094:55:0;;;19742:21:1;;;19779:18;;;19772:30;19838:34;19818:18;;;19811:62;19890:18;;19094:55:0;19558:356:1;60687:342:0;60855:1;60843:9;:13;60839:185;;;-1:-1:-1;;;;;60871:18:0;;;60867:73;;-1:-1:-1;;;;;60902:15:0;;;;;;:9;:15;;;;;:28;;60921:9;;60902:15;:28;;60921:9;;60902:28;:::i;:::-;;;;-1:-1:-1;;60867:73:0;-1:-1:-1;;;;;60952:16:0;;;60948:69;;-1:-1:-1;;;;;60981:13:0;;;;;;:9;:13;;;;;:26;;60998:9;;60981:13;:26;;60998:9;;60981:26;:::i;:::-;;;;-1:-1:-1;;60687:342:0;;;;:::o;54399:870::-;-1:-1:-1;;;;;54475:16:0;;54467:61;;;;-1:-1:-1;;;54467:61:0;;20121:2:1;54467:61:0;;;20103:21:1;;;20140:18;;;20133:30;20199:34;20179:18;;;20172:62;20251:18;;54467:61:0;19919:356:1;54467:61:0;54544:16;54552:7;54544;:16::i;:::-;54543:17;54535:58;;;;-1:-1:-1;;;54535:58:0;;;;;;;:::i;:::-;54602:48;54631:1;54635:2;54639:7;54648:1;54602:20;:48::i;:::-;54741:16;54749:7;54741;:16::i;:::-;54740:17;54732:58;;;;-1:-1:-1;;;54732:58:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;55105:13:0;;;;;;:9;:13;;;;;;;;:18;;55122:1;55105:18;;;55139:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;55139:21:0;;;;;55174:33;55147:7;;55105:13;;-1:-1:-1;;;;;;;;;;;55174:33:0;55105:13;;55174:33;25206:229;;:::o;59256:729::-;59392:4;59409:15;:2;-1:-1:-1;;;;;59409:13:0;;:15::i;:::-;59405:575;;;59448:71;;-1:-1:-1;;;59448:71:0;;-1:-1:-1;;;;;59448:36:0;;;;;:71;;3816:10;;59499:4;;59505:7;;59514:4;;59448:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59448:71:0;;;;;;;;-1:-1:-1;;59448:71:0;;;;;;;;;;;;:::i;:::-;;;59435:504;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59674:6;:13;59691:1;59674:18;59670:260;;59707:60;;-1:-1:-1;;;59707:60:0;;;;;;;:::i;59670:260::-;59898:6;59892:13;59883:6;59879:2;59875:15;59868:38;59435:504;-1:-1:-1;;;;;;59569:51:0;-1:-1:-1;;;59569:51:0;;-1:-1:-1;59562:58:0;;59405:575;-1:-1:-1;59968:4:0;59256:729;;;;;;:::o;73385:143::-;73448:7;73475:1;73471;:5;:51;;73617:13;73697:15;;;73727:4;73720:15;;;73768:4;73752:21;;73471:51;;;73617:13;73697:15;;;73727:4;73720:15;;;73768:4;73752:21;;73479:20;73534:251;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:1;;1348:180;-1:-1:-1;1348:180:1:o;1533:203::-;-1:-1:-1;;;;;1697:32:1;;;;1679:51;;1667:2;1652:18;;1533:203::o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:1;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:1:o;2360:186::-;2419:6;2472:2;2460:9;2451:7;2447:23;2443:32;2440:52;;;2488:1;2485;2478:12;2440:52;2511:29;2530:9;2511:29;:::i;2551:328::-;2628:6;2636;2644;2697:2;2685:9;2676:7;2672:23;2668:32;2665:52;;;2713:1;2710;2703:12;2665:52;2736:29;2755:9;2736:29;:::i;:::-;2726:39;;2784:38;2818:2;2807:9;2803:18;2784:38;:::i;:::-;2774:48;;2869:2;2858:9;2854:18;2841:32;2831:42;;2551:328;;;;;:::o;3251:254::-;3319:6;3327;3380:2;3368:9;3359:7;3355:23;3351:32;3348:52;;;3396:1;3393;3386:12;3348:52;3432:9;3419:23;3409:33;;3461:38;3495:2;3484:9;3480:18;3461:38;:::i;:::-;3451:48;;3251:254;;;;;:::o;3510:632::-;3681:2;3733:21;;;3803:13;;3706:18;;;3825:22;;;3652:4;;3681:2;3904:15;;;;3878:2;3863:18;;;3652:4;3947:169;3961:6;3958:1;3955:13;3947:169;;;4022:13;;4010:26;;4091:15;;;;4056:12;;;;3983:1;3976:9;3947:169;;;-1:-1:-1;4133:3:1;;3510:632;-1:-1:-1;;;;;;3510:632:1:o;4147:127::-;4208:10;4203:3;4199:20;4196:1;4189:31;4239:4;4236:1;4229:15;4263:4;4260:1;4253:15;4279:632;4344:5;-1:-1:-1;;;;;4404:14:1;;;4401:40;;;4421:18;;:::i;:::-;4496:2;4490:9;4464:2;4550:15;;-1:-1:-1;;4546:24:1;;;4572:2;4542:33;4538:42;4526:55;;;4596:18;;;4616:22;;;4593:46;4590:72;;;4642:18;;:::i;:::-;4682:10;4678:2;4671:22;4711:6;4702:15;;4741:6;4733;4726:22;4781:3;4772:6;4767:3;4763:16;4760:25;4757:45;;;4798:1;4795;4788:12;4757:45;4848:6;4843:3;4836:4;4828:6;4824:17;4811:44;4903:1;4896:4;4887:6;4879;4875:19;4871:30;4864:41;;;;4279:632;;;;;:::o;4916:451::-;4985:6;5038:2;5026:9;5017:7;5013:23;5009:32;5006:52;;;5054:1;5051;5044:12;5006:52;5081:23;;-1:-1:-1;;;;;5116:30:1;;5113:50;;;5159:1;5156;5149:12;5113:50;5182:22;;5235:4;5227:13;;5223:27;-1:-1:-1;5213:55:1;;5264:1;5261;5254:12;5213:55;5287:74;5353:7;5348:2;5335:16;5330:2;5326;5322:11;5287:74;:::i;5372:118::-;5458:5;5451:13;5444:21;5437:5;5434:32;5424:60;;5480:1;5477;5470:12;5495:315;5560:6;5568;5621:2;5609:9;5600:7;5596:23;5592:32;5589:52;;;5637:1;5634;5627:12;5589:52;5660:29;5679:9;5660:29;:::i;:::-;5650:39;;5739:2;5728:9;5724:18;5711:32;5752:28;5774:5;5752:28;:::i;:::-;5799:5;5789:15;;;5495:315;;;;;:::o;6055:615::-;6141:6;6149;6202:2;6190:9;6181:7;6177:23;6173:32;6170:52;;;6218:1;6215;6208:12;6170:52;6245:23;;-1:-1:-1;;;;;6317:14:1;;;6314:34;;;6344:1;6341;6334:12;6314:34;6382:6;6371:9;6367:22;6357:32;;6427:7;6420:4;6416:2;6412:13;6408:27;6398:55;;6449:1;6446;6439:12;6398:55;6489:2;6476:16;6515:2;6507:6;6504:14;6501:34;;;6531:1;6528;6521:12;6501:34;6584:7;6579:2;6569:6;6566:1;6562:14;6558:2;6554:23;6550:32;6547:45;6544:65;;;6605:1;6602;6595:12;6544:65;6636:2;6628:11;;;;;6658:6;;-1:-1:-1;6055:615:1;;-1:-1:-1;;;;6055:615:1:o;6675:667::-;6770:6;6778;6786;6794;6847:3;6835:9;6826:7;6822:23;6818:33;6815:53;;;6864:1;6861;6854:12;6815:53;6887:29;6906:9;6887:29;:::i;:::-;6877:39;;6935:38;6969:2;6958:9;6954:18;6935:38;:::i;:::-;6925:48;-1:-1:-1;7020:2:1;7005:18;;6992:32;;-1:-1:-1;7075:2:1;7060:18;;7047:32;-1:-1:-1;;;;;7091:30:1;;7088:50;;;7134:1;7131;7124:12;7088:50;7157:22;;7210:4;7202:13;;7198:27;-1:-1:-1;7188:55:1;;7239:1;7236;7229:12;7188:55;7262:74;7328:7;7323:2;7310:16;7305:2;7301;7297:11;7262:74;:::i;:::-;7252:84;;;6675:667;;;;;;;:::o;7347:260::-;7415:6;7423;7476:2;7464:9;7455:7;7451:23;7447:32;7444:52;;;7492:1;7489;7482:12;7444:52;7515:29;7534:9;7515:29;:::i;:::-;7505:39;;7563:38;7597:2;7586:9;7582:18;7563:38;:::i;7612:380::-;7691:1;7687:12;;;;7734;;;7755:61;;7809:4;7801:6;7797:17;7787:27;;7755:61;7862:2;7854:6;7851:14;7831:18;7828:38;7825:161;;7908:10;7903:3;7899:20;7896:1;7889:31;7943:4;7940:1;7933:15;7971:4;7968:1;7961:15;7825:161;;7612:380;;;:::o;7997:127::-;8058:10;8053:3;8049:20;8046:1;8039:31;8089:4;8086:1;8079:15;8113:4;8110:1;8103:15;8129:128;8196:9;;;8217:11;;;8214:37;;;8231:18;;:::i;8678:127::-;8739:10;8734:3;8730:20;8727:1;8720:31;8770:4;8767:1;8760:15;8794:4;8791:1;8784:15;8810:135;8849:3;8870:17;;;8867:43;;8890:18;;:::i;:::-;-1:-1:-1;8937:1:1;8926:13;;8810:135::o;8950:348::-;9152:2;9134:21;;;9191:2;9171:18;;;9164:30;-1:-1:-1;;;9225:2:1;9210:18;;9203:54;9289:2;9274:18;;8950:348::o;9713:125::-;9778:9;;;9799:10;;;9796:36;;;9812:18;;:::i;10222:545::-;10324:2;10319:3;10316:11;10313:448;;;10360:1;10385:5;10381:2;10374:17;10430:4;10426:2;10416:19;10500:2;10488:10;10484:19;10481:1;10477:27;10471:4;10467:38;10536:4;10524:10;10521:20;10518:47;;;-1:-1:-1;10559:4:1;10518:47;10614:2;10609:3;10605:12;10602:1;10598:20;10592:4;10588:31;10578:41;;10669:82;10687:2;10680:5;10677:13;10669:82;;;10732:17;;;10713:1;10702:13;10669:82;;;10673:3;;;10222:545;;;:::o;10943:1352::-;11063:10;;-1:-1:-1;;;;;11085:30:1;;11082:56;;;11118:18;;:::i;:::-;11147:97;11237:6;11197:38;11229:4;11223:11;11197:38;:::i;:::-;11191:4;11147:97;:::i;:::-;11299:4;;11363:2;11352:14;;11380:1;11375:663;;;;12082:1;12099:6;12096:89;;;-1:-1:-1;12151:19:1;;;12145:26;12096:89;-1:-1:-1;;10900:1:1;10896:11;;;10892:24;10888:29;10878:40;10924:1;10920:11;;;10875:57;12198:81;;11345:944;;11375:663;10169:1;10162:14;;;10206:4;10193:18;;-1:-1:-1;;11411:20:1;;;11529:236;11543:7;11540:1;11537:14;11529:236;;;11632:19;;;11626:26;11611:42;;11724:27;;;;11692:1;11680:14;;;;11559:19;;11529:236;;;11533:3;11793:6;11784:7;11781:19;11778:201;;;11854:19;;;11848:26;-1:-1:-1;;11937:1:1;11933:14;;;11949:3;11929:24;11925:37;11921:42;11906:58;11891:74;;11778:201;-1:-1:-1;;;;;12025:1:1;12009:14;;;12005:22;11992:36;;-1:-1:-1;10943:1352:1:o;13277:496::-;13456:3;13494:6;13488:13;13510:66;13569:6;13564:3;13557:4;13549:6;13545:17;13510:66;:::i;:::-;13639:13;;13598:16;;;;13661:70;13639:13;13598:16;13708:4;13696:17;;13661:70;:::i;:::-;13747:20;;13277:496;-1:-1:-1;;;;13277:496:1:o;14494:245::-;14561:6;14614:2;14602:9;14593:7;14589:23;14585:32;14582:52;;;14630:1;14627;14620:12;14582:52;14662:9;14656:16;14681:28;14703:5;14681:28;:::i;15576:409::-;15778:2;15760:21;;;15817:2;15797:18;;;15790:30;15856:34;15851:2;15836:18;;15829:62;-1:-1:-1;;;15922:2:1;15907:18;;15900:43;15975:3;15960:19;;15576:409::o;16843:812::-;-1:-1:-1;;;17249:3:1;17242:38;17224:3;17309:6;17303:13;17325:75;17393:6;17388:2;17383:3;17379:12;17372:4;17364:6;17360:17;17325:75;:::i;:::-;-1:-1:-1;;;17459:2:1;17419:16;;;17451:11;;;17444:40;17509:13;;17531:76;17509:13;17593:2;17585:11;;17578:4;17566:17;;17531:76;:::i;:::-;17627:17;17646:2;17623:26;;16843:812;-1:-1:-1;;;;16843:812:1:o;17660:401::-;17862:2;17844:21;;;17901:2;17881:18;;;17874:30;17940:34;17935:2;17920:18;;17913:62;-1:-1:-1;;;18006:2:1;17991:18;;17984:35;18051:3;18036:19;;17660:401::o;18471:414::-;18673:2;18655:21;;;18712:2;18692:18;;;18685:30;18751:34;18746:2;18731:18;;18724:62;-1:-1:-1;;;18817:2:1;18802:18;;18795:48;18875:3;18860:19;;18471:414::o;19244:168::-;19317:9;;;19348;;19365:15;;;19359:22;;19345:37;19335:71;;19386:18;;:::i;19417:136::-;19456:3;19484:5;19474:39;;19493:18;;:::i;:::-;-1:-1:-1;;;19529:18:1;;19417:136::o;20280:352::-;20482:2;20464:21;;;20521:2;20501:18;;;20494:30;-1:-1:-1;;;20555:2:1;20540:18;;20533:58;20623:2;20608:18;;20280:352::o;20637:489::-;-1:-1:-1;;;;;20906:15:1;;;20888:34;;20958:15;;20953:2;20938:18;;20931:43;21005:2;20990:18;;20983:34;;;21053:3;21048:2;21033:18;;21026:31;;;20831:4;;21074:46;;21100:19;;21092:6;21074:46;:::i;:::-;21066:54;20637:489;-1:-1:-1;;;;;;20637:489:1:o;21131:249::-;21200:6;21253:2;21241:9;21232:7;21228:23;21224:32;21221:52;;;21269:1;21266;21259:12;21221:52;21301:9;21295:16;21320:30;21344:5;21320:30;:::i

Swarm Source

ipfs://f78074e0896890700ed4d1922fa7fd7a46a453aa209cf931ae4fc666d879d527

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services