ETH Price: $3,119.41 (+0.73%)

Token

Decal by Michael Connolly (DECAL)
 

Overview

Max Total Supply

100 DECAL

Holders

91

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A
Balance
1 DECAL
0xdb20c8a6f4c1e36834a6ebf0699db7d0023d5f5f
Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
xiiixiii_Decal

Compiler Version
v0.8.17+commit.8df45f5f

Optimization Enabled:
Yes with 1 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2023-09-21
*/

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

pragma solidity ^0.8.17;

error TokenIdAlreadySet();

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

  event ArtistMinted(uint256 numberOfTokens, uint256 remainingArtistSupply);

  event TokenHashSet(uint256 indexed tokenId, bytes32 indexed tokenHash);

  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;

  mapping(uint256 => bytes32) public tokenIdToHash;

  constructor(
    string memory _baseUri,
    address[] memory _admins,
    uint256 _artistMaxSupply,
    address _artist
  ) ERC721("Decal by Michael Connolly", "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();
    tokenId = totalSupply;
    totalSupply++;
    minted[msg.sender] = true;
    _storeTokenHash(tokenId);
    _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++) {
      _storeTokenHash(tokenId);
      _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++) {
      _storeTokenHash(tokenId);
      _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 _storeTokenHash(uint256 tokenId) internal {
    if (
      tokenIdToHash[tokenId] !=
      bytes32(
        0x0000000000000000000000000000000000000000000000000000000000000000
      )
    ) revert TokenIdAlreadySet(); // this check might be redundant
    tokenIdToHash[tokenId] = keccak256(
      abi.encodePacked(block.number, tokenId, block.timestamp)
    );
    emit TokenHashSet(tokenId, tokenIdToHash[tokenId]);
  }

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

Contract Security Audit

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"},{"inputs":[],"name":"TokenIdAlreadySet","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":"uint256","name":"tokenId","type":"uint256"},{"indexed":true,"internalType":"bytes32","name":"tokenHash","type":"bytes32"}],"name":"TokenHashSet","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":"","type":"uint256"}],"name":"tokenIdToHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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"}]

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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)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000f92bb2215684c353b4009395061ee7652883c365000000000000000000000000000000000000000000000000000000000000003268747470733a2f2f636c69656e742d6170692e646563612e73797374656d732f646563616c2f6d657461646174612f32362f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a57ec3a618b6969a6b1fec2ef4bf54b2afc5ca30

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

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


Deployed Bytecode Sourcemap

74169:5758:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79191:180;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;79191:180:0;;;;;;;;47824:94;;;:::i;:::-;;;;;;;:::i;75416:262::-;;;;;;:::i;:::-;;:::i;:::-;;49261:171;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;49261:171:0;1533:203:1;48821:382:0;;;;;;:::i;:::-;;:::i;74507:30::-;;;;;;;;;2324:25:1;;;2312:2;2297:18;74507:30:0;2178:177:1;74462:38:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;49955:328;;;;;;:::i;:::-;;:::i;23620:135::-;;;;;;:::i;:::-;;:::i;74591:25::-;;;;;;24039:156;;;;;;:::i;:::-;;:::i;74544:40::-;;74581:3;74544:40;;25143:229;;;;;;:::i;:::-;;:::i;50346:165::-;;;;;;:::i;:::-;;:::i;74694:21::-;;;;;-1:-1:-1;;;;;74694:21:0;;;78694:433;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;74750:48::-;;;;;;:::i;:::-;;;;;;;;;;;;;;47546:219;;;;;;:::i;:::-;;:::i;47285:207::-;;;;;;:::i;:::-;;:::i;29085:97::-;;;:::i;74623:30::-;;;;;;75684:129;;;;;;:::i;:::-;;:::i;74660:27::-;;;;;;28473:81;;;:::i;22244:156::-;;;;;;:::i;:::-;;:::i;47979:98::-;;;:::i;74722:21::-;;;:::i;76628:711::-;;;;;;:::i;:::-;;:::i;75819:129::-;;;;;;:::i;:::-;;:::i;21379:49::-;;21424:4;21379:49;;49496:164;;;;;;:::i;:::-;;:::i;78070:142::-;;;:::i;75954:668::-;;;;;;:::i;:::-;;:::i;50574:315::-;;;;;;:::i;:::-;;:::i;77345:719::-;;;;;;:::i;:::-;;:::i;78218:115::-;;;:::i;78339:349::-;;;;;;:::i;:::-;;:::i;75307:103::-;;;;;;:::i;:::-;;:::i;24464:158::-;;;;;;:::i;:::-;;:::i;49723:173::-;;;;;;:::i;:::-;;:::i;29327:191::-;;;;;;:::i;:::-;;:::i;79191:180::-;79309:4;79329:36;79353:11;79329:23;:36::i;:::-;79322:43;79191:180;-1:-1:-1;;79191:180:0:o;47824:94::-;47878:13;47907:5;47900:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47824:94;:::o;75416:262::-;21424:4;21844:16;21424:4;21844:10;:16::i;:::-;75579:11:::1;::::0;75566:24:::1;::::0;74581:3:::1;75566:24;:::i;:::-;75549:12;::::0;75530:31:::1;::::0;:16;:31:::1;:::i;:::-;75529:62;75525:106;;;75607:24;;-1:-1:-1::0;;;75607:24:0::1;;;;;;;;;;;75525:106;-1:-1:-1::0;75638:15:0::1;:34:::0;75416:262::o;49261:171::-;49347:7;49363:23;49378:7;49363:14;:23::i;:::-;-1:-1:-1;49402:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;49402:24:0;;49261:171::o;48821:382::-;48898:13;48914:23;48929:7;48914:14;:23::i;:::-;48898:39;;48958:5;-1:-1:-1;;;;;48952:11:0;:2;-1:-1:-1;;;;;48952:11:0;;48944:57;;;;-1:-1:-1;;;48944:57:0;;8133:2:1;48944: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;;48944:57:0;;;;;;;;;3753:10;-1:-1:-1;;;;;49026:21:0;;;;:62;;-1:-1:-1;49051:37:0;49068:5;3753:10;49723:173;:::i;49051:37::-;49010:157;;;;-1:-1:-1;;;49010:157:0;;8535:2:1;49010: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;;49010:157:0;8333:425:1;49010:157:0;49176:21;49185:2;49189:7;49176:8;:21::i;:::-;48891:312;48821:382;;:::o;49955:328::-;50136:41;3753:10;50169:7;50136:18;:41::i;:::-;50120:120;;;;-1:-1:-1;;;50120:120:0;;;;;;;:::i;:::-;50249:28;50259:4;50265:2;50269:7;50249:9;:28::i;23620:135::-;23704:7;23727:12;;;:6;:12;;;;;:22;;;;23620:135::o;24039:156::-;24137:18;24150:4;24137:12;:18::i;:::-;21844:16;21855:4;21844:10;:16::i;:::-;24164:25:::1;24175:4;24181:7;24164:10;:25::i;25143:229::-:0;-1:-1:-1;;;;;25243:23:0;;3753:10;25243:23;25227:104;;;;-1:-1:-1;;;25227:104:0;;9379:2:1;25227: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;;25227:104:0;9177:411:1;25227:104:0;25340:26;25352:4;25358:7;25340:11;:26::i;:::-;25143:229;;:::o;50346:165::-;50466:39;50483:4;50489:2;50493:7;50466:39;;;;;;;;;;;;:16;:39::i;78694:433::-;78769:16;78794:18;78815:17;78825:6;78815:9;:17::i;:::-;78794:38;;78839:25;78881:10;-1:-1:-1;;;;;78867:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;78867:25:0;;78839:53;;78899:12;78927:9;78922:178;78946:11;;78942:1;:15;78922:178;;;78991:6;-1:-1:-1;;;;;78977:20:0;:10;78985:1;78977:7;:10::i;:::-;-1:-1:-1;;;;;78977:20:0;;78973:82;;79027:1;79010:8;79019:4;79010:14;;;;;;;;:::i;:::-;;;;;;;;;;:18;79039:6;;;;:::i;:::-;;;;78973:82;79063:29;;;79087:5;79063:29;78959:3;;;;:::i;:::-;;;;78922:178;;;-1:-1:-1;79113:8:0;;78694:433;-1:-1:-1;;;;78694:433:0:o;47546:219::-;47628:7;47644:13;47660:17;47669:7;47660:8;:17::i;:::-;47644:33;-1:-1:-1;;;;;;47692:19:0;;47684:56;;;;-1:-1:-1;;;47684:56:0;;;;;;;:::i;47285:207::-;47367:7;-1:-1:-1;;;;;47391:19:0;;47383:73;;;;-1:-1:-1;;;47383:73:0;;10420:2:1;47383: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;;47383:73:0;10218:405:1;47383:73:0;-1:-1:-1;;;;;;47470:16:0;;;;;:9;:16;;;;;;;47285:207::o;29085:97::-;28373:13;:11;:13::i;:::-;29146:30:::1;29173:1;29146:18;:30::i;:::-;29085:97::o:0;75684:129::-;21424:4;21844:16;21424:4;21844:10;:16::i;:::-;-1:-1:-1;75783:10:0::1;:24:::0;75684:129::o;28473:81::-;28542:6;;-1:-1:-1;;;;;28542:6:0;;28473:81::o;22244:156::-;22345:4;22365:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;22365:29:0;;;;;;;;;;;;;;;22244:156::o;47979:98::-;48035:13;48064:7;48057:14;;;;;:::i;74722:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;76628:711::-;64100:21;:19;:21::i;:::-;21424:4:::1;21844:16;21424:4:::0;21844:10:::1;:16::i;:::-;76753:15:::2;76772:1;76753:20:::0;76749:49:::2;;76782:16;;-1:-1:-1::0;;;76782:16:0::2;;;;;;;;;;;76749:49;76809:6;::::0;-1:-1:-1;;;;;76809:6:0::2;76805:43;;76838:10;;-1:-1:-1::0;;;76838:10:0::2;;;;;;;;;;;76805:43;76855:17;76893:12;;76875:15;;:30;;;;:::i;:::-;76855:50;;76916:9;76929:1;76916:14:::0;76912:51:::2;;76939:24;;-1:-1:-1::0;;;76939:24:0::2;;;;;;;;;;;76912:51;76996:36;77005:15;77022:9;76996:8;:36::i;:::-;77058:11;::::0;76970:63;;-1:-1:-1;77040:15:0::2;77076:140;77100:15;77096:1;:19;77076:140;;;77131:24;77147:7;77131:15;:24::i;:::-;77174:6;::::0;77164:26:::2;::::0;-1:-1:-1;;;;;77174:6:0::2;77182:7:::0;77164:9:::2;:26::i;:::-;77199:9:::0;::::2;::::0;::::2;:::i;:::-;;;;77117:3;;;;;:::i;:::-;;;;77076:140;;;;77238:15;77222:12;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;77260:11:0::2;:21:::0;;;77293:40:::2;::::0;;10932:25:1;;;10988:2;10973:18;;10966:34;;;-1:-1:-1;;;;;;;;;;;77293:40:0;10905:18:1;77293:40:0::2;;;;;;;76742:597;;64128:1:::1;64136:20:::0;63570:1;64620:7;:22;64449:199;64136:20;76628:711;:::o;75819:129::-;21424:4;21844:16;21424:4;21844:10;:16::i;:::-;75921:7:::1;:21;75931:11:::0;75921:7;:21:::1;:::i;49496:164::-:0;49602:52;3753:10;49635:8;49645;49602:18;:52::i;78070:142::-;78124:7;78193:12;;78175:15;;:30;;;;:::i;:::-;78160:11;;78147:24;;74581:3;78147:24;:::i;:::-;:59;;;;:::i;:::-;78140:66;;78070:142;:::o;75954:668::-;76042:15;64100:21;:19;:21::i;:::-;76077:10:::1;76070:18;::::0;;;:6:::1;:18;::::0;;;;;::::1;;76066:46;;;76097:15;;-1:-1:-1::0;;;76097:15:0::1;;;;;;;;;;;76066:46;74581:3;76123:11;;:25;76119:56;;76157:18;;-1:-1:-1::0;;;76157:18:0::1;;;;;;;;;;;76119:56;76212:1;76186:23;:21;:23::i;:::-;:27;76182:64;;;76222:24;;-1:-1:-1::0;;;76222:24:0::1;;;;;;;;;;;76182:64;76257:23;:10;:21;:23::i;:::-;76253:60;;;76289:24;;-1:-1:-1::0;;;76289:24:0::1;;;;;;;;;;;76253:60;76345:28;::::0;-1:-1:-1;;;;;;76362:10:0::1;13389:2:1::0;13360:15;13356:45;76345:28:0::1;::::0;::::1;13344:58:1::0;76320:12:0::1;::::0;13418::1;;76345:28:0::1;;;;;;;;;;;;76335:39;;;;;;76320:54;;76386:50;76405:12;;76386:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;76419:10:0::1;::::0;;-1:-1:-1;76431:4:0;;-1:-1:-1;76386:18:0::1;:50::i;:::-;76381:87;;76452:16;;-1:-1:-1::0;;;76452:16:0::1;;;;;;;;;;;76381:87;76485:11;::::0;;;-1:-1:-1;76485:11:0;;76503::::1;:13;76485:11:::0;76503:13:::1;:::i;:::-;::::0;;;-1:-1:-1;;76530:10:0::1;76523:18;::::0;;;:6:::1;:18;::::0;;;;:25;;-1:-1:-1;;76523:25:0::1;76544:4;76523:25;::::0;;76555:24:::1;76571:7:::0;76555:15:::1;:24::i;:::-;76586:30;76596:10;76608:7;76586:9;:30::i;:::-;76059:563;64136:20:::0;63570:1;64620:7;:22;64449:199;50574:315;50734:41;3753:10;50767:7;50734:18;:41::i;:::-;50718:120;;;;-1:-1:-1;;;50718:120:0;;;;;;;:::i;:::-;50845:38;50859:4;50865:2;50869:7;50878:4;50845:13;:38::i;:::-;50574:315;;;;:::o;77345:719::-;64100:21;:19;:21::i;:::-;77423:15:::1;77442:1;77423:20:::0;77419:49:::1;;77452:16;;-1:-1:-1::0;;;77452:16:0::1;;;;;;;;;;;77419:49;77479:6;::::0;-1:-1:-1;;;;;77479:6:0::1;77475:43;;77508:10;;-1:-1:-1::0;;;77508:10:0::1;;;;;;;;;;;77475:43;77543:6;::::0;-1:-1:-1;;;;;77543:6:0::1;77529:10;:20;77525:44;;77558:11;;-1:-1:-1::0;;;77558:11:0::1;;;;;;;;;;;77525:44;77576:17;77614:12;;77596:15;;:30;;;;:::i;:::-;77576:50;;77637:9;77650:1;77637:14:::0;77633:51:::1;;77660:24;;-1:-1:-1::0;;;77660:24:0::1;;;;;;;;;;;77633:51;77717:36;77726:15;77743:9;77717:8;:36::i;:::-;77779:11;::::0;77691:63;;-1:-1:-1;77761:15:0::1;77797:144;77821:15;77817:1;:19;77797:144;;;77852:24;77868:7;77852:15;:24::i;:::-;77885:30;77895:10;77907:7;77885:9;:30::i;:::-;77924:9:::0;::::1;::::0;::::1;:::i;:::-;;;;77838:3;;;;;:::i;:::-;;;;77797:144;;;;77963:15;77947:12;;:31;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;77985:11:0::1;:21:::0;;;78018:40:::1;::::0;;10932:25:1;;;10988:2;10973:18;;10966:34;;;-1:-1:-1;;;;;;;;;;;78018:40:0;10905:18:1;78018:40:0::1;;;;;;;77412:652;;64136:20:::0;63570:1;64620:7;:22;64449:199;78218:115;78274:7;78315:12;;78297:15;;:30;;;;:::i;78339:349::-;78423:13;78453:17;78461:8;78453:7;:17::i;:::-;78445:68;;;;-1:-1:-1;;;78445:68:0;;13643:2:1;78445: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;;78445:68:0;13441:402:1;78445:68:0;78520:21;78544:10;:8;:10::i;:::-;78520:34;;78593:1;78575:7;78569:21;:25;78561:53;;;;-1:-1:-1;;;78561:53:0;;14050:2:1;78561:53:0;;;14032:21:1;14089:2;14069:18;;;14062:30;-1:-1:-1;;;14108:18:1;;;14101:45;14163:18;;78561:53:0;13848:339:1;78561:53:0;78652:7;78661:19;:8;:17;:19::i;:::-;78635:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78621:61;;;78339:349;;;:::o;75307:103::-;21424:4;21844:16;21424:4;21844:10;:16::i;:::-;-1:-1:-1;75388:6:0::1;:16:::0;;-1:-1:-1;;;;;;75388:16:0::1;-1:-1:-1::0;;;;;75388:16:0;;;::::1;::::0;;;::::1;::::0;;75307:103::o;24464:158::-;24563:18;24576:4;24563:12;:18::i;:::-;21844:16;21855:4;21844:10;:16::i;:::-;24590:26:::1;24602:4;24608:7;24590:11;:26::i;49723:173::-:0;-1:-1:-1;;;;;49855:25:0;;;49835:4;49855:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;49723:173::o;29327:191::-;28373:13;:11;:13::i;:::-;-1:-1:-1;;;;;29412:22:0;::::1;29404:73;;;::::0;-1:-1:-1;;;29404:73:0;;14895:2:1;29404: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;;29404:73:0::1;14693:402:1::0;29404:73:0::1;29484:28;29503:8;29484:18;:28::i;21938:222::-:0;22033:4;-1:-1:-1;;;;;;22060:47:0;;-1:-1:-1;;;22060:47:0;;:94;;;22118:36;22142:11;22118:23;:36::i;22686:99::-;22749:30;22760:4;3753:10;22749;:30::i;58522:129::-;58600:16;58608:7;58600;:16::i;:::-;58592:53;;;;-1:-1:-1;;;58592:53:0;;;;;;;:::i;57859:164::-;57930:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;57930:29:0;-1:-1:-1;;;;;57930:29:0;;;;;;;;:24;;57980:23;57930:24;57980:14;:23::i;:::-;-1:-1:-1;;;;;57971:46:0;;;;;;;;;;;57859:164;;:::o;52823:283::-;52931:4;52944:13;52960:23;52975:7;52960:14;:23::i;:::-;52944:39;;53009:5;-1:-1:-1;;;;;52998:16:0;:7;-1:-1:-1;;;;;52998:16:0;;:59;;;;53025:32;53042:5;53049:7;53025:16;:32::i;:::-;52998:101;;;;53092:7;-1:-1:-1;;;;;53068:31:0;:20;53080:7;53068:11;:20::i;:::-;-1:-1:-1;;;;;53068:31:0;;52998:101;52990:110;52823:283;-1:-1:-1;;;;52823:283:0:o;56553:1199::-;56702:4;-1:-1:-1;;;;;56675:31:0;:23;56690:7;56675:14;:23::i;:::-;-1:-1:-1;;;;;56675:31:0;;56659:102;;;;-1:-1:-1;;;56659:102:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;56776:16:0;;56768:65;;;;-1:-1:-1;;;56768:65:0;;15708:2:1;56768: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;;56768:65:0;15506:400:1;56768:65:0;56842:42;56863:4;56869:2;56873:7;56882:1;56842:20;:42::i;:::-;57014:4;-1:-1:-1;;;;;56987:31:0;:23;57002:7;56987:14;:23::i;:::-;-1:-1:-1;;;;;56987:31:0;;56971:102;;;;-1:-1:-1;;;56971:102:0;;;;;;;:::i;:::-;57137:24;;;;:15;:24;;;;;;;;57130:31;;-1:-1:-1;;;;;;57130:31:0;;;;;;-1:-1:-1;;;;;57573:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;57573:20:0;;;57602:13;;;;;;;;;:18;;57130:31;57602:18;;;57634:16;;;:7;:16;;;;;;:21;;;;;;;;;;57669:27;;57153:7;;-1:-1:-1;;;;;;;;;;;57669:27:0;;48891:312;48821:382;;:::o;26661:216::-;26741:22;26749:4;26755:7;26741;:22::i;:::-;26736:136;;26774:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;26774:29:0;;;;;;;;;:36;;-1:-1:-1;;26774:36:0;26806:4;26774:36;;;26851:12;3753:10;;3677:92;26851:12;-1:-1:-1;;;;;26824:40:0;26842:7;-1:-1:-1;;;;;26824:40:0;26836:4;26824:40;;;;;;;;;;26661:216;;:::o;27041:217::-;27121:22;27129:4;27135:7;27121;:22::i;:::-;27117:136;;;27186:5;27154:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;27154:29:0;;;;;;;;;;:37;;-1:-1:-1;;27154:37:0;;;27205:40;3753:10;;27154:12;;27205:40;;27186:5;27205:40;27041:217;;:::o;52144:111::-;52210:7;52233:16;;;:7;:16;;;;;;-1:-1:-1;;;;;52233:16:0;;52144:111::o;28624:126::-;3753:10;28684:7;:5;:7::i;:::-;-1:-1:-1;;;;;28684:23:0;;28676:68;;;;-1:-1:-1;;;28676:68:0;;16113:2:1;28676:68:0;;;16095:21:1;;;16132:18;;;16125:30;16191:34;16171:18;;;16164:62;16243:18;;28676:68:0;15911:356:1;29668:177:0;29757:6;;;-1:-1:-1;;;;;29770:17:0;;;-1:-1:-1;;;;;;29770:17:0;;;;;;;29799:40;;29757:6;;;29770:17;29757:6;;29799:40;;29738:16;;29799:40;29731:114;29668:177;:::o;64168:275::-;63612:1;64294:7;;:19;64286:63;;;;-1:-1:-1;;;64286:63:0;;16474:2:1;64286:63:0;;;16456:21:1;16513:2;16493:18;;;16486:30;16552:33;16532:18;;;16525:61;16603:18;;64286:63:0;16272:355:1;64286:63:0;63612:1;64419:7;:18;64168:275::o;6411:100::-;6469:7;6496:1;6492;:5;:13;;6504:1;6492:13;;;6500:1;6492:13;6485:20;6411:100;-1:-1:-1;;;6411:100:0:o;79377:439::-;79498:66;79447:22;;;:13;:22;;;;;;:126;79435:172;;79588:19;;-1:-1:-1;;;79588:19:0;;;;;;;;;;;79435:172;79690:56;;;79707:12;79690:56;;;16817:19:1;16852:12;;;16845:28;;;79730:15:0;16889:12:1;;;16882:28;16926:12;;79690:56:0;;;-1:-1:-1;;79690:56:0;;;;;;;;;79672:81;;79690:56;79672:81;;;;79647:22;;;;:13;:22;;;;;;:106;;;79672:81;;79661:7;;79765:45;;;79377:439;:::o;53426:104::-;53498:26;53508:2;53512:7;53498:26;;;;;;;;;;;;:9;:26::i;58154:287::-;58291:8;-1:-1:-1;;;;;58282:17:0;:5;-1:-1:-1;;;;;58282:17:0;;58274:55;;;;-1:-1:-1;;;58274:55:0;;17151:2:1;58274:55:0;;;17133:21:1;17190:2;17170:18;;;17163:30;-1:-1:-1;;;17209:18:1;;;17202:55;17274:18;;58274:55:0;16949:349:1;58274:55:0;-1:-1:-1;;;;;58336:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;58336:46:0;;;;;;;;;;58394:41;;540::1;;;58394::0;;513:18:1;58394:41:0;;;;;;;58154:287;;;:::o;37732:308::-;-1:-1:-1;;;;;38011:19:0;;:23;;;37732:308::o;65867:170::-;65978:4;66027;65998:25;66011:5;66018:4;65998:12;:25::i;:::-;:33;;65867:170;-1:-1:-1;;;;65867:170:0:o;51732:306::-;51866:28;51876:4;51882:2;51886:7;51866:9;:28::i;:::-;51917:47;51940:4;51946:2;51950:7;51959:4;51917:22;:47::i;:::-;51901:131;;;;-1:-1:-1;;;51901:131:0;;;;;;;:::i;52550:122::-;52615:4;;52635:17;52644:7;52635:8;:17::i;:::-;-1:-1:-1;;;;;52635:31:0;;;;52550:122;-1:-1:-1;;52550:122:0:o;79822:102::-;79882:13;79911:7;79904:14;;;;;:::i;17730:586::-;17786:13;17827:14;17844:17;17855:5;17844:10;:17::i;:::-;17864:1;17844:21;17827:38;;17874:20;17908:6;-1:-1:-1;;;;;17897:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17897:18:0;-1:-1:-1;17874:41:0;-1:-1:-1;18013:28:0;;;18029:2;18013:28;18058:224;-1:-1:-1;;18082:5:0;-1:-1:-1;;;18193:2:0;18182:14;;18177:30;18082:5;18164:44;18238:2;18229:11;;;-1:-1:-1;18251:21:0;18058:224;18251:21;-1:-1:-1;18297:6:0;17730:586;-1:-1:-1;;;17730:586:0:o;46938:291::-;47050:4;-1:-1:-1;;;;;;47077:40:0;;-1:-1:-1;;;47077:40:0;;:99;;-1:-1:-1;;;;;;;47128:48:0;;-1:-1:-1;;;47128:48:0;47077:99;:146;;;-1:-1:-1;;;;;;;;;;5754:40:0;;;47187:36;5639:161;23059:386;23144:22;23152:4;23158:7;23144;:22::i;:::-;23139:301;;23284:28;23304:7;23284:19;:28::i;:::-;23361:38;23389:4;23396:2;23361:19;:38::i;:::-;23213:199;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;23213:199:0;;;;;;;;;;-1:-1:-1;;;23177:255:0;;;;;;;:::i;60624:342::-;60792:1;60780:9;:13;60776:185;;;-1:-1:-1;;;;;60808:18:0;;;60804:73;;-1:-1:-1;;;;;60839:15:0;;;;;;:9;:15;;;;;:28;;60858:9;;60839:15;:28;;60858:9;;60839:28;:::i;:::-;;;;-1:-1:-1;;60804:73:0;-1:-1:-1;;;;;60889:16:0;;;60885:69;;-1:-1:-1;;;;;60918:13:0;;;;;;:9;:13;;;;;:26;;60935:9;;60918:13;:26;;60935:9;;60918:26;:::i;:::-;;;;-1:-1:-1;;60624:342:0;;;;:::o;53747:279::-;53858:18;53864:2;53868:7;53858:5;:18::i;:::-;53899:53;53930:1;53934:2;53938:7;53947:4;53899:22;:53::i;:::-;53883:137;;;;-1:-1:-1;;;53883:137:0;;;;;;;:::i;66664:287::-;66762:7;66801:4;66762:7;66812:108;66836:5;:12;66832:1;:16;66812:108;;;66879:33;66889:12;66903:5;66909:1;66903:8;;;;;;;;:::i;:::-;;;;;;;66879:9;:33::i;:::-;66864:48;-1:-1:-1;66850:3:0;;;;:::i;:::-;;;;66812:108;;;-1:-1:-1;66933:12:0;66664:287;-1:-1:-1;;;66664:287:0:o;59193:729::-;59329:4;59346:15;:2;-1:-1:-1;;;;;59346:13:0;;:15::i;:::-;59342:575;;;59385:71;;-1:-1:-1;;;59385:71:0;;-1:-1:-1;;;;;59385:36:0;;;;;:71;;3753:10;;59436:4;;59442:7;;59451:4;;59385:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59385:71:0;;;;;;;;-1:-1:-1;;59385:71:0;;;;;;;;;;;;:::i;:::-;;;59372:504;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59611:6;:13;59628:1;59611:18;59607:260;;59644:60;;-1:-1:-1;;;59644:60:0;;;;;;;:::i;59607:260::-;59835:6;59829:13;59820:6;59816:2;59812:15;59805:38;59372:504;-1:-1:-1;;;;;;59506:51:0;-1:-1:-1;;;59506:51:0;;-1:-1:-1;59499:58:0;;59342:575;-1:-1:-1;59905:4:0;59193:729;;;;;;:::o;14973:742::-;15026:7;;-1:-1:-1;;;15090:17:0;;15086:84;;-1:-1:-1;;;15120:17:0;;;-1:-1:-1;15158:2:0;15148:12;15086:84;-1:-1:-1;;;15182:5:0;:17;15178:84;;-1:-1:-1;;;15212:17:0;;;-1:-1:-1;15250:2:0;15240:12;15178:84;15283:8;15274:5;:17;15270:84;;15313:8;15304:17;;;-1:-1:-1;15342:2:0;15332:12;15270:84;15375:7;15366:5;:16;15362:81;;15404:7;15395:16;;;-1:-1:-1;15432:1:0;15422:11;15362:81;15464:7;15455:5;:16;15451:81;;15493:7;15484:16;;;-1:-1:-1;15521:1:0;15511:11;15451:81;15553:7;15544:5;:16;15540:81;;15582:7;15573:16;;;-1:-1:-1;15610:1:0;15600:11;15540:81;15642:7;15633:5;:16;15629:54;;15672:1;15662:11;15703:6;14973:742;-1:-1:-1;;14973:742:0:o;19269:145::-;19327:13;19356:52;-1:-1:-1;;;;;19368:22:0;;17629:2;18700:420;18790:13;18812:19;18844:10;18848:6;18844:1;:10;:::i;:::-;:14;;18857:1;18844:14;:::i;:::-;-1:-1:-1;;;;;18834:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18834:25:0;;18812:47;;-1:-1:-1;;;18866:6:0;18873:1;18866:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;18866:15:0;;;;;;;;;-1:-1:-1;;;18888:6:0;18895:1;18888:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;18888:15:0;;;;;;;;-1:-1:-1;18915:9:0;18927:10;18931:6;18927:1;:10;:::i;:::-;:14;;18940:1;18927:14;:::i;:::-;18915:26;;18910:115;18947:1;18943;:5;18910:115;;;-1:-1:-1;;;18985:5:0;18993:3;18985:11;18976:21;;;;;;;:::i;:::-;;;;18964:6;18971:1;18964:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;18964:33:0;;;;;;;;-1:-1:-1;19016:1:0;19006:11;;;;;18950:3;;;:::i;:::-;;;18910:115;;;-1:-1:-1;19039:10:0;;19031:55;;;;-1:-1:-1;;;19031:55:0;;19935:2:1;19031:55:0;;;19917:21:1;;;19954:18;;;19947:30;20013:34;19993:18;;;19986:62;20065:18;;19031:55:0;19733:356:1;54336:870:0;-1:-1:-1;;;;;54412:16:0;;54404:61;;;;-1:-1:-1;;;54404:61:0;;20296:2:1;54404:61:0;;;20278:21:1;;;20315:18;;;20308:30;20374:34;20354:18;;;20347:62;20426:18;;54404:61:0;20094:356:1;54404:61:0;54481:16;54489:7;54481;:16::i;:::-;54480:17;54472:58;;;;-1:-1:-1;;;54472:58:0;;;;;;;:::i;:::-;54539:48;54568:1;54572:2;54576:7;54585:1;54539:20;:48::i;:::-;54678:16;54686:7;54678;:16::i;:::-;54677:17;54669:58;;;;-1:-1:-1;;;54669:58:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;55042:13:0;;;;;;:9;:13;;;;;;;;:18;;55059:1;55042:18;;;55076:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;55076:21:0;;;;;55111:33;55084:7;;55042:13;;-1:-1:-1;;;;;;;;;;;55111:33:0;55042:13;;55111:33;25143:229;;:::o;73322:143::-;73385:7;73412:1;73408;:5;:51;;73554:13;73634:15;;;73664:4;73657:15;;;73705:4;73689:21;;73408:51;;;73554:13;73634:15;;;73664:4;73657:15;;;73705:4;73689:21;;73416:20;73471: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;17303:414::-;17505:2;17487:21;;;17544:2;17524:18;;;17517:30;17583:34;17578:2;17563:18;;17556:62;-1:-1:-1;;;17649:2:1;17634:18;;17627:48;17707:3;17692:19;;17303:414::o;17854:812::-;-1:-1:-1;;;18260:3:1;18253:38;18235:3;18320:6;18314:13;18336:75;18404:6;18399:2;18394:3;18390:12;18383:4;18375:6;18371:17;18336:75;:::i;:::-;-1:-1:-1;;;18470:2:1;18430:16;;;18462:11;;;18455:40;18520:13;;18542:76;18520:13;18604:2;18596:11;;18589:4;18577:17;;18542:76;:::i;:::-;18638:17;18657:2;18634:26;;17854:812;-1:-1:-1;;;;17854:812:1:o;18671:489::-;-1:-1:-1;;;;;18940:15:1;;;18922:34;;18992:15;;18987:2;18972:18;;18965:43;19039:2;19024:18;;19017:34;;;19087:3;19082:2;19067:18;;19060:31;;;18865:4;;19108:46;;19134:19;;19126:6;19108:46;:::i;:::-;19100:54;18671:489;-1:-1:-1;;;;;;18671:489:1:o;19165:249::-;19234:6;19287:2;19275:9;19266:7;19262:23;19258:32;19255:52;;;19303:1;19300;19293:12;19255:52;19335:9;19329:16;19354:30;19378:5;19354:30;:::i;19419:168::-;19492:9;;;19523;;19540:15;;;19534:22;;19520:37;19510:71;;19561:18;;:::i;19592:136::-;19631:3;19659:5;19649:39;;19668:18;;:::i;:::-;-1:-1:-1;;;19704:18:1;;19592:136::o;20455:352::-;20657:2;20639:21;;;20696:2;20676:18;;;20669:30;-1:-1:-1;;;20730:2:1;20715:18;;20708:58;20798:2;20783:18;;20455:352::o

Swarm Source

ipfs://c6b9d2da97314c8bdb10c6ce747d698cb535605bb8203542dd6624df87340310
Loading...
Loading
Loading...
Loading
[ Download: CSV Export  ]
[ Download: CSV Export  ]

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.