Token

ERC-20: Decal by Naime (DECAL)

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

ERC-721

Overview

Max Total Supply

100 DECAL

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x6a0c999516151274dcb30f69a3d1c4ee7f1e20ac

Filtered by Token Holder

0xFedeA86Ebec8DDE40a2ddD1d156350C62C6697E4

lemonhead.eth

Balance

1 DECAL

0xfedea86ebec8dde40a2ddd1d156350c62c6697e4

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Naime_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-11-23
*/

// 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/Naime_Decal.sol


pragma solidity ^0.8.17;








/// @author @0x__jj, @llio (Deca)
contract Naime_Decal is ERC721, ReentrancyGuard, AccessControl, 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 Naime", "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;
  }
}

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":"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"},{"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":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":"to","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":"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":"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":[{"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"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000030000000000000000000000000da4438a9cc8d41fe9c0c6efd302a173ed967da7000000000000000000000000000000000000000000000000000000000000003268747470733a2f2f636c69656e742d6170692e646563612e73797374656d732f646563616c2f6d657461646174612f32392f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a57ec3a618b6969a6b1fec2ef4bf54b2afc5ca30

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

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

Deployed Bytecode Sourcemap

74522:5070:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79301:180;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;79301:180:0;;;;;;;;48180:94;;;:::i;:::-;;;;;;;:::i;75623:262::-;;;;;;:::i;:::-;;:::i;:::-;;49617:171;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;49617:171:0;1533:203:1;49177:382:0;;;;;;:::i;:::-;;:::i;74780:30::-;;;;;;;;;2324:25:1;;;2312:2;2297:18;74780:30:0;2178:177:1;74735:38:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;50311:328;;;;;;:::i;:::-;;:::i;23770:135::-;;;;;;:::i;:::-;;:::i;74864:25::-;;;;;;24189:156;;;;;;:::i;:::-;;:::i;74817:40::-;;74854:3;74817:40;;25293:229;;;;;;:::i;:::-;;:::i;50702:165::-;;;;;;:::i;:::-;;:::i;74967:21::-;;;;;-1:-1:-1;;;;;74967:21:0;;;78804:433;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;47902:219::-;;;;;;:::i;:::-;;:::i;47641:207::-;;;;;;:::i;:::-;;:::i;29239:97::-;;;:::i;74896:30::-;;;;;;75891:129;;;;;;:::i;:::-;;:::i;74933:27::-;;;;;;28627:81;;;:::i;22394:156::-;;;;;;:::i;:::-;;:::i;48335:98::-;;;:::i;74995:21::-;;;:::i;76804:678::-;;;;;;:::i;:::-;;:::i;76026:129::-;;;;;;:::i;:::-;;:::i;21529:49::-;;21574:4;21529:49;;49852:164;;;;;;:::i;:::-;;:::i;78180:142::-;;;:::i;76161:637::-;;;;;;:::i;:::-;;:::i;50930:315::-;;;;;;:::i;:::-;;:::i;77488:686::-;;;;;;:::i;:::-;;:::i;78328:115::-;;;:::i;78449:349::-;;;;;;:::i;:::-;;:::i;75514:103::-;;;;;;:::i;:::-;;:::i;24614:158::-;;;;;;:::i;:::-;;:::i;50079:173::-;;;;;;:::i;:::-;;:::i;29481:191::-;;;;;;:::i;:::-;;:::i;79301:180::-;79419:4;79439:36;79463:11;79439:23;:36::i;:::-;79432:43;79301:180;-1:-1:-1;;79301:180:0:o;48180:94::-;48234:13;48263:5;48256:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48180:94;:::o;75623:262::-;21574:4;21994:16;21574:4;21994:10;:16::i;:::-;75786:11:::1;::::0;75773:24:::1;::::0;74854:3:::1;75773:24;:::i;:::-;75756:12;::::0;75737:31:::1;::::0;:16;:31:::1;:::i;:::-;75736:62;75732:106;;;75814:24;;-1:-1:-1::0;;;75814:24:0::1;;;;;;;;;;;75732:106;-1:-1:-1::0;75845:15:0::1;:34:::0;75623:262::o;49617:171::-;49703:7;49719:23;49734:7;49719:14;:23::i;:::-;-1:-1:-1;49758:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;49758:24:0;;49617:171::o;49177:382::-;49254:13;49270:23;49285:7;49270:14;:23::i;:::-;49254:39;;49314:5;-1:-1:-1;;;;;49308:11:0;:2;-1:-1:-1;;;;;49308:11:0;;49300:57;;;;-1:-1:-1;;;49300:57:0;;8133:2:1;49300:57:0;;;8115:21:1;8172:2;8152:18;;;8145:30;8211:34;8191:18;;;8184:62;-1:-1:-1;;;8262:18:1;;;8255:31;8303:19;;49300:57:0;;;;;;;;;3845:10;-1:-1:-1;;;;;49382:21:0;;;;:62;;-1:-1:-1;49407:37:0;49424:5;3845:10;50079:173;:::i;49407:37::-;49366:157;;;;-1:-1:-1;;;49366:157:0;;8535:2:1;49366:157:0;;;8517:21:1;8574:2;8554:18;;;8547:30;8613:34;8593:18;;;8586:62;8684:31;8664:18;;;8657:59;8733:19;;49366:157:0;8333:425:1;49366:157:0;49532:21;49541:2;49545:7;49532:8;:21::i;:::-;49247:312;49177:382;;:::o;50311:328::-;50492:41;3845:10;50525:7;50492:18;:41::i;:::-;50476:120;;;;-1:-1:-1;;;50476:120:0;;;;;;;:::i;:::-;50605:28;50615:4;50621:2;50625:7;50605:9;:28::i;23770:135::-;23854:7;23877:12;;;:6;:12;;;;;:22;;;;23770:135::o;24189:156::-;24287:18;24300:4;24287:12;:18::i;:::-;21994:16;22005:4;21994:10;:16::i;:::-;24314:25:::1;24325:4;24331:7;24314:10;:25::i;25293:229::-:0;-1:-1:-1;;;;;25393:23:0;;3845:10;25393:23;25377:104;;;;-1:-1:-1;;;25377:104:0;;9379:2:1;25377:104:0;;;9361:21:1;9418:2;9398:18;;;9391:30;9457:34;9437:18;;;9430:62;-1:-1:-1;;;9508:18:1;;;9501:45;9563:19;;25377:104:0;9177:411:1;25377:104:0;25490:26;25502:4;25508:7;25490:11;:26::i;:::-;25293:229;;:::o;50702:165::-;50822:39;50839:4;50845:2;50849:7;50822:39;;;;;;;;;;;;:16;:39::i;78804:433::-;78879:16;78904:18;78925:17;78935:6;78925:9;:17::i;:::-;78904:38;;78949:25;78991:10;-1:-1:-1;;;;;78977:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;78977:25:0;;78949:53;;79009:12;79037:9;79032:178;79056:11;;79052:1;:15;79032:178;;;79101:6;-1:-1:-1;;;;;79087:20:0;:10;79095:1;79087:7;:10::i;:::-;-1:-1:-1;;;;;79087:20:0;;79083:82;;79137:1;79120:8;79129:4;79120:14;;;;;;;;:::i;:::-;;;;;;;;;;:18;79149:6;;;;:::i;:::-;;;;79083:82;79173:29;;;79197:5;79173:29;79069:3;;;;:::i;:::-;;;;79032:178;;;-1:-1:-1;79223:8:0;;78804:433;-1:-1:-1;;;;78804:433:0:o;47902:219::-;47984:7;48000:13;48016:17;48025:7;48016:8;:17::i;:::-;48000:33;-1:-1:-1;;;;;;48048:19:0;;48040:56;;;;-1:-1:-1;;;48040:56:0;;;;;;;:::i;47641:207::-;47723:7;-1:-1:-1;;;;;47747:19:0;;47739:73;;;;-1:-1:-1;;;47739:73:0;;10420:2:1;47739:73:0;;;10402:21:1;10459:2;10439:18;;;10432:30;10498:34;10478:18;;;10471:62;-1:-1:-1;;;10549:18:1;;;10542:39;10598:19;;47739:73:0;10218:405:1;47739:73:0;-1:-1:-1;;;;;;47826:16:0;;;;;:9;:16;;;;;;;47641:207::o;29239:97::-;28527:13;:11;:13::i;:::-;29300:30:::1;29327:1;29300:18;:30::i;:::-;29239:97::o:0;75891:129::-;21574:4;21994:16;21574:4;21994:10;:16::i;:::-;-1:-1:-1;75990:10:0::1;:24:::0;75891:129::o;28627:81::-;28696:6;;-1:-1:-1;;;;;28696:6:0;;28627:81::o;22394:156::-;22495:4;22515:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;22515:29:0;;;;;;;;;;;;;;;22394:156::o;48335:98::-;48391:13;48420:7;48413:14;;;;;:::i;74995:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;76804:678::-;64460:21;:19;:21::i;:::-;21574:4:::1;21994:16;21574:4:::0;21994:10:::1;:16::i;:::-;76929:15:::2;76948:1;76929:20:::0;76925:49:::2;;76958:16;;-1:-1:-1::0;;;76958:16:0::2;;;;;;;;;;;76925:49;76985:6;::::0;-1:-1:-1;;;;;76985:6:0::2;76981:43;;77014:10;;-1:-1:-1::0;;;77014:10:0::2;;;;;;;;;;;76981:43;77031:17;77069:12;;77051:15;;:30;;;;:::i;:::-;77031:50;;77092:9;77105:1;77092:14:::0;77088:51:::2;;77115:24;;-1:-1:-1::0;;;77115:24:0::2;;;;;;;;;;;77088:51;77172:36;77181:15;77198:9;77172:8;:36::i;:::-;77234:11;::::0;77146:63;;-1:-1:-1;77216:15:0::2;77252:107;77276:15;77272:1;:19;77252:107;;;77317:6;::::0;77307:26:::2;::::0;-1:-1:-1;;;;;77317:6:0::2;77325:7:::0;77307:9:::2;:26::i;:::-;77342:9:::0;::::2;::::0;::::2;:::i;:::-;;;;77293:3;;;;;:::i;:::-;;;;77252:107;;;;77381:15;77365:12;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;77403:11:0::2;:21:::0;;;77436:40:::2;::::0;;10932:25:1;;;10988:2;10973:18;;10966:34;;;-1:-1:-1;;;;;;;;;;;77436:40:0;10905:18:1;77436:40:0::2;;;;;;;76918:564;;64488:1:::1;64496:20:::0;63930:1;64980:7;:22;64809:199;64496:20;76804:678;:::o;76026:129::-;21574:4;21994:16;21574:4;21994:10;:16::i;:::-;76128:7:::1;:21;76138:11:::0;76128:7;:21:::1;:::i;49852:164::-:0;49958:52;3845:10;49991:8;50001;49958:18;:52::i;78180:142::-;78234:7;78303:12;;78285:15;;:30;;;;:::i;:::-;78270:11;;78257:24;;74854:3;78257:24;:::i;:::-;:59;;;;:::i;:::-;78250:66;;78180:142;:::o;76161:637::-;76249:15;64460:21;:19;:21::i;:::-;76284:10:::1;76277:18;::::0;;;:6:::1;:18;::::0;;;;;::::1;;76273:46;;;76304:15;;-1:-1:-1::0;;;76304:15:0::1;;;;;;;;;;;76273:46;74854:3;76330:11;;:25;76326:56;;76364:18;;-1:-1:-1::0;;;76364:18:0::1;;;;;;;;;;;76326:56;76419:1;76393:23;:21;:23::i;:::-;:27;76389:64;;;76429:24;;-1:-1:-1::0;;;76429:24:0::1;;;;;;;;;;;76389:64;76464:23;:10;:21;:23::i;:::-;76460:60;;;76496:24;;-1:-1:-1::0;;;76496:24:0::1;;;;;;;;;;;76460:60;76552:28;::::0;-1:-1:-1;;;;;;76569:10:0::1;13389:2:1::0;13360:15;13356:45;76552:28:0::1;::::0;::::1;13344:58:1::0;76527:12:0::1;::::0;13418::1;;76552:28:0::1;;;;;;;;;;;;76542:39;;;;;;76527:54;;76593:50;76612:12;;76593:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;76626:10:0::1;::::0;;-1:-1:-1;76638:4:0;;-1:-1:-1;76593:18:0::1;:50::i;:::-;76588:87;;76659:16;;-1:-1:-1::0;;;76659:16:0::1;;;;;;;;;;;76588:87;76689:10;76682:18;::::0;;;:6:::1;:18;::::0;;;;:25;;-1:-1:-1;;76682:25:0::1;76703:4;76682:25;::::0;;76724:11:::1;::::0;;;-1:-1:-1;76724:11:0;;76742:13:::1;76724:11:::0;76742:13:::1;:::i;:::-;;;;;;76762:30;76772:10;76784:7;76762:9;:30::i;:::-;76266:532;64496:20:::0;63930:1;64980:7;:22;64809:199;50930:315;51090:41;3845:10;51123:7;51090:18;:41::i;:::-;51074:120;;;;-1:-1:-1;;;51074:120:0;;;;;;;:::i;:::-;51201:38;51215:4;51221:2;51225:7;51234:4;51201:13;:38::i;:::-;50930:315;;;;:::o;77488:686::-;64460:21;:19;:21::i;:::-;77566:15:::1;77585:1;77566:20:::0;77562:49:::1;;77595:16;;-1:-1:-1::0;;;77595:16:0::1;;;;;;;;;;;77562:49;77622:6;::::0;-1:-1:-1;;;;;77622:6:0::1;77618:43;;77651:10;;-1:-1:-1::0;;;77651:10:0::1;;;;;;;;;;;77618:43;77686:6;::::0;-1:-1:-1;;;;;77686:6:0::1;77672:10;:20;77668:44;;77701:11;;-1:-1:-1::0;;;77701:11:0::1;;;;;;;;;;;77668:44;77719:17;77757:12;;77739:15;;:30;;;;:::i;:::-;77719:50;;77780:9;77793:1;77780:14:::0;77776:51:::1;;77803:24;;-1:-1:-1::0;;;77803:24:0::1;;;;;;;;;;;77776:51;77860:36;77869:15;77886:9;77860:8;:36::i;:::-;77922:11;::::0;77834:63;;-1:-1:-1;77904:15:0::1;77940:111;77964:15;77960:1;:19;77940:111;;;77995:30;78005:10;78017:7;77995:9;:30::i;:::-;78034:9:::0;::::1;::::0;::::1;:::i;:::-;;;;77981:3;;;;;:::i;:::-;;;;77940:111;;;;78073:15;78057:12;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;78095:11:0::1;:21:::0;;;78128:40:::1;::::0;;10932:25:1;;;10988:2;10973:18;;10966:34;;;-1:-1:-1;;;;;;;;;;;78128:40:0;10905:18:1;78128:40:0::1;;;;;;;77555:619;;64496:20:::0;63930:1;64980:7;:22;64809:199;78328:115;78384:7;78425:12;;78407:15;;:30;;;;:::i;78449:349::-;78533:13;78563:17;78571:8;78563:7;:17::i;:::-;78555:68;;;;-1:-1:-1;;;78555:68:0;;13643:2:1;78555:68:0;;;13625:21:1;13682:2;13662:18;;;13655:30;13721:34;13701:18;;;13694:62;-1:-1:-1;;;13772:18:1;;;13765:36;13818:19;;78555:68:0;13441:402:1;78555:68:0;78630:21;78654:10;:8;:10::i;:::-;78630:34;;78703:1;78685:7;78679:21;:25;78671:53;;;;-1:-1:-1;;;78671:53:0;;14050:2:1;78671:53:0;;;14032:21:1;14089:2;14069:18;;;14062:30;-1:-1:-1;;;14108:18:1;;;14101:45;14163:18;;78671:53:0;13848:339:1;78671:53:0;78762:7;78771:19;:8;:17;:19::i;:::-;78745:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78731:61;;;78449:349;;;:::o;75514:103::-;21574:4;21994:16;21574:4;21994:10;:16::i;:::-;-1:-1:-1;75595:6:0::1;:16:::0;;-1:-1:-1;;;;;;75595:16:0::1;-1:-1:-1::0;;;;;75595:16:0;;;::::1;::::0;;;::::1;::::0;;75514:103::o;24614:158::-;24713:18;24726:4;24713:12;:18::i;:::-;21994:16;22005:4;21994:10;:16::i;:::-;24740:26:::1;24752:4;24758:7;24740:11;:26::i;50079:173::-:0;-1:-1:-1;;;;;50211:25:0;;;50191:4;50211:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;50079:173::o;29481:191::-;28527:13;:11;:13::i;:::-;-1:-1:-1;;;;;29566:22:0;::::1;29558:73;;;::::0;-1:-1:-1;;;29558:73:0;;14895:2:1;29558:73:0::1;::::0;::::1;14877:21:1::0;14934:2;14914:18;;;14907:30;14973:34;14953:18;;;14946:62;-1:-1:-1;;;15024:18:1;;;15017:36;15070:19;;29558:73:0::1;14693:402:1::0;29558:73:0::1;29638:28;29657:8;29638:18;:28::i;22088:222::-:0;22183:4;-1:-1:-1;;;;;;22210:47:0;;-1:-1:-1;;;22210:47:0;;:94;;;22268:36;22292:11;22268:23;:36::i;22836:99::-;22899:30;22910:4;3845:10;22899;:30::i;58878:129::-;58956:16;58964:7;58956;:16::i;:::-;58948:53;;;;-1:-1:-1;;;58948:53:0;;;;;;;:::i;58215:164::-;58286:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;58286:29:0;-1:-1:-1;;;;;58286:29:0;;;;;;;;:24;;58336:23;58286:24;58336:14;:23::i;:::-;-1:-1:-1;;;;;58327:46:0;;;;;;;;;;;58215:164;;:::o;53179:283::-;53287:4;53300:13;53316:23;53331:7;53316:14;:23::i;:::-;53300:39;;53365:5;-1:-1:-1;;;;;53354:16:0;:7;-1:-1:-1;;;;;53354:16:0;;:59;;;;53381:32;53398:5;53405:7;53381:16;:32::i;:::-;53354:101;;;;53448:7;-1:-1:-1;;;;;53424:31:0;:20;53436:7;53424:11;:20::i;:::-;-1:-1:-1;;;;;53424:31:0;;53354:101;53346:110;53179:283;-1:-1:-1;;;;53179:283:0:o;56909:1199::-;57058:4;-1:-1:-1;;;;;57031:31:0;:23;57046:7;57031:14;:23::i;:::-;-1:-1:-1;;;;;57031:31:0;;57015:102;;;;-1:-1:-1;;;57015:102:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;57132:16:0;;57124:65;;;;-1:-1:-1;;;57124:65:0;;15708:2:1;57124:65:0;;;15690:21:1;15747:2;15727:18;;;15720:30;15786:34;15766:18;;;15759:62;-1:-1:-1;;;15837:18:1;;;15830:34;15881:19;;57124:65:0;15506:400:1;57124:65:0;57198:42;57219:4;57225:2;57229:7;57238:1;57198:20;:42::i;:::-;57370:4;-1:-1:-1;;;;;57343:31:0;:23;57358:7;57343:14;:23::i;:::-;-1:-1:-1;;;;;57343:31:0;;57327:102;;;;-1:-1:-1;;;57327:102:0;;;;;;;:::i;:::-;57493:24;;;;:15;:24;;;;;;;;57486:31;;-1:-1:-1;;;;;;57486:31:0;;;;;;-1:-1:-1;;;;;57929:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;57929:20:0;;;57958:13;;;;;;;;;:18;;57486:31;57958:18;;;57990:16;;;:7;:16;;;;;;:21;;;;;;;;;;58025:27;;57509:7;;-1:-1:-1;;;;;;;;;;;58025:27:0;;49247:312;49177:382;;:::o;26811:216::-;26891:22;26899:4;26905:7;26891;:22::i;:::-;26886:136;;26924:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;26924:29:0;;;;;;;;;:36;;-1:-1:-1;;26924:36:0;26956:4;26924:36;;;27001:12;3845:10;;3765:98;27001:12;-1:-1:-1;;;;;26974:40:0;26992:7;-1:-1:-1;;;;;26974:40:0;26986:4;26974:40;;;;;;;;;;26811:216;;:::o;27191:217::-;27271:22;27279:4;27285:7;27271;:22::i;:::-;27267:136;;;27336:5;27304:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;27304:29:0;;;;;;;;;;:37;;-1:-1:-1;;27304:37:0;;;27355:40;3845:10;;27304:12;;27355:40;;27336:5;27355:40;27191:217;;:::o;52500:111::-;52566:7;52589:16;;;:7;:16;;;;;;-1:-1:-1;;;;;52589:16:0;;52500:111::o;28778:126::-;3845:10;28838:7;:5;:7::i;:::-;-1:-1:-1;;;;;28838:23:0;;28830:68;;;;-1:-1:-1;;;28830:68:0;;16113:2:1;28830:68:0;;;16095:21:1;;;16132:18;;;16125:30;16191:34;16171:18;;;16164:62;16243:18;;28830:68:0;15911:356:1;29822:177:0;29911:6;;;-1:-1:-1;;;;;29924:17:0;;;-1:-1:-1;;;;;;29924:17:0;;;;;;;29953:40;;29911:6;;;29924:17;29911:6;;29953:40;;29892:16;;29953:40;29885:114;29822:177;:::o;64528:275::-;63972:1;64654:7;;:19;64646:63;;;;-1:-1:-1;;;64646:63:0;;16474:2:1;64646:63:0;;;16456:21:1;16513:2;16493:18;;;16486:30;16552:33;16532:18;;;16525:61;16603:18;;64646:63:0;16272:355:1;64646:63:0;63972:1;64779:7;:18;64528:275::o;6547:100::-;6605:7;6632:1;6628;:5;:13;;6640:1;6628:13;;;6636:1;6628:13;6621:20;6547:100;-1:-1:-1;;;6547:100:0:o;53782:104::-;53854:26;53864:2;53868:7;53854:26;;;;;;;;;;;;:9;:26::i;58510:287::-;58647:8;-1:-1:-1;;;;;58638:17:0;:5;-1:-1:-1;;;;;58638:17:0;;58630:55;;;;-1:-1:-1;;;58630:55:0;;16834:2:1;58630:55:0;;;16816:21:1;16873:2;16853:18;;;16846:30;-1:-1:-1;;;16892:18:1;;;16885:55;16957:18;;58630:55:0;16632:349:1;58630:55:0;-1:-1:-1;;;;;58692:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;58692:46:0;;;;;;;;;;58750:41;;540::1;;;58750::0;;513:18:1;58750:41:0;;;;;;;58510:287;;;:::o;38072:308::-;-1:-1:-1;;;;;38351:19:0;;:23;;;38072:308::o;66231:170::-;66342:4;66391;66362:25;66375:5;66382:4;66362:12;:25::i;:::-;:33;;66231:170;-1:-1:-1;;;;66231:170:0:o;52088:306::-;52222:28;52232:4;52238:2;52242:7;52222:9;:28::i;:::-;52273:47;52296:4;52302:2;52306:7;52315:4;52273:22;:47::i;:::-;52257:131;;;;-1:-1:-1;;;52257:131:0;;;;;;;:::i;52906:122::-;52971:4;;52991:17;53000:7;52991:8;:17::i;:::-;-1:-1:-1;;;;;52991:31:0;;;;52906:122;-1:-1:-1;;52906:122:0:o;79487:102::-;79547:13;79576:7;79569:14;;;;;:::i;17870:586::-;17926:13;17967:14;17984:17;17995:5;17984:10;:17::i;:::-;18004:1;17984:21;17967:38;;18014:20;18048:6;-1:-1:-1;;;;;18037:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18037:18:0;-1:-1:-1;18014:41:0;-1:-1:-1;18153:28:0;;;18169:2;18153:28;18198:224;-1:-1:-1;;18222:5:0;-1:-1:-1;;;18333:2:0;18322:14;;18317:30;18222:5;18304:44;18378:2;18369:11;;;-1:-1:-1;18391:21:0;18198:224;18391:21;-1:-1:-1;18437:6:0;17870:586;-1:-1:-1;;;17870:586:0:o;47294:291::-;47406:4;-1:-1:-1;;;;;;47433:40:0;;-1:-1:-1;;;47433:40:0;;:99;;-1:-1:-1;;;;;;;47484:48:0;;-1:-1:-1;;;47484:48:0;47433:99;:146;;;-1:-1:-1;;;;;;;;;;5884:40:0;;;47543:36;5775:157;23209:386;23294:22;23302:4;23308:7;23294;:22::i;:::-;23289:301;;23434:28;23454:7;23434:19;:28::i;:::-;23511:38;23539:4;23546:2;23511:19;:38::i;:::-;23363:199;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;23363:199:0;;;;;;;;;;-1:-1:-1;;;23327:255:0;;;;;;;:::i;60980:342::-;61148:1;61136:9;:13;61132:185;;;-1:-1:-1;;;;;61164:18:0;;;61160:73;;-1:-1:-1;;;;;61195:15:0;;;;;;:9;:15;;;;;:28;;61214:9;;61195:15;:28;;61214:9;;61195:28;:::i;:::-;;;;-1:-1:-1;;61160:73:0;-1:-1:-1;;;;;61245:16:0;;;61241:69;;-1:-1:-1;;;;;61274:13:0;;;;;;:9;:13;;;;;:26;;61291:9;;61274:13;:26;;61291:9;;61274:26;:::i;:::-;;;;-1:-1:-1;;60980:342:0;;;;:::o;54103:279::-;54214:18;54220:2;54224:7;54214:5;:18::i;:::-;54255:53;54286:1;54290:2;54294:7;54303:4;54255:22;:53::i;:::-;54239:137;;;;-1:-1:-1;;;54239:137:0;;;;;;;:::i;67028:287::-;67126:7;67165:4;67126:7;67176:108;67200:5;:12;67196:1;:16;67176:108;;;67243:33;67253:12;67267:5;67273:1;67267:8;;;;;;;;:::i;:::-;;;;;;;67243:9;:33::i;:::-;67228:48;-1:-1:-1;67214:3:0;;;;:::i;:::-;;;;67176:108;;;-1:-1:-1;67297:12:0;67028:287;-1:-1:-1;;;67028:287:0:o;59549:729::-;59685:4;59702:15;:2;-1:-1:-1;;;;;59702:13:0;;:15::i;:::-;59698:575;;;59741:71;;-1:-1:-1;;;59741:71:0;;-1:-1:-1;;;;;59741:36:0;;;;;:71;;3845:10;;59792:4;;59798:7;;59807:4;;59741:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59741:71:0;;;;;;;;-1:-1:-1;;59741:71:0;;;;;;;;;;;;:::i;:::-;;;59728:504;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59967:6;:13;59984:1;59967:18;59963:260;;60000:60;;-1:-1:-1;;;60000:60:0;;;;;;;:::i;59963:260::-;60191:6;60185:13;60176:6;60172:2;60168:15;60161:38;59728:504;-1:-1:-1;;;;;;59862:51:0;-1:-1:-1;;;59862:51:0;;-1:-1:-1;59855:58:0;;59698:575;-1:-1:-1;60261:4:0;59549:729;;;;;;:::o;15109:742::-;15162:7;;-1:-1:-1;;;15226:17:0;;15222:84;;-1:-1:-1;;;15256:17:0;;;-1:-1:-1;15294:2:0;15284:12;15222:84;-1:-1:-1;;;15318:5:0;:17;15314:84;;-1:-1:-1;;;15348:17:0;;;-1:-1:-1;15386:2:0;15376:12;15314:84;15419:8;15410:5;:17;15406:84;;15449:8;15440:17;;;-1:-1:-1;15478:2:0;15468:12;15406:84;15511:7;15502:5;:16;15498:81;;15540:7;15531:16;;;-1:-1:-1;15568:1:0;15558:11;15498:81;15600:7;15591:5;:16;15587:81;;15629:7;15620:16;;;-1:-1:-1;15657:1:0;15647:11;15587:81;15689:7;15680:5;:16;15676:81;;15718:7;15709:16;;;-1:-1:-1;15746:1:0;15736:11;15676:81;15778:7;15769:5;:16;15765:54;;15808:1;15798:11;15839:6;15109:742;-1:-1:-1;;15109:742:0:o;19409:145::-;19467:13;19496:52;-1:-1:-1;;;;;19508:22:0;;17769:2;18840:420;18930:13;18952:19;18984:10;18988:6;18984:1;:10;:::i;:::-;:14;;18997:1;18984:14;:::i;:::-;-1:-1:-1;;;;;18974:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18974:25:0;;18952:47;;-1:-1:-1;;;19006:6:0;19013:1;19006:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;19006:15:0;;;;;;;;;-1:-1:-1;;;19028:6:0;19035:1;19028:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;19028:15:0;;;;;;;;-1:-1:-1;19055:9:0;19067:10;19071:6;19067:1;:10;:::i;:::-;:14;;19080:1;19067:14;:::i;:::-;19055:26;;19050:115;19087:1;19083;:5;19050:115;;;-1:-1:-1;;;19125:5:0;19133:3;19125:11;19116:21;;;;;;;:::i;:::-;;;;19104:6;19111:1;19104:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;19104:33:0;;;;;;;;-1:-1:-1;19156:1:0;19146:11;;;;;19090:3;;;:::i;:::-;;;19050:115;;;-1:-1:-1;19179:10:0;;19171:55;;;;-1:-1:-1;;;19171:55:0;;19618:2:1;19171:55:0;;;19600:21:1;;;19637:18;;;19630:30;19696:34;19676:18;;;19669:62;19748:18;;19171:55:0;19416:356:1;54692:870:0;-1:-1:-1;;;;;54768:16:0;;54760:61;;;;-1:-1:-1;;;54760:61:0;;19979:2:1;54760:61:0;;;19961:21:1;;;19998:18;;;19991:30;20057:34;20037:18;;;20030:62;20109:18;;54760:61:0;19777:356:1;54760:61:0;54837:16;54845:7;54837;:16::i;:::-;54836:17;54828:58;;;;-1:-1:-1;;;54828:58:0;;;;;;;:::i;:::-;54895:48;54924:1;54928:2;54932:7;54941:1;54895:20;:48::i;:::-;55034:16;55042:7;55034;:16::i;:::-;55033:17;55025:58;;;;-1:-1:-1;;;55025:58:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;55398:13:0;;;;;;:9;:13;;;;;;;;:18;;55415:1;55398:18;;;55432:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;55432:21:0;;;;;55467:33;55440:7;;55398:13;;-1:-1:-1;;;;;;;;;;;55467:33:0;55398:13;;55467:33;25293:229;;:::o;73686:143::-;73749:7;73776:1;73772;:5;:51;;73918:13;73998:15;;;74028:4;74021:15;;;74069:4;74053:21;;73772:51;;;73918:13;73998:15;;;74028:4;74021:15;;;74069:4;74053:21;;73780:20;73835: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;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:347::-;5437:6;5445;5498:2;5486:9;5477:7;5473:23;5469:32;5466:52;;;5514:1;5511;5504:12;5466:52;5537:29;5556:9;5537:29;:::i;:::-;5527:39;;5616:2;5605:9;5601:18;5588:32;5663:5;5656:13;5649:21;5642:5;5639:32;5629:60;;5685:1;5682;5675:12;5629:60;5708:5;5698:15;;;5372:347;;;;;:::o;5724:615::-;5810:6;5818;5871:2;5859:9;5850:7;5846:23;5842:32;5839:52;;;5887:1;5884;5877:12;5839:52;5914:23;;-1:-1:-1;;;;;5986:14:1;;;5983:34;;;6013:1;6010;6003:12;5983:34;6051:6;6040:9;6036:22;6026:32;;6096:7;6089:4;6085:2;6081:13;6077:27;6067:55;;6118:1;6115;6108:12;6067:55;6158:2;6145:16;6184:2;6176:6;6173:14;6170:34;;;6200:1;6197;6190:12;6170:34;6253:7;6248:2;6238:6;6235:1;6231:14;6227:2;6223:23;6219:32;6216:45;6213:65;;;6274:1;6271;6264:12;6213:65;6305:2;6297:11;;;;;6327:6;;-1:-1:-1;5724:615:1;;-1:-1:-1;;;;5724:615:1:o;6344:667::-;6439:6;6447;6455;6463;6516:3;6504:9;6495:7;6491:23;6487:33;6484:53;;;6533:1;6530;6523:12;6484:53;6556:29;6575:9;6556:29;:::i;:::-;6546:39;;6604:38;6638:2;6627:9;6623:18;6604:38;:::i;:::-;6594:48;-1:-1:-1;6689:2:1;6674:18;;6661:32;;-1:-1:-1;6744:2:1;6729:18;;6716:32;-1:-1:-1;;;;;6760:30:1;;6757:50;;;6803:1;6800;6793:12;6757:50;6826:22;;6879:4;6871:13;;6867:27;-1:-1:-1;6857:55:1;;6908:1;6905;6898:12;6857:55;6931:74;6997:7;6992:2;6979:16;6974:2;6970;6966:11;6931:74;:::i;:::-;6921:84;;;6344:667;;;;;;;:::o;7016:260::-;7084:6;7092;7145:2;7133:9;7124:7;7120:23;7116:32;7113:52;;;7161:1;7158;7151:12;7113:52;7184:29;7203:9;7184:29;:::i;:::-;7174:39;;7232:38;7266:2;7255:9;7251:18;7232:38;:::i;7281:380::-;7360:1;7356:12;;;;7403;;;7424:61;;7478:4;7470:6;7466:17;7456:27;;7424:61;7531:2;7523:6;7520:14;7500:18;7497:38;7494:161;;7577:10;7572:3;7568:20;7565:1;7558:31;7612:4;7609:1;7602:15;7640:4;7637:1;7630:15;7494:161;;7281:380;;;:::o;7666:127::-;7727:10;7722:3;7718:20;7715:1;7708:31;7758:4;7755:1;7748:15;7782:4;7779:1;7772:15;7798:128;7865:9;;;7886:11;;;7883:37;;;7900:18;;:::i;8763:409::-;8965:2;8947:21;;;9004:2;8984:18;;;8977:30;9043:34;9038:2;9023:18;;9016:62;-1:-1:-1;;;9109:2:1;9094:18;;9087:43;9162:3;9147:19;;8763:409::o;9593:127::-;9654:10;9649:3;9645:20;9642:1;9635:31;9685:4;9682:1;9675:15;9709:4;9706:1;9699:15;9725:135;9764:3;9785:17;;;9782:43;;9805:18;;:::i;:::-;-1:-1:-1;9852:1:1;9841:13;;9725:135::o;9865:348::-;10067:2;10049:21;;;10106:2;10086:18;;;10079:30;-1:-1:-1;;;10140:2:1;10125:18;;10118:54;10204:2;10189:18;;9865:348::o;10628:125::-;10693:9;;;10714:10;;;10711:36;;;10727:18;;:::i;11137:545::-;11239:2;11234:3;11231:11;11228:448;;;11275:1;11300:5;11296:2;11289:17;11345:4;11341:2;11331:19;11415:2;11403:10;11399:19;11396:1;11392:27;11386:4;11382:38;11451:4;11439:10;11436:20;11433:47;;;-1:-1:-1;11474:4:1;11433:47;11529:2;11524:3;11520:12;11517:1;11513:20;11507:4;11503:31;11493:41;;11584:82;11602:2;11595:5;11592:13;11584:82;;;11647:17;;;11628:1;11617:13;11584:82;;;11588:3;;;11137:545;;;:::o;11858:1352::-;11978:10;;-1:-1:-1;;;;;12000:30:1;;11997:56;;;12033:18;;:::i;:::-;12062:97;12152:6;12112:38;12144:4;12138:11;12112:38;:::i;:::-;12106:4;12062:97;:::i;:::-;12214:4;;12278:2;12267:14;;12295:1;12290:663;;;;12997:1;13014:6;13011:89;;;-1:-1:-1;13066:19:1;;;13060:26;13011:89;-1:-1:-1;;11815:1:1;11811:11;;;11807:24;11803:29;11793:40;11839:1;11835:11;;;11790:57;13113:81;;12260:944;;12290:663;11084:1;11077:14;;;11121:4;11108:18;;-1:-1:-1;;12326:20:1;;;12444:236;12458:7;12455:1;12452:14;12444:236;;;12547:19;;;12541:26;12526:42;;12639:27;;;;12607:1;12595:14;;;;12474:19;;12444:236;;;12448:3;12708:6;12699:7;12696:19;12693:201;;;12769:19;;;12763:26;-1:-1:-1;;12852:1:1;12848:14;;;12864:3;12844:24;12840:37;12836:42;12821:58;12806:74;;12693:201;-1:-1:-1;;;;;12940:1:1;12924:14;;;12920:22;12907:36;;-1:-1:-1;11858:1352:1:o;14192:496::-;14371:3;14409:6;14403:13;14425:66;14484:6;14479:3;14472:4;14464:6;14460:17;14425:66;:::i;:::-;14554:13;;14513:16;;;;14576:70;14554:13;14513:16;14623:4;14611:17;;14576:70;:::i;:::-;14662:20;;14192:496;-1:-1:-1;;;;14192:496:1:o;15100:401::-;15302:2;15284:21;;;15341:2;15321:18;;;15314:30;15380:34;15375:2;15360:18;;15353:62;-1:-1:-1;;;15446:2:1;15431:18;;15424:35;15491:3;15476:19;;15100:401::o;16986:414::-;17188:2;17170:21;;;17227:2;17207:18;;;17200:30;17266:34;17261:2;17246:18;;17239:62;-1:-1:-1;;;17332:2:1;17317:18;;17310:48;17390:3;17375:19;;16986:414::o;17537:812::-;-1:-1:-1;;;17943:3:1;17936:38;17918:3;18003:6;17997:13;18019:75;18087:6;18082:2;18077:3;18073:12;18066:4;18058:6;18054:17;18019:75;:::i;:::-;-1:-1:-1;;;18153:2:1;18113:16;;;18145:11;;;18138:40;18203:13;;18225:76;18203:13;18287:2;18279:11;;18272:4;18260:17;;18225:76;:::i;:::-;18321:17;18340:2;18317:26;;17537:812;-1:-1:-1;;;;17537:812:1:o;18354:489::-;-1:-1:-1;;;;;18623:15:1;;;18605:34;;18675:15;;18670:2;18655:18;;18648:43;18722:2;18707:18;;18700:34;;;18770:3;18765:2;18750:18;;18743:31;;;18548:4;;18791:46;;18817:19;;18809:6;18791:46;:::i;:::-;18783:54;18354:489;-1:-1:-1;;;;;;18354:489:1:o;18848:249::-;18917:6;18970:2;18958:9;18949:7;18945:23;18941:32;18938:52;;;18986:1;18983;18976:12;18938:52;19018:9;19012:16;19037:30;19061:5;19037:30;:::i;19102:168::-;19175:9;;;19206;;19223:15;;;19217:22;;19203:37;19193:71;;19244:18;;:::i;19275:136::-;19314:3;19342:5;19332:39;;19351:18;;:::i;:::-;-1:-1:-1;;;19387:18:1;;19275:136::o;20138:352::-;20340:2;20322:21;;;20379:2;20359:18;;;20352:30;-1:-1:-1;;;20413:2:1;20398:18;;20391:58;20481:2;20466:18;;20138:352::o

Swarm Source

ipfs://0864f8c5af234c4a8b62129987b7ec4d2c096ccb22a4ade011e42b4e4596931c

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