Token

French Riviera Collection by Daniel Angeli (FRC-DA)

ERC-721

Overview

Max Total Supply

132 FRC-DA

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x3b149ad7934ac69b516f0289e88007b01c028293

Filtered by Token Holder

0xEa4AC3B51e75ff58de93d3ed6531D45C28a4C6C7

luckyjoe.eth

Balance

2 FRC-DA

0xEa4AC3B51e75ff58de93d3ed6531D45C28a4C6C7

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

NonFungibleToken

Compiler Version

v0.8.4+commit.c7e474f2

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-05-25
*/

// Sources flattened with hardhat v2.9.2 https://hardhat.org

// File contracts/dependencies/Context.sol

/**
 * @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 contracts/dependencies/EnumerableSet.sol

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256`
 * (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}


// File contracts/dependencies/Address.sol

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
   * @dev Returns whether the target address is a contract.
   * @param _addr Address to check.
   * @return addressCheck True if _addr is a contract, false if not.
   */
  function isContract(address _addr) internal view returns (bool addressCheck)
  {
    // This method relies in extcodesize, which returns 0 for contracts in
    // construction, since the code is only stored at the end of the
    // constructor execution.

    // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
    // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
    // for accounts without code, i.e. `keccak256('')`
    bytes32 codehash;
    bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
    assembly { codehash := extcodehash(_addr) } // solhint-disable-line
    addressCheck = (codehash != 0x0 && codehash != accountHash);
  }

    /**
     * @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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File contracts/dependencies/AccessControl.sol

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms.
 *
 * 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 {
    using EnumerableSet for EnumerableSet.AddressSet;
    using Address for address;

    struct RoleData {
        EnumerableSet.AddressSet members;
        bytes32 adminRole;
    }

    mapping (bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @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 {_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) public view returns (bool) {
        return _roles[role].members.contains(account);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view returns (uint256) {
        return _roles[role].members.length();
    }

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view returns (address) {
        return _roles[role].members.at(index);
    }

    /**
     * @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 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.
     */
    function grantRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");

        _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.
     */
    function revokeRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");

        _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 granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual {
        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.
     *
     * [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}.
     * ====
     */
    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 {
        emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
        _roles[role].adminRole = adminRole;
    }

    function _grantRole(bytes32 role, address account) private {
        if (_roles[role].members.add(account)) {
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (_roles[role].members.remove(account)) {
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}


// File contracts/dependencies/IERC165.sol

/**
 * @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);
    /*
     function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
    */
}


// File contracts/dependencies/ERC165.sol

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor ()  {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}


// File contracts/dependencies/IERC721.sol

/**
 * @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`, 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 be 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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * 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 Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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


// File contracts/dependencies/IERC721Metadata.sol

/**
 * @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 contracts/dependencies/IERC721Receiver.sol

/**
 * @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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


// File contracts/dependencies/Strings.sol

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @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] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}


// File contracts/dependencies/ERC721A.sol

error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;
    mapping (address => bool) public whitelists;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Base URI
    string private _baseURI;
    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }
    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a prefix in {tokenURI} to each token's URI, or
    * to the token ID if no specific URI is set for that token ID.
    */
    function baseURI() public view returns (string memory) {
        return _baseURI;
    }
    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

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

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 1;
    }

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @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 override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return _ownershipOf(tokenId).addr;
    }

    /**
     * @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) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        string memory base_URI = baseURI();
        return string(abi.encodePacked(_baseURI, tokenId.toString(), ".json"));
    }


    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

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

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_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 {
        _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 {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @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`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _startTokenId() <= tokenId && tokenId < _currentIndex &&
            !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (safe && to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex != end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex != end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * 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
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, from);

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = to;
            currSlot.startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev This is equivalent to _burn(tokenId, false)
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
                isApprovedForAll(from, _msgSender()) ||
                getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, from);

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            AddressData storage addressData = _addressData[from];
            addressData.balance -= 1;
            addressData.numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = from;
            currSlot.startTimestamp = uint64(block.timestamp);
            currSlot.burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(
        address to,
        uint256 tokenId,
        address owner
    ) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}


// File contracts/dependencies/Pausable.sol

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

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

    bool private _paused;

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

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

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

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

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

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


// File contracts/dependencies/ERC721Pausable.sol

/**
 * @dev ERC721 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract ERC721Pausable is ERC721A, Pausable {
    /**
     * @dev See {ERC721-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        require(!paused(), "ERC721Pausable: token transfer while paused");
    }
}


// File contracts/dependencies/SafeMath.sol

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}


// File contracts/erc721/nft.sol

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







/**
 * @dev {ERC721} token, including:
 *
 *  - ability for holders to burn (destroy) their tokens
 *  - a minter role that allows for token minting (creation)
 *  - a pauser role that allows to stop all token transfers
 *  - token ID and URI autogeneration
 *
 * This contract uses {AccessControl} to lock permissioned functions using the
 * different roles - head to its documentation for details.
 *
 * The account that deploys the contract will be granted the minter and pauser
 * roles, as well as the default admin role, which will let it grant both minter
 * and pauser roles to other accounts.
 */

contract NonFungibleToken is Context, AccessControl, ERC721A, ERC721Pausable {

    using SafeMath for uint256;
    using Address for address;

    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    address public owner;

    bool public whitelistingEnabled = false;
    bool public mintingEnabled = true;
    bool public freezeMetadata = false;

    uint256 private _maxPerWallet = 2;
    uint256 public numberOfWhitelisted;


    // uint256 private _revealsCount = 0;

    /**
     * @dev Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE` and `PAUSER_ROLE` to the
     * account that deploys the contract.
     *
     * Token URIs will be autogenerated based on `baseURI` and their token IDs.
     * See {ERC721-tokenURI}.
     */
    constructor(string memory name, string memory symbol, string memory _baseURI, uint256 maxPerWallet) public ERC721A(name, symbol)  {
        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());

        _setupRole(MINTER_ROLE, _msgSender());
        _setupRole(PAUSER_ROLE, _msgSender());

        _setBaseURI(_baseURI);
        _maxPerWallet = maxPerWallet;
        owner = msg.sender;
    }


    function getMaxPerWallet() public view returns (uint256) {
        return _maxPerWallet;
    }

    function setMaxPerWallet(uint256 maxPerWallet) public virtual {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "NonFungibleToken: must have DEFAULT_ADMIN_ROLE");
        _maxPerWallet = maxPerWallet;
    }

    function setFreezeMetadata() public virtual {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "NonFungibleToken: must have DEFAULT_ADMIN_ROLE");
        require(! freezeMetadata, "NonFungibleToken: already frozen !");

        freezeMetadata = true;
    }

    function setURI(string memory _baseURI) public virtual {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "NonFungibleToken: must have admin role");
        require(! freezeMetadata, "Metadata frozen !");
        _setBaseURI(_baseURI);

    }

    function setOwner(address _owner) public virtual {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "NonFungibleToken: must have admin role");
        _setupRole(DEFAULT_ADMIN_ROLE, _owner);
        _setupRole(MINTER_ROLE, _owner);
        owner = _owner;
    }

    function toggleMinting(bool _bool) public virtual {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "NonFungibleToken: must have admin role to mint");
        mintingEnabled = _bool;

    }

    function toggleWhitelisting(bool _toggle) public virtual {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "NonFungibleToken: must have admin role");
        whitelistingEnabled = _toggle;

    }

    function whitelist(address[] memory _beneficiaries) external {
      require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "NonFungibleToken: must have admin role");
      for (uint256 i = 0; i < _beneficiaries.length; i++) {
        if (! whitelists[_beneficiaries[i]]){
            numberOfWhitelisted = numberOfWhitelisted + 1;
        }
        whitelists[_beneficiaries[i]] = true;
      }
    }

    function removeFromWhitelist(address[] memory _beneficiaries) external {
      require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "NonFungibleToken: must have admin role");
      for (uint256 i = 0; i < _beneficiaries.length; i++) {

        if (whitelists[_beneficiaries[i]]){
            numberOfWhitelisted = numberOfWhitelisted.sub(1);
        }
        whitelists[_beneficiaries[i]] = false;
      }
    }

    function contractURI() public view returns (string memory) {
        return string(abi.encodePacked(baseURI(), "contract-metadata.json"));
    }

    /**
     * @dev Creates a new token for `to`. Its token ID will be automatically
     * assigned (and available on the emitted {IERC721-Transfer} event), and the token
     * URI autogenerated based on the base URI passed at construction.
     *
     * See {ERC721-_mint}.
     *
     * Requirements:
     *
     * - the caller must have the `MINTER_ROLE`.
     */
    function mint(address to) public virtual {
        require(hasRole(MINTER_ROLE, _msgSender()), "NonFungibleToken: must have minter role to mint");
        require(whitelists[to] || ! whitelistingEnabled, "User not whitelisted !");

        require(mintingEnabled, "Minting not enabled !");
        // We cannot just use balanceOf to create the new tokenId because tokens
        // can be burned (destroyed), so we need a separate counter.
        _safeMint(to, 1);
        require(balanceOf(to) <= getMaxPerWallet(), "Max NFTs reached by wallet");
    }

    function mint(address to, uint256 quantity) public virtual {
        require(hasRole(MINTER_ROLE, _msgSender()), "NonFungibleToken: must have minter role to mint");
        require(whitelists[to] || ! whitelistingEnabled, "User not whitelisted !");

        require(mintingEnabled, "Minting not enabled !");
        // We cannot just use balanceOf to create the new tokenId because tokens
        // can be burned (destroyed), so we need a separate counter.
        _safeMint(to, quantity);
        require(balanceOf(to) <= getMaxPerWallet(), "Max NFTs reached by wallet");
    }
    function batchMint(address[] memory _beneficiaries) external {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "NonFungibleToken: must have admin role");
        for (uint256 i = 0; i < _beneficiaries.length; i++) {
          mint(_beneficiaries[i]);
        }
    }
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721A, ERC721Pausable) {
        super._beforeTokenTransfer(from, to, tokenId);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"_baseURI","type":"string"},{"internalType":"uint256","name":"maxPerWallet","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","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":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":[{"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":"address[]","name":"_beneficiaries","type":"address[]"}],"name":"batchMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freezeMetadata","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","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":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintingEnabled","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":"numberOfWhitelisted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_beneficiaries","type":"address[]"}],"name":"removeFromWhitelist","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":[],"name":"setFreezeMetadata","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"maxPerWallet","type":"uint256"}],"name":"setMaxPerWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"setURI","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":"bool","name":"_bool","type":"bool"}],"name":"toggleMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_toggle","type":"bool"}],"name":"toggleWhitelisting","outputs":[],"stateMutability":"nonpayable","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":"_beneficiaries","type":"address[]"}],"name":"whitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"whitelistingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002a4672656e6368205269766965726120436f6c6c656374696f6e2062792044616e69656c20416e67656c690000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064652432d4441000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000046261736500000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): French Riviera Collection by Daniel Angeli
Arg [1] : symbol (string): FRC-DA
Arg [2] : _baseURI (string): base
Arg [3] : maxPerWallet (uint256): 1

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [4] : 000000000000000000000000000000000000000000000000000000000000002a
Arg [5] : 4672656e6368205269766965726120436f6c6c656374696f6e2062792044616e
Arg [6] : 69656c20416e67656c6900000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [8] : 4652432d44410000000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [10] : 6261736500000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

71498:5852:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44848:305;;;;;;:::i;:::-;;:::i;:::-;;;9177:14:1;;9170:22;9152:41;;9140:2;9125:18;44848:305:0;;;;;;;;73353:257;;;;;;:::i;:::-;;:::i;:::-;;47961:100;;;:::i;:::-;;;;;;;:::i;49100:204::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;8475:32:1;;;8457:51;;8445:2;8430:18;49100:204:0;8412:102:1;48663:371:0;;;;;;:::i;:::-;;:::i;73618:276::-;;;;;;:::i;:::-;;:::i;44097:303::-;44351:12;;44335:13;;:28;-1:-1:-1;;44335:46:0;44097:303;;;9350:25:1;;;9338:2;9323:18;44097:303:0;9305:76:1;41052:43:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;73902:204;;;;;;:::i;:::-;;:::i;49965:170::-;;;;;;:::i;:::-;;:::i;25612:114::-;;;;;;:::i;:::-;25669:7;25696:12;;;;;;;;;;:22;;;;25612:114;25988:227;;;;;;:::i;:::-;;:::i;27197:209::-;;;;;;:::i;:::-;;:::i;76277:588::-;;;;;;:::i;:::-;;:::i;50206:185::-;;;;;;:::i;:::-;;:::i;73074:271::-;;;:::i;74745:419::-;;;;;;:::i;:::-;;:::i;71818:39::-;;;;;-1:-1:-1;;;71818:39:0;;;;;;63408:86;63479:7;;;;63408:86;;74114:210;;;;;;:::i;:::-;;:::i;47769:125::-;;;;;;:::i;:::-;;:::i;75706:563::-;;;;;;:::i;:::-;;:::i;72742:96::-;72817:13;;72742:96;;42937:89;;;:::i;45217:206::-;;;;;;:::i;:::-;;:::i;71789:20::-;;;;;;;;-1:-1:-1;;;;;71789:20:0;;;25285:138;;;;;;:::i;:::-;;:::i;24246:139::-;;;;;;:::i;:::-;;:::i;48130:104::-;;;:::i;71864:33::-;;;;;-1:-1:-1;;;71864:33:0;;;;;;22991:49;;23036:4;22991:49;;49376:287;;;;;;:::i;:::-;;:::i;71987:34::-;;;;;;50462:369;;;;;;:::i;:::-;;:::i;74332:405::-;;;;;;:::i;:::-;;:::i;48305:294::-;;;;;;:::i;:::-;;:::i;24559:127::-;;;;;;:::i;:::-;;:::i;71904:34::-;;;;;-1:-1:-1;;;71904:34:0;;;;;;71651:62;;-1:-1:-1;;;;;;;;;;;71651:62:0;;26460:230;;;;;;:::i;:::-;;:::i;76871:282::-;;;;;;:::i;:::-;;:::i;72846:220::-;;;;;;:::i;:::-;;:::i;71720:62::-;;71758:24;71720:62;;75172:146;;;:::i;49734:164::-;;;;;;:::i;:::-;-1:-1:-1;;;;;49855:25:0;;;49831:4;49855:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;49734:164;44848:305;44950:4;-1:-1:-1;;;;;;44987:40:0;;-1:-1:-1;;;44987:40:0;;:105;;-1:-1:-1;;;;;;;45044:48:0;;-1:-1:-1;;;45044:48:0;44987:105;:158;;;-1:-1:-1;;;;;;;30854:33:0;;30830:4;30854:33;;;:20;:33;;;;;;;;45109:36;44967:178;44848:305;-1:-1:-1;;44848:305:0:o;73353:257::-;73427:41;23036:4;730:10;24246:139;:::i;73427:41::-;73419:92;;;;-1:-1:-1;;;73419:92:0;;;;;;;:::i;:::-;;;;;;;;;73532:14;;-1:-1:-1;;;73532:14:0;;;;73530:16;73522:46;;;;-1:-1:-1;;;73522:46:0;;12597:2:1;73522:46:0;;;12579:21:1;12636:2;12616:18;;;12609:30;-1:-1:-1;;;12655:18:1;;;12648:47;12712:18;;73522:46:0;12569:167:1;73522:46:0;73579:21;73591:8;73579:11;:21::i;:::-;73353:257;:::o;47961:100::-;48015:13;48048:5;48041:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47961:100;:::o;49100:204::-;49168:7;49193:16;49201:7;49193;:16::i;:::-;49188:64;;49218:34;;-1:-1:-1;;;49218:34:0;;;;;;;;;;;49188:64;-1:-1:-1;49272:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;49272:24:0;;49100:204::o;48663:371::-;48736:13;48752:24;48768:7;48752:15;:24::i;:::-;48736:40;;48797:5;-1:-1:-1;;;;;48791:11:0;:2;-1:-1:-1;;;;;48791:11:0;;48787:48;;;48811:24;;-1:-1:-1;;;48811:24:0;;;;;;;;;;;48787:48;730:10;-1:-1:-1;;;;;48852:21:0;;;;;;:63;;-1:-1:-1;48878:37:0;48895:5;730:10;49734:164;:::i;48878:37::-;48877:38;48852:63;48848:138;;;48939:35;;-1:-1:-1;;;48939:35:0;;;;;;;;;;;48848:138;48998:28;49007:2;49011:7;49020:5;48998:8;:28::i;:::-;48663:371;;;:::o;73618:276::-;73686:41;23036:4;730:10;24246:139;:::i;73686:41::-;73678:92;;;;-1:-1:-1;;;73678:92:0;;;;;;;:::i;:::-;73781:38;23036:4;73812:6;73781:10;:38::i;:::-;73830:31;-1:-1:-1;;;;;;;;;;;73854:6:0;73830:10;:31::i;:::-;73872:5;:14;;-1:-1:-1;;;;;73872:14:0;;;;;-1:-1:-1;;;;;;73872:14:0;;;;;;;;;73618:276::o;73902:204::-;73971:41;23036:4;730:10;24246:139;:::i;73971:41::-;73963:100;;;;-1:-1:-1;;;73963:100:0;;12182:2:1;73963:100:0;;;12164:21:1;12221:2;12201:18;;;12194:30;12260:34;12240:18;;;12233:62;-1:-1:-1;;;12311:18:1;;;12304:44;12365:19;;73963:100:0;12154:236:1;73963:100:0;74074:14;:22;;;;;-1:-1:-1;;;74074:22:0;-1:-1:-1;;;;74074:22:0;;;;;;;;;73902:204::o;49965:170::-;50099:28;50109:4;50115:2;50119:7;50099:9;:28::i;25988:227::-;26080:6;:12;;;;;;;;;;:22;;;26072:45;;730:10;24246:139;:::i;26072:45::-;26064:105;;;;-1:-1:-1;;;26064:105:0;;10227:2:1;26064:105:0;;;10209:21:1;10266:2;10246:18;;;10239:30;10305:34;10285:18;;;10278:62;-1:-1:-1;;;10356:18:1;;;10349:45;10411:19;;26064:105:0;10199:237:1;26064:105:0;26182:25;26193:4;26199:7;26182:10;:25::i;:::-;25988:227;;:::o;27197:209::-;-1:-1:-1;;;;;27284:23:0;;730:10;27284:23;27276:83;;;;-1:-1:-1;;;27276:83:0;;14103:2:1;27276:83:0;;;14085:21:1;14142:2;14122:18;;;14115:30;14181:34;14161:18;;;14154:62;-1:-1:-1;;;14232:18:1;;;14225:45;14287:19;;27276:83:0;14075:237:1;27276:83:0;27372:26;27384:4;27390:7;27372:11;:26::i;76277:588::-;76355:34;-1:-1:-1;;;;;;;;;;;730:10:0;24246:139;:::i;76355:34::-;76347:94;;;;-1:-1:-1;;;76347:94:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;76460:14:0;;;;;;:10;:14;;;;;;;;;:39;;-1:-1:-1;76480:19:0;;-1:-1:-1;;;76480:19:0;;;;76478:21;76460:39;76452:74;;;;-1:-1:-1;;;76452:74:0;;11831:2:1;76452:74:0;;;11813:21:1;11870:2;11850:18;;;11843:30;-1:-1:-1;;;11889:18:1;;;11882:52;11951:18;;76452:74:0;11803:172:1;76452:74:0;76547:14;;-1:-1:-1;;;76547:14:0;;;;76539:48;;;;-1:-1:-1;;;76539:48:0;;12943:2:1;76539:48:0;;;12925:21:1;12982:2;12962:18;;;12955:30;-1:-1:-1;;;13001:18:1;;;12994:51;13062:18;;76539:48:0;12915:171:1;76539:48:0;76750:23;76760:2;76764:8;76750:9;:23::i;:::-;72817:13;;76792;76802:2;76792:9;:13::i;:::-;:34;;76784:73;;;;-1:-1:-1;;;76784:73:0;;11059:2:1;76784:73:0;;;11041:21:1;11098:2;11078:18;;;11071:30;11137:28;11117:18;;;11110:56;11183:18;;76784:73:0;11031:176:1;50206:185:0;50344:39;50361:4;50367:2;50371:7;50344:39;;;;;;;;;;;;:16;:39::i;73074:271::-;73137:41;23036:4;730:10;24246:139;:::i;73137:41::-;73129:100;;;;-1:-1:-1;;;73129:100:0;;;;;;;:::i;:::-;73250:14;;-1:-1:-1;;;73250:14:0;;;;73248:16;73240:63;;;;-1:-1:-1;;;73240:63:0;;13700:2:1;73240:63:0;;;13682:21:1;13739:2;13719:18;;;13712:30;13778:34;13758:18;;;13751:62;-1:-1:-1;;;13829:18:1;;;13822:32;13871:19;;73240:63:0;13672:224:1;73240:63:0;73316:14;:21;;-1:-1:-1;;;;73316:21:0;-1:-1:-1;;;73316:21:0;;;73074:271::o;74745:419::-;74833:41;23036:4;730:10;24246:139;:::i;74833:41::-;74825:92;;;;-1:-1:-1;;;74825:92:0;;;;;;;:::i;:::-;74931:9;74926:231;74950:14;:21;74946:1;:25;74926:231;;;74995:10;:29;75006:14;75021:1;75006:17;;;;;;-1:-1:-1;;;75006:17:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;74995:29:0;;;;;;;;;;;-1:-1:-1;74995:29:0;;;;74991:109;;;75062:19;;:26;;75086:1;75062:23;:26::i;:::-;75040:19;:48;74991:109;75142:5;75110:10;:29;75121:14;75136:1;75121:17;;;;;;-1:-1:-1;;;75121:17:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;75110:29:0;;;;;;;;;;;-1:-1:-1;75110:29:0;:37;;-1:-1:-1;;75110:37:0;;;;;;;;;;74973:3;;;;:::i;:::-;;;;74926:231;;74114:210;74190:41;23036:4;730:10;24246:139;:::i;74190:41::-;74182:92;;;;-1:-1:-1;;;74182:92:0;;;;;;;:::i;:::-;74285:19;:29;;;;;-1:-1:-1;;;74285:29:0;-1:-1:-1;;;;74285:29:0;;;;;;;;;74114:210::o;47769:125::-;47833:7;47860:21;47873:7;47860:12;:21::i;:::-;:26;;47769:125;-1:-1:-1;;47769:125:0:o;75706:563::-;75766:34;-1:-1:-1;;;;;;;;;;;730:10:0;24246:139;:::i;75766:34::-;75758:94;;;;-1:-1:-1;;;75758:94:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;75871:14:0;;;;;;:10;:14;;;;;;;;;:39;;-1:-1:-1;75891:19:0;;-1:-1:-1;;;75891:19:0;;;;75889:21;75871:39;75863:74;;;;-1:-1:-1;;;75863:74:0;;11831:2:1;75863:74:0;;;11813:21:1;11870:2;11850:18;;;11843:30;-1:-1:-1;;;11889:18:1;;;11882:52;11951:18;;75863:74:0;11803:172:1;75863:74:0;75958:14;;-1:-1:-1;;;75958:14:0;;;;75950:48;;;;-1:-1:-1;;;75950:48:0;;12943:2:1;75950:48:0;;;12925:21:1;12982:2;12962:18;;;12955:30;-1:-1:-1;;;13001:18:1;;;12994:51;13062:18;;75950:48:0;12915:171:1;75950:48:0;76161:16;76171:2;76175:1;76161:9;:16::i;:::-;72817:13;;76196;76206:2;76196:9;:13::i;:::-;:34;;76188:73;;;;-1:-1:-1;;;76188:73:0;;11059:2:1;76188:73:0;;;11041:21:1;11098:2;11078:18;;;11071:30;11137:28;11117:18;;;11110:56;11183:18;;76188:73:0;11031:176:1;42937:89:0;42977:13;43010:8;43003:15;;;;;:::i;45217:206::-;45281:7;-1:-1:-1;;;;;45305:19:0;;45301:60;;45333:28;;-1:-1:-1;;;45333:28:0;;;;;;;;;;;45301:60;-1:-1:-1;;;;;;45387:19:0;;;;;:12;:19;;;;;:27;;;;45217:206::o;25285:138::-;25358:7;25385:12;;;;;;;;;;:30;;25409:5;25385:23;:30::i;:::-;25378:37;25285:138;-1:-1:-1;;;25285:138:0:o;24246:139::-;24315:4;24339:12;;;;;;;;;;:38;;24369:7;24339:29;:38::i;48130:104::-;48186:13;48219:7;48212:14;;;;;:::i;49376:287::-;-1:-1:-1;;;;;49475:24:0;;730:10;49475:24;49471:54;;;49508:17;;-1:-1:-1;;;49508:17:0;;;;;;;;;;;49471:54;730:10;49538:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;49538:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;49538:53:0;;;;;;;;;;49607:48;;9152:41:1;;;49538:42:0;;730:10;49607:48;;9125:18:1;49607:48:0;;;;;;;49376:287;;:::o;50462:369::-;50629:28;50639:4;50645:2;50649:7;50629:9;:28::i;:::-;50672:15;:2;-1:-1:-1;;;;;50672:13:0;;:15::i;:::-;:76;;;;;50692:56;50723:4;50729:2;50733:7;50742:5;50692:30;:56::i;:::-;50691:57;50672:76;50668:156;;;50772:40;;-1:-1:-1;;;50772:40:0;;;;;;;;;;;50668:156;50462:369;;;;:::o;74332:405::-;74410:41;23036:4;730:10;24246:139;:::i;74410:41::-;74402:92;;;;-1:-1:-1;;;74402:92:0;;;;;;;:::i;:::-;74508:9;74503:227;74527:14;:21;74523:1;:25;74503:227;;;74572:10;:29;74583:14;74598:1;74583:17;;;;;;-1:-1:-1;;;74583:17:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;74572:29:0;;;;;;;;;;;-1:-1:-1;74572:29:0;;;;74566:108;;74639:19;;:23;;74661:1;74639:23;:::i;:::-;74617:19;:45;74566:108;74716:4;74684:10;:29;74695:14;74710:1;74695:17;;;;;;-1:-1:-1;;;74695:17:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;74684:29:0;;;;;;;;;;;-1:-1:-1;74684:29:0;:36;;-1:-1:-1;;74684:36:0;;;;;;;;;;74550:3;;;;:::i;:::-;;;;74503:227;;48305:294;48378:13;48409:16;48417:7;48409;:16::i;:::-;48404:59;;48434:29;;-1:-1:-1;;;48434:29:0;;;;;;;;;;;48404:59;48476:22;48501:9;:7;:9::i;:::-;48476:34;;48552:8;48562:18;:7;:16;:18::i;:::-;48535:55;;;;;;;;;:::i;:::-;;;;;;;;;;;;;48521:70;;;48305:294;;;:::o;24559:127::-;24622:7;24649:12;;;;;;;;;;:29;;:27;:29::i;26460:230::-;26553:6;:12;;;;;;;;;;:22;;;26545:45;;730:10;24246:139;:::i;26545:45::-;26537:106;;;;-1:-1:-1;;;26537:106:0;;11414:2:1;26537:106:0;;;11396:21:1;11453:2;11433:18;;;11426:30;11492:34;11472:18;;;11465:62;-1:-1:-1;;;11543:18:1;;;11536:46;11599:19;;26537:106:0;11386:238:1;76871:282:0;76951:41;23036:4;730:10;24246:139;:::i;76951:41::-;76943:92;;;;-1:-1:-1;;;76943:92:0;;;;;;;:::i;:::-;77051:9;77046:100;77070:14;:21;77066:1;:25;77046:100;;;77111:23;77116:14;77131:1;77116:17;;;;;;-1:-1:-1;;;77116:17:0;;;;;;;;;;;;;;;77111:4;:23::i;:::-;77093:3;;;;:::i;:::-;;;;77046:100;;72846:220;72927:41;23036:4;730:10;24246:139;:::i;72927:41::-;72919:100;;;;-1:-1:-1;;;72919:100:0;;;;;;;:::i;:::-;73030:13;:28;72846:220::o;75172:146::-;75216:13;75273:9;:7;:9::i;:::-;75256:53;;;;;;;;:::i;:::-;;;;;;;;;;;;;75242:68;;75172:146;:::o;8602:152::-;8672:4;8696:50;8701:3;-1:-1:-1;;;;;8721:23:0;;8696:4;:50::i;42600:100::-;42673:19;;;;:8;;:19;;;;;:::i;51086:187::-;51143:4;51186:7;43954:1;51167:26;;:53;;;;;51207:13;;51197:7;:23;51167:53;:98;;;;-1:-1:-1;;51238:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;51238:27:0;;;;51237:28;;51086:187::o;59256:196::-;59371:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;59371:29:0;-1:-1:-1;;;;;59371:29:0;;;;;;;;;59416:28;;59371:24;;59416:28;;;;;;;59256:196;;;:::o;54199:2130::-;54314:35;54352:21;54365:7;54352:12;:21::i;:::-;54314:59;;54412:4;-1:-1:-1;;;;;54390:26:0;:13;:18;;;-1:-1:-1;;;;;54390:26:0;;54386:67;;54425:28;;-1:-1:-1;;;54425:28:0;;;;;;;;;;;54386:67;54466:22;730:10;-1:-1:-1;;;;;54492:20:0;;;;:73;;-1:-1:-1;54529:36:0;54546:4;730:10;49734:164;:::i;54529:36::-;54492:126;;;-1:-1:-1;730:10:0;54582:20;54594:7;54582:11;:20::i;:::-;-1:-1:-1;;;;;54582:36:0;;54492:126;54466:153;;54637:17;54632:66;;54663:35;;-1:-1:-1;;;54663:35:0;;;;;;;;;;;54632:66;-1:-1:-1;;;;;54713:16:0;;54709:52;;54738:23;;-1:-1:-1;;;54738:23:0;;;;;;;;;;;54709:52;54882:35;54899:1;54903:7;54912:4;54882:8;:35::i;:::-;-1:-1:-1;;;;;55213:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;55213:31:0;;;;;;;-1:-1:-1;;55213:31:0;;;;;;;55259:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;55259:29:0;;;;;;;;;;;55339:20;;;:11;:20;;;;;;55374:18;;-1:-1:-1;;;;;;55407:49:0;;;;-1:-1:-1;;;55440:15:0;55407:49;;;;;;;;;;55730:11;;55790:24;;;;;55833:13;;55339:20;;55790:24;;55833:13;55829:384;;56043:13;;56028:11;:28;56024:174;;56081:20;;56150:28;;;;56124:54;;-1:-1:-1;;;56124:54:0;-1:-1:-1;;;;;;56124:54:0;;;-1:-1:-1;;;;;56081:20:0;;56124:54;;;;56024:174;54199:2130;;;56260:7;56256:2;-1:-1:-1;;;;;56241:27:0;56250:4;-1:-1:-1;;;;;56241:27:0;;;;;;;;;;;56279:42;54199:2130;;;;;:::o;28440:188::-;28514:6;:12;;;;;;;;;;:33;;28539:7;28514:24;:33::i;:::-;28510:111;;;28569:40;;730:10;;-1:-1:-1;;;;;28569:40:0;;;28581:4;;28569:40;;;;;28440:188;;:::o;28636:192::-;28711:6;:12;;;;;;;;;;:36;;28739:7;28711:27;:36::i;:::-;28707:114;;;28769:40;;730:10;;-1:-1:-1;;;;;28769:40:0;;;28781:4;;28769:40;;;;;28636:192;;:::o;51281:104::-;51350:27;51360:2;51364:8;51350:27;;;;;;;;;;;;:9;:27::i;66770:136::-;66828:7;66855:43;66859:1;66862;66855:43;;;;;;;;;;;;;;;;;:3;:43::i;46598:1109::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;46709:7:0;;43954:1;46758:23;;:47;;;;;46792:13;;46785:4;:20;46758:47;46754:886;;;46826:31;46860:17;;;:11;:17;;;;;;;;;46826:51;;;;;;;;;-1:-1:-1;;;;;46826:51:0;;;;-1:-1:-1;;;46826:51:0;;;;;;;;;;;-1:-1:-1;;;46826:51:0;;;;;;;;;;;;;;46896:729;;46946:14;;-1:-1:-1;;;;;46946:28:0;;46942:101;;47010:9;46598:1109;-1:-1:-1;;;46598:1109:0:o;46942:101::-;-1:-1:-1;;;47385:6:0;47430:17;;;;:11;:17;;;;;;;;;47418:29;;;;;;;;;-1:-1:-1;;;;;47418:29:0;;;;;-1:-1:-1;;;47418:29:0;;;;;;;;;;;-1:-1:-1;;;47418:29:0;;;;;;;;;;;;;47478:28;47474:109;;47546:9;46598:1109;-1:-1:-1;;;46598:1109:0:o;47474:109::-;47345:261;;;46754:886;;47668:31;;-1:-1:-1;;;47668:31:0;;;;;;;;;;;9898:158;9972:7;10023:22;10027:3;10039:5;10023:3;:22::i;9174:167::-;-1:-1:-1;;;;;9308:23:0;;9254:4;4710:19;;;:12;;;:19;;;;;;:24;;9278:55;4613:129;13631:755;13689:17;14271:18;;14175:66;14337:15;;;;;:42;;;14368:11;14356:8;:23;;14337:42;14321:59;13631:755;-1:-1:-1;;;;13631:755:0:o;59944:667::-;60128:72;;-1:-1:-1;;;60128:72:0;;60107:4;;-1:-1:-1;;;;;60128:36:0;;;;;:72;;730:10;;60179:4;;60185:7;;60194:5;;60128:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60128:72:0;;;;;;;;-1:-1:-1;;60128:72:0;;;;;;;;;;;;:::i;:::-;;;60124:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60362:13:0;;60358:235;;60408:40;;-1:-1:-1;;;60408:40:0;;;;;;;;;;;60358:235;60551:6;60545:13;60536:6;60532:2;60528:15;60521:38;60124:480;-1:-1:-1;;;;;;60247:55:0;-1:-1:-1;;;60247:55:0;;-1:-1:-1;59944:667:0;;;;;;:::o;38131:723::-;38187:13;38408:10;38404:53;;-1:-1:-1;;38435:10:0;;;;;;;;;;;;-1:-1:-1;;;38435:10:0;;;;;38131:723::o;38404:53::-;38482:5;38467:12;38523:78;38530:9;;38523:78;;38556:8;;;;:::i;:::-;;-1:-1:-1;38579:10:0;;-1:-1:-1;38587:2:0;38579:10;;:::i;:::-;;;38523:78;;;38611:19;38643:6;38633:17;;;;;;-1:-1:-1;;;38633:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38633:17:0;;38611:39;;38661:154;38668:10;;38661:154;;38695:11;38705:1;38695:11;;:::i;:::-;;-1:-1:-1;38764:10:0;38772:2;38764:5;:10;:::i;:::-;38751:24;;:2;:24;:::i;:::-;38738:39;;38721:6;38728;38721:14;;;;;;-1:-1:-1;;;38721:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;38721:56:0;;;;;;;;-1:-1:-1;38792:11:0;38801:2;38792:11;;:::i;:::-;;;38661:154;;9427:117;9490:7;9517:19;9525:3;4911:18;;4828:109;2517:414;2580:4;4710:19;;;:12;;;:19;;;;;;2597:327;;-1:-1:-1;2640:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;2823:18;;2801:19;;;:12;;;:19;;;;;;:40;;;;2856:11;;2597:327;-1:-1:-1;2907:5:0;2900:12;;8930:158;9003:4;9027:53;9035:3;-1:-1:-1;;;;;9055:23:0;;9027:7;:53::i;51748:163::-;51871:32;51877:2;51881:8;51891:5;51898:4;51871:5;:32::i;67209:192::-;67295:7;67331:12;67323:6;;;;67315:29;;;;-1:-1:-1;;;67315:29:0;;;;;;;;:::i;:::-;-1:-1:-1;67355:9:0;67367:5;67371:1;67367;:5;:::i;:::-;67355:17;67209:192;-1:-1:-1;;;;;67209:192:0:o;5291:120::-;5358:7;5385:3;:11;;5397:5;5385:18;;;;;;-1:-1:-1;;;5385:18:0;;;;;;;;;;;;;;;;;5378:25;;5291:120;;;;:::o;3107:1420::-;3173:4;3312:19;;;:12;;;:19;;;;;;3348:15;;3344:1176;;3723:21;3747:14;3760:1;3747:10;:14;:::i;:::-;3796:18;;3723:38;;-1:-1:-1;3776:17:0;;3796:22;;3817:1;;3796:22;:::i;:::-;3776:42;;3852:13;3839:9;:26;3835:405;;3886:17;3906:3;:11;;3918:9;3906:22;;;;;;-1:-1:-1;;;3906:22:0;;;;;;;;;;;;;;;;;3886:42;;4060:9;4031:3;:11;;4043:13;4031:26;;;;;;-1:-1:-1;;;4031:26:0;;;;;;;;;;;;;;;;;;;;:38;;;;4145:23;;;:12;;;:23;;;;;:36;;;3835:405;4321:17;;:3;;:17;;;-1:-1:-1;;;4321:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;4416:3;:12;;:19;4429:5;4416:19;;;;;;;;;;;4409:26;;;4459:4;4452:11;;;;;;;3344:1176;4503:5;4496:12;;;;;52170:1775;52332:13;;-1:-1:-1;;;;;52360:16:0;;52356:48;;52385:19;;-1:-1:-1;;;52385:19:0;;;;;;;;;;;52356:48;52419:13;52415:44;;52441:18;;-1:-1:-1;;;52441:18:0;;;;;;;;;;;52415:44;-1:-1:-1;;;;;52810:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;52869:49:0;;52810:44;;;;;;;;52869:49;;;;-1:-1:-1;;52810:44:0;;;;;;52869:49;;;;;;;;;;;;;;;;52935:25;;;52869:29;52935:25;;;;;;:35;;-1:-1:-1;;;;;;52985:66:0;;;;-1:-1:-1;;;53035:15:0;52985:66;;;;;;;;;;52935:25;53132:23;;;53176:4;:23;;;;;53184:15;:2;-1:-1:-1;;;;;53184:13:0;;:15::i;:::-;53172:641;;;53220:314;53251:38;;53276:12;;-1:-1:-1;;;;;53251:38:0;;;53268:1;;53251:38;;53268:1;;53251:38;53317:69;53356:1;53360:2;53364:14;;;;;;53380:5;53317:30;:69::i;:::-;53312:174;;53422:40;;-1:-1:-1;;;53422:40:0;;;;;;;;;;;53312:174;53529:3;53513:12;:19;;53220:314;;53615:12;53598:13;;:29;53594:43;;53629:8;;;53594:43;53172:641;;;53678:120;53709:40;;53734:14;;;;;-1:-1:-1;;;;;53709:40:0;;;53726:1;;53709:40;;53726:1;;53709:40;53793:3;53777:12;:19;;53678:120;;53172:641;-1:-1:-1;53827:13:0;:28;53877:60;50462:369;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:406:1;78:5;112:18;104:6;101:30;98:2;;;134:18;;:::i;:::-;172:57;217:2;196:15;;-1:-1:-1;;192:29:1;223:4;188:40;172:57;:::i;:::-;163:66;;252:6;245:5;238:21;292:3;283:6;278:3;274:16;271:25;268:2;;;309:1;306;299:12;268:2;358:6;353:3;346:4;339:5;335:16;322:43;412:1;405:4;396:6;389:5;385:18;381:29;374:40;88:332;;;;;:::o;425:173::-;493:20;;-1:-1:-1;;;;;542:31:1;;532:42;;522:2;;588:1;585;578:12;522:2;474:124;;;:::o;603:160::-;668:20;;724:13;;717:21;707:32;;697:2;;753:1;750;743:12;768:196;827:6;880:2;868:9;859:7;855:23;851:32;848:2;;;901:6;893;886:22;848:2;929:29;948:9;929:29;:::i;969:270::-;1037:6;1045;1098:2;1086:9;1077:7;1073:23;1069:32;1066:2;;;1119:6;1111;1104:22;1066:2;1147:29;1166:9;1147:29;:::i;:::-;1137:39;;1195:38;1229:2;1218:9;1214:18;1195:38;:::i;:::-;1185:48;;1056:183;;;;;:::o;1244:338::-;1321:6;1329;1337;1390:2;1378:9;1369:7;1365:23;1361:32;1358:2;;;1411:6;1403;1396:22;1358:2;1439:29;1458:9;1439:29;:::i;:::-;1429:39;;1487:38;1521:2;1510:9;1506:18;1487:38;:::i;:::-;1477:48;;1572:2;1561:9;1557:18;1544:32;1534:42;;1348:234;;;;;:::o;1587:696::-;1682:6;1690;1698;1706;1759:3;1747:9;1738:7;1734:23;1730:33;1727:2;;;1781:6;1773;1766:22;1727:2;1809:29;1828:9;1809:29;:::i;:::-;1799:39;;1857:38;1891:2;1880:9;1876:18;1857:38;:::i;:::-;1847:48;;1942:2;1931:9;1927:18;1914:32;1904:42;;1997:2;1986:9;1982:18;1969:32;2024:18;2016:6;2013:30;2010:2;;;2061:6;2053;2046:22;2010:2;2089:22;;2142:4;2134:13;;2130:27;-1:-1:-1;2120:2:1;;2176:6;2168;2161:22;2120:2;2204:73;2269:7;2264:2;2251:16;2246:2;2242;2238:11;2204:73;:::i;:::-;2194:83;;;1717:566;;;;;;;:::o;2288:264::-;2353:6;2361;2414:2;2402:9;2393:7;2389:23;2385:32;2382:2;;;2435:6;2427;2420:22;2382:2;2463:29;2482:9;2463:29;:::i;:::-;2453:39;;2511:35;2542:2;2531:9;2527:18;2511:35;:::i;2557:264::-;2625:6;2633;2686:2;2674:9;2665:7;2661:23;2657:32;2654:2;;;2707:6;2699;2692:22;2654:2;2735:29;2754:9;2735:29;:::i;:::-;2725:39;2811:2;2796:18;;;;2783:32;;-1:-1:-1;;;2644:177:1:o;2826:1008::-;2910:6;2941:2;2984;2972:9;2963:7;2959:23;2955:32;2952:2;;;3005:6;2997;2990:22;2952:2;3050:9;3037:23;3079:18;3120:2;3112:6;3109:14;3106:2;;;3141:6;3133;3126:22;3106:2;3184:6;3173:9;3169:22;3159:32;;3229:7;3222:4;3218:2;3214:13;3210:27;3200:2;;3256:6;3248;3241:22;3200:2;3297;3284:16;3319:2;3315;3312:10;3309:2;;;3325:18;;:::i;:::-;3371:2;3368:1;3364:10;3354:20;;3394:28;3418:2;3414;3410:11;3394:28;:::i;:::-;3456:15;;;3487:12;;;;3519:11;;;3549;;;3545:20;;3542:33;-1:-1:-1;3539:2:1;;;3593:6;3585;3578:22;3539:2;3620:6;3611:15;;3635:169;3649:2;3646:1;3643:9;3635:169;;;3706:23;3725:3;3706:23;:::i;:::-;3694:36;;3667:1;3660:9;;;;;3750:12;;;;3782;;3635:169;;;-1:-1:-1;3823:5:1;2921:913;-1:-1:-1;;;;;;;;2921:913:1:o;3839:190::-;3895:6;3948:2;3936:9;3927:7;3923:23;3919:32;3916:2;;;3969:6;3961;3954:22;3916:2;3997:26;4013:9;3997:26;:::i;4034:190::-;4093:6;4146:2;4134:9;4125:7;4121:23;4117:32;4114:2;;;4167:6;4159;4152:22;4114:2;-1:-1:-1;4195:23:1;;4104:120;-1:-1:-1;4104:120:1:o;4229:264::-;4297:6;4305;4358:2;4346:9;4337:7;4333:23;4329:32;4326:2;;;4379:6;4371;4364:22;4326:2;4420:9;4407:23;4397:33;;4449:38;4483:2;4472:9;4468:18;4449:38;:::i;4498:258::-;4566:6;4574;4627:2;4615:9;4606:7;4602:23;4598:32;4595:2;;;4648:6;4640;4633:22;4595:2;-1:-1:-1;;4676:23:1;;;4746:2;4731:18;;;4718:32;;-1:-1:-1;4585:171:1:o;4761:255::-;4819:6;4872:2;4860:9;4851:7;4847:23;4843:32;4840:2;;;4893:6;4885;4878:22;4840:2;4937:9;4924:23;4956:30;4980:5;4956:30;:::i;5021:259::-;5090:6;5143:2;5131:9;5122:7;5118:23;5114:32;5111:2;;;5164:6;5156;5149:22;5111:2;5201:9;5195:16;5220:30;5244:5;5220:30;:::i;5285:480::-;5354:6;5407:2;5395:9;5386:7;5382:23;5378:32;5375:2;;;5428:6;5420;5413:22;5375:2;5473:9;5460:23;5506:18;5498:6;5495:30;5492:2;;;5543:6;5535;5528:22;5492:2;5571:22;;5624:4;5616:13;;5612:27;-1:-1:-1;5602:2:1;;5658:6;5650;5643:22;5602:2;5686:73;5751:7;5746:2;5733:16;5728:2;5724;5720:11;5686:73;:::i;5965:257::-;6006:3;6044:5;6038:12;6071:6;6066:3;6059:19;6087:63;6143:6;6136:4;6131:3;6127:14;6120:4;6113:5;6109:16;6087:63;:::i;:::-;6204:2;6183:15;-1:-1:-1;;6179:29:1;6170:39;;;;6211:4;6166:50;;6014:208;-1:-1:-1;;6014:208:1:o;6227:185::-;6269:3;6307:5;6301:12;6322:52;6367:6;6362:3;6355:4;6348:5;6344:16;6322:52;:::i;:::-;6390:16;;;;;6277:135;-1:-1:-1;;6277:135:1:o;6535:461::-;6767:3;6805:6;6799:13;6821:53;6867:6;6862:3;6855:4;6847:6;6843:17;6821:53;:::i;:::-;-1:-1:-1;;;6896:16:1;;6921:39;;;-1:-1:-1;6987:2:1;6976:14;;6775:221;-1:-1:-1;6775:221:1:o;7001:1305::-;7278:3;7307;7342:6;7336:13;7372:3;7394:1;7422:9;7418:2;7414:18;7404:28;;7482:2;7471:9;7467:18;7504;7494:2;;7548:4;7540:6;7536:17;7526:27;;7494:2;7574;7622;7614:6;7611:14;7591:18;7588:38;7585:2;;;-1:-1:-1;;;7649:33:1;;7705:4;7702:1;7695:15;7735:4;7656:3;7723:17;7585:2;7766:18;7793:104;;;;7911:1;7906:322;;;;7759:469;;7793:104;-1:-1:-1;;7826:24:1;;7814:37;;7871:16;;;;-1:-1:-1;7793:104:1;;7906:322;14826:4;14845:17;;;14895:4;14879:21;;8001:3;8017:165;8031:6;8028:1;8025:13;8017:165;;;8109:14;;8096:11;;;8089:35;8152:16;;;;8046:10;;8017:165;;;8021:3;;8211:6;8206:3;8202:16;8195:23;;7759:469;;;;;;;8244:56;8269:30;8295:3;8287:6;8269:30;:::i;:::-;-1:-1:-1;;;6477:20:1;;6522:1;6513:11;;6467:63;8519:488;-1:-1:-1;;;;;8788:15:1;;;8770:34;;8840:15;;8835:2;8820:18;;8813:43;8887:2;8872:18;;8865:34;;;8935:3;8930:2;8915:18;;8908:31;;;8713:4;;8956:45;;8981:19;;8973:6;8956:45;:::i;:::-;8948:53;8722:285;-1:-1:-1;;;;;;8722:285:1:o;9386:219::-;9535:2;9524:9;9517:21;9498:4;9555:44;9595:2;9584:9;9580:18;9572:6;9555:44;:::i;9610:410::-;9812:2;9794:21;;;9851:2;9831:18;;;9824:30;9890:34;9885:2;9870:18;;9863:62;-1:-1:-1;;;9956:2:1;9941:18;;9934:44;10010:3;9995:19;;9784:236::o;10441:411::-;10643:2;10625:21;;;10682:2;10662:18;;;10655:30;10721:34;10716:2;10701:18;;10694:62;-1:-1:-1;;;10787:2:1;10772:18;;10765:45;10842:3;10827:19;;10615:237::o;13091:402::-;13293:2;13275:21;;;13332:2;13312:18;;;13305:30;13371:34;13366:2;13351:18;;13344:62;-1:-1:-1;;;13437:2:1;13422:18;;13415:36;13483:3;13468:19;;13265:228::o;14499:275::-;14570:2;14564:9;14635:2;14616:13;;-1:-1:-1;;14612:27:1;14600:40;;14670:18;14655:34;;14691:22;;;14652:62;14649:2;;;14717:18;;:::i;:::-;14753:2;14746:22;14544:230;;-1:-1:-1;14544:230:1:o;14911:128::-;14951:3;14982:1;14978:6;14975:1;14972:13;14969:2;;;14988:18;;:::i;:::-;-1:-1:-1;15024:9:1;;14959:80::o;15044:120::-;15084:1;15110;15100:2;;15115:18;;:::i;:::-;-1:-1:-1;15149:9:1;;15090:74::o;15169:125::-;15209:4;15237:1;15234;15231:8;15228:2;;;15242:18;;:::i;:::-;-1:-1:-1;15279:9:1;;15218:76::o;15299:258::-;15371:1;15381:113;15395:6;15392:1;15389:13;15381:113;;;15471:11;;;15465:18;15452:11;;;15445:39;15417:2;15410:10;15381:113;;;15512:6;15509:1;15506:13;15503:2;;;-1:-1:-1;;15547:1:1;15529:16;;15522:27;15352:205::o;15562:380::-;15641:1;15637:12;;;;15684;;;15705:2;;15759:4;15751:6;15747:17;15737:27;;15705:2;15812;15804:6;15801:14;15781:18;15778:38;15775:2;;;15858:10;15853:3;15849:20;15846:1;15839:31;15893:4;15890:1;15883:15;15921:4;15918:1;15911:15;15775:2;;15617:325;;;:::o;15947:135::-;15986:3;-1:-1:-1;;16007:17:1;;16004:2;;;16027:18;;:::i;:::-;-1:-1:-1;16074:1:1;16063:13;;15994:88::o;16087:112::-;16119:1;16145;16135:2;;16150:18;;:::i;:::-;-1:-1:-1;16184:9:1;;16125:74::o;16204:127::-;16265:10;16260:3;16256:20;16253:1;16246:31;16296:4;16293:1;16286:15;16320:4;16317:1;16310:15;16336:127;16397:10;16392:3;16388:20;16385:1;16378:31;16428:4;16425:1;16418:15;16452:4;16449:1;16442:15;16468:127;16529:10;16524:3;16520:20;16517:1;16510:31;16560:4;16557:1;16550:15;16584:4;16581:1;16574:15;16600:131;-1:-1:-1;;;;;;16674:32:1;;16664:43;;16654:2;;16721:1;16718;16711:12

Swarm Source

ipfs://1f224d9736d959d5e1f19f6982e35259c7bf46bef40e60e0fb17709504d2b165

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

Tools & Services