Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

    bool private _paused;

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
    }

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

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

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

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

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

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

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

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

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

        _owners[tokenId] = to;

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

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

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

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

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

        // Clear approvals
        delete _tokenApprovals[tokenId];

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId, 1);

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

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

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

        emit Transfer(from, to, tokenId);

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "../ERC721.sol";
import "./IERC721Enumerable.sol";

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev See {ERC721-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);

        if (batchSize > 1) {
            // Will only trigger during construction. Batch transferring (minting) is not available afterwards.
            revert("ERC721Enumerable: consecutive transfers not supported");
        }

        uint256 tokenId = firstTokenId;

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC721.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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.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`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

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

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

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

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

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

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

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

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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

pragma solidity ^0.8.0;

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

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

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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

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

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

import "./math/Math.sol";

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

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

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

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

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

contract JPEGALERTS is ERC721, ERC721Enumerable, Pausable, Ownable {
    using Counters for Counters.Counter;

    // private variables
    string private baseURI;
    Counters.Counter private tokenIdCounter;

    constructor() ERC721("JPEGALERTS", "JPEG ALERTS PASS") {
        tokenIdCounter.increment();
    }

    // public variables
    uint256 public maxSupply = 0;

    // publicMint variables
    bool public pubMintStatus = false;
    uint256 public pubWalletMintLimit = 0;
    uint256 public pubMintPrice = 0 ether;

    // whiteListMint variables
    mapping(address => bool) private whitelistedAddresses;
    bool public wlMintStatus = false;
    uint256 public wlWalletMintLimit = 0;
    uint256 public wlMintPrice = 0 ether;
    

    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }

    // set baseURI
    function setBaseURI(string memory value) public {
        baseURI = value;
    }

    // Get metadata URI
    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(_exists(tokenId), "ERC721: invalid token ID");

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

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

    // publicMint
    function publicMint(uint256 quantity) public payable {
        require(pubMintStatus, "public sale is not live");
        require(maxSupply > totalSupply(), "sold out");
        require(
            quantity > 0 &&
                (balanceOf(msg.sender) + quantity) <= pubWalletMintLimit,
            "invalid quantity"
        );
        require(msg.value >= (quantity * pubMintPrice), "insufficient eth");

        for (uint256 i = 0; i < quantity; i++) {
            uint256 tokenId = tokenIdCounter.current();
            _safeMint(msg.sender, tokenId);
            tokenIdCounter.increment();
        }
    }

    // whitelist Mint
    function whitelistMint(uint256 quantity) public payable {
        require(wlMintStatus, "whitelist sale is not live");
        require(maxSupply > totalSupply(), "sold out");
        require(
            whitelistedAddresses[msg.sender],
            "sorry you are not in the whitelist"
        );
        require(
            quantity > 0 &&
                (balanceOf(msg.sender) + quantity) <= wlWalletMintLimit,
            "invalid quantity"
        );
        require(msg.value >= (quantity * wlMintPrice), "insufficient eth");

        for (uint256 i = 0; i < quantity; i++) {
            uint256 tokenId = tokenIdCounter.current();
            _safeMint(msg.sender, tokenId);

            tokenIdCounter.increment();
        }
    }

    // configure public mint
    function configurePubMint(
        bool status,
        uint256 limitPerWallet,
        uint256 price
    ) public onlyOwner {
        pubMintStatus = status;
        pubWalletMintLimit = limitPerWallet;
        pubMintPrice = price;
    }

    // configure whitelist mint
    function configureWlMint(
        bool status,
        uint256 limitPerWallet,
        uint256 price
    ) public onlyOwner {
        wlMintStatus = status;
        wlWalletMintLimit = limitPerWallet;
        wlMintPrice = price;
    }

    // set whitelist addresses
    function addWhitelistAddresses(address[] calldata addresses)
        external
        onlyOwner
    {
        for (uint256 i = 0; i < addresses.length; i++) {
            whitelistedAddresses[addresses[i]] = true;
        }
    }

    // set public mint status
    function setMaxSupply(uint256 supply) public onlyOwner {
        maxSupply = supply;
    }

    // check whitelist status
    function isWhitelisted(address addr) public view returns (bool) {
        return whitelistedAddresses[addr];
    }

    // withdraw balance
    function withdrawBalance(address addr) external onlyOwner {
        uint256 balance = address(this).balance;
        payable(addr).transfer(balance);
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId,
        uint256 batchSize
    ) internal override(ERC721, ERC721Enumerable) whenNotPaused {
        super._beforeTokenTransfer(from, to, tokenId, batchSize);
    }

    // The following functions are overrides required by Solidity.

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721Enumerable)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"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":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":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":[{"internalType":"address[]","name":"addresses","type":"address[]"}],"name":"addWhitelistAddresses","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"bool","name":"status","type":"bool"},{"internalType":"uint256","name":"limitPerWallet","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"}],"name":"configurePubMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"status","type":"bool"},{"internalType":"uint256","name":"limitPerWallet","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"}],"name":"configureWlMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"addr","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pubMintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pubMintStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pubWalletMintLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"value","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"supply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"withdrawBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wlMintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wlMintStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wlWalletMintLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

410:4910:15:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5113:205;;;;;;;;;;-1:-1:-1;5113:205:15;;;;;:::i;:::-;;:::i;:::-;;;565:14:16;;558:22;540:41;;528:2;513:18;5113:205:15;;;;;;;;2471:98:2;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3935:167::-;;;;;;;;;;-1:-1:-1;3935:167:2;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:16;;;1679:51;;1667:2;1652:18;3935:167:2;1533:203:16;3468:406:2;;;;;;;;;;-1:-1:-1;3468:406:2;;;;;:::i;:::-;;:::i;:::-;;4082:229:15;;;;;;;;;;-1:-1:-1;4082:229:15;;;;;:::i;:::-;;:::i;815:33::-;;;;;;;;;;-1:-1:-1;815:33:15;;;;;;;;1630:111:5;;;;;;;;;;-1:-1:-1;1717:10:5;:17;1630:111;;;2944:25:16;;;2932:2;2917:18;1630:111:5;2798:177:16;3533:239:15;;;;;;;;;;-1:-1:-1;3533:239:15;;;;;:::i;:::-;;:::i;4612:326:2:-;;;;;;;;;;-1:-1:-1;4612:326:2;;;;;:::i;:::-;;:::i;1111:36:15:-;;;;;;;;;;;;;;;;2117:613;;;;;;:::i;:::-;;:::i;1306:253:5:-;;;;;;;;;;-1:-1:-1;1306:253:5;;;;;:::i;:::-;;:::i;4473:114:15:-;;;;;;;;;;-1:-1:-1;4473:114:15;;;;;:::i;:::-;-1:-1:-1;;;;;4554:26:15;4531:4;4554:26;;;:20;:26;;;;;;;;;4473:114;2030:63;;;;;;;;;;;;;:::i;5004:179:2:-;;;;;;;;;;-1:-1:-1;5004:179:2;;;;;:::i;:::-;;:::i;1813:230:5:-;;;;;;;;;;-1:-1:-1;1813:230:5;;;;;:::i;:::-;;:::i;1290:80:15:-;;;;;;;;;;-1:-1:-1;1290:80:15;;;;;:::i;:::-;;:::i;1615:84:1:-;;;;;;;;;;-1:-1:-1;1685:7:1;;;;1615:84;;3810:235:15;;;;;;;;;;-1:-1:-1;3810:235:15;;;;;:::i;:::-;;:::i;2190:219:2:-;;;;;;;;;;-1:-1:-1;2190:219:2;;;;;:::i;:::-;;:::i;4347:90:15:-;;;;;;;;;;-1:-1:-1;4347:90:15;;;;;:::i;:::-;;:::i;1929:204:2:-;;;;;;;;;;-1:-1:-1;1929:204:2;;;;;:::i;:::-;;:::i;1831:101:0:-;;;;;;;;;;;;;:::i;4617:155:15:-;;;;;;;;;;-1:-1:-1;4617:155:15;;;;;:::i;:::-;;:::i;1031:32::-;;;;;;;;;;-1:-1:-1;1031:32:15;;;;;;;;1965:59;;;;;;;;;;;;;:::i;2758:740::-;;;;;;:::i;:::-;;:::i;1201:85:0:-;;;;;;;;;;-1:-1:-1;1273:6:0;;;;;-1:-1:-1;;;;;1273:6:0;1201:85;;897:37:15;;;;;;;;;;;;;;;;2633:102:2;;;;;;;;;;;;;:::i;4169:153::-;;;;;;;;;;-1:-1:-1;4169:153:2;;;;;:::i;:::-;;:::i;5249:314::-;;;;;;;;;;-1:-1:-1;5249:314:2;;;;;:::i;:::-;;:::i;1400:559:15:-;;;;;;;;;;-1:-1:-1;1400:559:15;;;;;:::i;:::-;;:::i;752:28::-;;;;;;;;;;;;;;;;4388:162:2;;;;;;;;;;-1:-1:-1;4388:162:2;;;;;:::i;:::-;-1:-1:-1;;;;;4508:25:2;;;4485:4;4508:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;4388:162;2081:198:0;;;;;;;;;;-1:-1:-1;2081:198:0;;;;;:::i;:::-;;:::i;854:37:15:-;;;;;;;;;;;;;;;;1069:36;;;;;;;;;;;;;;;;5113:205;5248:4;5275:36;5299:11;5275:23;:36::i;:::-;5268:43;5113:205;-1:-1:-1;;5113:205:15:o;2471:98:2:-;2525:13;2557:5;2550:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2471:98;:::o;3935:167::-;4011:7;4030:23;4045:7;4030:14;:23::i;:::-;-1:-1:-1;4071:24:2;;;;:15;:24;;;;;;-1:-1:-1;;;;;4071:24:2;;3935:167::o;3468:406::-;3548:13;3564:23;3579:7;3564:14;:23::i;:::-;3548:39;;3611:5;-1:-1:-1;;;;;3605:11:2;:2;-1:-1:-1;;;;;3605:11:2;;3597:57;;;;-1:-1:-1;;;3597:57:2;;6998:2:16;3597:57:2;;;6980:21:16;7037:2;7017:18;;;7010:30;7076:34;7056:18;;;7049:62;-1:-1:-1;;;7127:18:16;;;7120:31;7168:19;;3597:57:2;;;;;;;;;719:10:9;-1:-1:-1;;;;;3686:21:2;;;;:62;;-1:-1:-1;3711:37:2;3728:5;719:10:9;4388:162:2;:::i;3711:37::-;3665:170;;;;-1:-1:-1;;;3665:170:2;;7400:2:16;3665:170:2;;;7382:21:16;7439:2;7419:18;;;7412:30;7478:34;7458:18;;;7451:62;7549:31;7529:18;;;7522:59;7598:19;;3665:170:2;7198:425:16;3665:170:2;3846:21;3855:2;3859:7;3846:8;:21::i;:::-;3538:336;3468:406;;:::o;4082:229:15:-;1094:13:0;:11;:13::i;:::-;4197:9:15::1;4192:113;4212:20:::0;;::::1;4192:113;;;4290:4;4253:20;:34;4274:9;;4284:1;4274:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;4253:34:15::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;4253:34:15;:41;;-1:-1:-1;;4253:41:15::1;::::0;::::1;;::::0;;;::::1;::::0;;4234:3;::::1;::::0;::::1;:::i;:::-;;;;4192:113;;3533:239:::0;1094:13:0;:11;:13::i;:::-;3668::15::1;:22:::0;;-1:-1:-1;;3668:22:15::1;::::0;::::1;;::::0;;;::::1;::::0;;;3700:18:::1;:35:::0;3745:12:::1;:20:::0;3533:239::o;4612:326:2:-;4801:41;719:10:9;4834:7:2;4801:18;:41::i;:::-;4793:99;;;;-1:-1:-1;;;4793:99:2;;;;;;;:::i;:::-;4903:28;4913:4;4919:2;4923:7;4903:9;:28::i;2117:613:15:-;2188:13;;;;2180:49;;;;-1:-1:-1;;;2180:49:15;;8648:2:16;2180:49:15;;;8630:21:16;8687:2;8667:18;;;8660:30;8726:25;8706:18;;;8699:53;8769:18;;2180:49:15;8446:347:16;2180:49:15;1717:10:5;:17;2247:9:15;;:25;2239:46;;;;-1:-1:-1;;;2239:46:15;;9000:2:16;2239:46:15;;;8982:21:16;9039:1;9019:18;;;9012:29;-1:-1:-1;;;9057:18:16;;;9050:38;9105:18;;2239:46:15;8798:331:16;2239:46:15;2327:1;2316:8;:12;:88;;;;;2386:18;;2373:8;2349:21;2359:10;2349:9;:21::i;:::-;:32;;;;:::i;:::-;2348:56;;2316:88;2295:151;;;;-1:-1:-1;;;2295:151:15;;9466:2:16;2295:151:15;;;9448:21:16;9505:2;9485:18;;;9478:30;-1:-1:-1;;;9524:18:16;;;9517:46;9580:18;;2295:151:15;9264:340:16;2295:151:15;2489:12;;2478:23;;:8;:23;:::i;:::-;2464:9;:38;;2456:67;;;;-1:-1:-1;;;2456:67:15;;9984:2:16;2456:67:15;;;9966:21:16;10023:2;10003:18;;;9996:30;-1:-1:-1;;;10042:18:16;;;10035:46;10098:18;;2456:67:15;9782:340:16;2456:67:15;2539:9;2534:190;2558:8;2554:1;:12;2534:190;;;2587:15;2605:24;:14;918::10;;827:112;2605:24:15;2587:42;;2643:30;2653:10;2665:7;2643:9;:30::i;:::-;2687:26;:14;1032:19:10;;1050:1;1032:19;;;945:123;2687:26:15;-1:-1:-1;2568:3:15;;;;:::i;:::-;;;;2534:190;;;;2117:613;:::o;1306:253:5:-;1403:7;1438:23;1455:5;1438:16;:23::i;:::-;1430:5;:31;1422:87;;;;-1:-1:-1;;;1422:87:5;;10329:2:16;1422:87:5;;;10311:21:16;10368:2;10348:18;;;10341:30;10407:34;10387:18;;;10380:62;-1:-1:-1;;;10458:18:16;;;10451:41;10509:19;;1422:87:5;10127:407:16;1422:87:5;-1:-1:-1;;;;;;1526:19:5;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;1306:253::o;2030:63:15:-;1094:13:0;:11;:13::i;:::-;2076:10:15::1;:8;:10::i;:::-;2030:63::o:0;5004:179:2:-;5137:39;5154:4;5160:2;5164:7;5137:39;;;;;;;;;;;;:16;:39::i;1813:230:5:-;1888:7;1923:30;1717:10;:17;;1630:111;1923:30;1915:5;:38;1907:95;;;;-1:-1:-1;;;1907:95:5;;10741:2:16;1907:95:5;;;10723:21:16;10780:2;10760:18;;;10753:30;10819:34;10799:18;;;10792:62;-1:-1:-1;;;10870:18:16;;;10863:42;10922:19;;1907:95:5;10539:408:16;1907:95:5;2019:10;2030:5;2019:17;;;;;;;;:::i;:::-;;;;;;;;;2012:24;;1813:230;;;:::o;1290:80:15:-;1348:7;:15;1358:5;1348:7;:15;:::i;3810:235::-;1094:13:0;:11;:13::i;:::-;3944:12:15::1;:21:::0;;-1:-1:-1;;3944:21:15::1;::::0;::::1;;::::0;;;::::1;::::0;;;3975:17:::1;:34:::0;4019:11:::1;:19:::0;3810:235::o;2190:219:2:-;2262:7;6930:16;;;:7;:16;;;;;;-1:-1:-1;;;;;6930:16:2;;2324:56;;;;-1:-1:-1;;;2324:56:2;;;;;;;:::i;4347:90:15:-;1094:13:0;:11;:13::i;:::-;4412:9:15::1;:18:::0;4347:90::o;1929:204:2:-;2001:7;-1:-1:-1;;;;;2028:19:2;;2020:73;;;;-1:-1:-1;;;2020:73:2;;13711:2:16;2020:73:2;;;13693:21:16;13750:2;13730:18;;;13723:30;13789:34;13769:18;;;13762:62;-1:-1:-1;;;13840:18:16;;;13833:39;13889:19;;2020:73:2;13509:405:16;2020:73:2;-1:-1:-1;;;;;;2110:16:2;;;;;:9;:16;;;;;;;1929:204::o;1831:101:0:-;1094:13;:11;:13::i;:::-;1895:30:::1;1922:1;1895:18;:30::i;4617:155:15:-:0;1094:13:0;:11;:13::i;:::-;4734:31:15::1;::::0;4703:21:::1;::::0;-1:-1:-1;;;;;4734:22:15;::::1;::::0;:31;::::1;;;::::0;4703:21;;4685:15:::1;4734:31:::0;4685:15;4734:31;4703:21;4734:22;:31;::::1;;;;;;;;;;;;;::::0;::::1;;;;1965:59:::0;1094:13:0;:11;:13::i;:::-;2009:8:15::1;:6;:8::i;2758:740::-:0;2832:12;;;;2824:51;;;;-1:-1:-1;;;2824:51:15;;14121:2:16;2824:51:15;;;14103:21:16;14160:2;14140:18;;;14133:30;14199:28;14179:18;;;14172:56;14245:18;;2824:51:15;13919:350:16;2824:51:15;1717:10:5;:17;2893:9:15;;:25;2885:46;;;;-1:-1:-1;;;2885:46:15;;9000:2:16;2885:46:15;;;8982:21:16;9039:1;9019:18;;;9012:29;-1:-1:-1;;;9057:18:16;;;9050:38;9105:18;;2885:46:15;8798:331:16;2885:46:15;2983:10;2962:32;;;;:20;:32;;;;;;;;2941:113;;;;-1:-1:-1;;;2941:113:15;;14476:2:16;2941:113:15;;;14458:21:16;14515:2;14495:18;;;14488:30;14554:34;14534:18;;;14527:62;-1:-1:-1;;;14605:18:16;;;14598:32;14647:19;;2941:113:15;14274:398:16;2941:113:15;3096:1;3085:8;:12;:87;;;;;3155:17;;3142:8;3118:21;3128:10;3118:9;:21::i;:::-;:32;;;;:::i;:::-;3117:55;;3085:87;3064:150;;;;-1:-1:-1;;;3064:150:15;;9466:2:16;3064:150:15;;;9448:21:16;9505:2;9485:18;;;9478:30;-1:-1:-1;;;9524:18:16;;;9517:46;9580:18;;3064:150:15;9264:340:16;3064:150:15;3257:11;;3246:22;;:8;:22;:::i;:::-;3232:9;:37;;3224:66;;;;-1:-1:-1;;;3224:66:15;;9984:2:16;3224:66:15;;;9966:21:16;10023:2;10003:18;;;9996:30;-1:-1:-1;;;10042:18:16;;;10035:46;10098:18;;3224:66:15;9782:340:16;3224:66:15;3306:9;3301:191;3325:8;3321:1;:12;3301:191;;;3354:15;3372:24;:14;918::10;;827:112;3372:24:15;3354:42;;3410:30;3420:10;3432:7;3410:9;:30::i;:::-;3455:26;:14;1032:19:10;;1050:1;1032:19;;;945:123;3455:26:15;-1:-1:-1;3335:3:15;;;;:::i;:::-;;;;3301:191;;2633:102:2;2689:13;2721:7;2714:14;;;;;:::i;4169:153::-;4263:52;719:10:9;4296:8:2;4306;4263:18;:52::i;5249:314::-;5417:41;719:10:9;5450:7:2;5417:18;:41::i;:::-;5409:99;;;;-1:-1:-1;;;5409:99:2;;;;;;;:::i;:::-;5518:38;5532:4;5538:2;5542:7;5551:4;5518:13;:38::i;:::-;5249:314;;;;:::o;1400:559:15:-;7321:4:2;6930:16;;;:7;:16;;;;;;1513:13:15;;-1:-1:-1;;;;;6930:16:2;1542:53:15;;;;-1:-1:-1;;;1542:53:15;;;;;;;:::i;:::-;1606:28;1637:10;:8;:10::i;:::-;1606:41;;1707:1;1682:14;1676:28;:32;:276;;;;;;;;;;;;;;;;;1797:14;1866:25;1883:7;1866:16;:25::i;:::-;1755:158;;;;;;;;;:::i;:::-;;;;;;;;;;;;;1676:276;1657:295;1400:559;-1:-1:-1;;;1400:559:15:o;2081:198:0:-;1094:13;:11;:13::i;:::-;-1:-1:-1;;;;;2169:22:0;::::1;2161:73;;;::::0;-1:-1:-1;;;2161:73:0;;15524:2:16;2161:73:0::1;::::0;::::1;15506:21:16::0;15563:2;15543:18;;;15536:30;15602:34;15582:18;;;15575:62;-1:-1:-1;;;15653:18:16;;;15646:36;15699:19;;2161:73:0::1;15322:402:16::0;2161:73:0::1;2244:28;2263:8;2244:18;:28::i;:::-;2081:198:::0;:::o;945:123:10:-;1032:19;;1050:1;1032:19;;;945:123::o;1005:222:5:-;1107:4;-1:-1:-1;;;;;;1130:50:5;;-1:-1:-1;;;1130:50:5;;:90;;;1184:36;1208:11;1184:23;:36::i;13466:133:2:-;7321:4;6930:16;;;:7;:16;;;;;;-1:-1:-1;;;;;6930:16:2;13539:53;;;;-1:-1:-1;;;13539:53:2;;;;;;;:::i;12768:171::-;12842:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;12842:29:2;-1:-1:-1;;;;;12842:29:2;;;;;;;;:24;;12895:23;12842:24;12895:14;:23::i;:::-;-1:-1:-1;;;;;12886:46:2;;;;;;;;;;;12768:171;;:::o;1359:130:0:-;1273:6;;-1:-1:-1;;;;;1273:6:0;;;;;719:10:9;1422:23:0;1414:68;;;;-1:-1:-1;;;1414:68:0;;15931:2:16;1414:68:0;;;15913:21:16;;;15950:18;;;15943:30;16009:34;15989:18;;;15982:62;16061:18;;1414:68:0;15729:356:16;7540:261:2;7633:4;7649:13;7665:23;7680:7;7665:14;:23::i;:::-;7649:39;;7717:5;-1:-1:-1;;;;;7706:16:2;:7;-1:-1:-1;;;;;7706:16:2;;:52;;;-1:-1:-1;;;;;;4508:25:2;;;4485:4;4508:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;7726:32;7706:87;;;;7786:7;-1:-1:-1;;;;;7762:31:2;:20;7774:7;7762:11;:20::i;:::-;-1:-1:-1;;;;;7762:31:2;;7706:87;7698:96;7540:261;-1:-1:-1;;;;7540:261:2:o;11423:1233::-;11577:4;-1:-1:-1;;;;;11550:31:2;:23;11565:7;11550:14;:23::i;:::-;-1:-1:-1;;;;;11550:31:2;;11542:81;;;;-1:-1:-1;;;11542:81:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;11641:16:2;;11633:65;;;;-1:-1:-1;;;11633:65:2;;16698:2:16;11633:65:2;;;16680:21:16;16737:2;16717:18;;;16710:30;16776:34;16756:18;;;16749:62;-1:-1:-1;;;16827:18:16;;;16820:34;16871:19;;11633:65:2;16496:400:16;11633:65:2;11709:42;11730:4;11736:2;11740:7;11749:1;11709:20;:42::i;:::-;11878:4;-1:-1:-1;;;;;11851:31:2;:23;11866:7;11851:14;:23::i;:::-;-1:-1:-1;;;;;11851:31:2;;11843:81;;;;-1:-1:-1;;;11843:81:2;;;;;;;:::i;:::-;11993:24;;;;:15;:24;;;;;;;;11986:31;;-1:-1:-1;;;;;;11986:31:2;;;;;;-1:-1:-1;;;;;12461:15:2;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;12461:20:2;;;12495:13;;;;;;;;;:18;;11986:31;12495:18;;;12533:16;;;:7;:16;;;;;;:21;;;;;;;;;;12570:27;;12009:7;;12570:27;;;3538:336;3468:406;;:::o;8131:108::-;8206:26;8216:2;8220:7;8206:26;;;;;;;;;;;;:9;:26::i;2433:117:1:-;1486:16;:14;:16::i;:::-;2491:7:::1;:15:::0;;-1:-1:-1;;2491:15:1::1;::::0;;2521:22:::1;719:10:9::0;2530:12:1::1;2521:22;::::0;-1:-1:-1;;;;;1697:32:16;;;1679:51;;1667:2;1652:18;2521:22:1::1;;;;;;;2433:117::o:0;:187:0:-;2525:6;;;-1:-1:-1;;;;;2541:17:0;;;2525:6;2541:17;;;-1:-1:-1;;;;;;2541:17:0;;;;;;2573:40;;2525:6;;;;;;;;2573:40;;2506:16;;2573:40;2496:124;2433:187;:::o;2186:115:1:-;1239:19;:17;:19::i;:::-;2245:7:::1;:14:::0;;-1:-1:-1;;2245:14:1::1;2255:4;2245:14;::::0;;2274:20:::1;2281:12;719:10:9::0;;640:96;13075:307:2;13225:8;-1:-1:-1;;;;;13216:17:2;:5;-1:-1:-1;;;;;13216:17:2;;13208:55;;;;-1:-1:-1;;;13208:55:2;;17103:2:16;13208:55:2;;;17085:21:16;17142:2;17122:18;;;17115:30;17181:27;17161:18;;;17154:55;17226:18;;13208:55:2;16901:349:16;13208:55:2;-1:-1:-1;;;;;13273:25:2;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;13273:46:2;;;;;;;;;;13334:41;;540::16;;;13334::2;;513:18:16;13334:41:2;;;;;;;13075:307;;;:::o;6424:305::-;6574:28;6584:4;6590:2;6594:7;6574:9;:28::i;:::-;6620:47;6643:4;6649:2;6653:7;6662:4;6620:22;:47::i;:::-;6612:110;;;;-1:-1:-1;;;6612:110:2;;;;;;;:::i;1159:106:15:-;1219:13;1251:7;1244:14;;;;;:::i;415:696:11:-;471:13;520:14;537:17;548:5;537:10;:17::i;:::-;557:1;537:21;520:38;;572:20;606:6;595:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;595:18:11;-1:-1:-1;572:41:11;-1:-1:-1;733:28:11;;;749:2;733:28;788:280;-1:-1:-1;;819:5:11;-1:-1:-1;;;953:2:11;942:14;;937:30;819:5;924:44;1012:2;1003:11;;;-1:-1:-1;1032:21:11;788:280;1032:21;-1:-1:-1;1088:6:11;415:696;-1:-1:-1;;;415:696:11:o;1570:300:2:-;1672:4;-1:-1:-1;;;;;;1707:40:2;;-1:-1:-1;;;1707:40:2;;:104;;-1:-1:-1;;;;;;;1763:48:2;;-1:-1:-1;;;1763:48:2;1707:104;:156;;;-1:-1:-1;;;;;;;;;;937:40:12;;;1827:36:2;829:155:12;4778:261:15;1239:19:1;:17;:19::i;:::-;4976:56:15::1;5003:4;5009:2;5013:7;5022:9;4976:26;:56::i;8460:309:2:-:0;8584:18;8590:2;8594:7;8584:5;:18::i;:::-;8633:53;8664:1;8668:2;8672:7;8681:4;8633:22;:53::i;:::-;8612:150;;;;-1:-1:-1;;;8612:150:2;;;;;;;:::i;1945:106:1:-;1685:7;;;;2003:41;;;;-1:-1:-1;;;2003:41:1;;18008:2:16;2003:41:1;;;17990:21:16;18047:2;18027:18;;;18020:30;-1:-1:-1;;;18066:18:16;;;18059:50;18126:18;;2003:41:1;17806:344:16;1767:106:1;1685:7;;;;1836:9;1828:38;;;;-1:-1:-1;;;1828:38:1;;18357:2:16;1828:38:1;;;18339:21:16;18396:2;18376:18;;;18369:30;-1:-1:-1;;;18415:18:16;;;18408:46;18471:18;;1828:38:1;18155:340:16;14151:831:2;14300:4;-1:-1:-1;;;;;14320:13:2;;1465:19:8;:23;14316:660:2;;14355:71;;-1:-1:-1;;;14355:71:2;;-1:-1:-1;;;;;14355:36:2;;;;;:71;;719:10:9;;14406:4:2;;14412:7;;14421:4;;14355:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14355:71:2;;;;;;;;-1:-1:-1;;14355:71:2;;;;;;;;;;;;:::i;:::-;;;14351:573;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14593:6;:13;14610:1;14593:18;14589:321;;14635:60;;-1:-1:-1;;;14635:60:2;;;;;;;:::i;14589:321::-;14862:6;14856:13;14847:6;14843:2;14839:15;14832:38;14351:573;-1:-1:-1;;;;;;14476:51:2;-1:-1:-1;;;14476:51:2;;-1:-1:-1;14469:58:2;;14316:660;-1:-1:-1;14961:4:2;14151:831;;;;;;:::o;9889:890:14:-;9942:7;;-1:-1:-1;;;10017:15:14;;10013:99;;-1:-1:-1;;;10052:15:14;;;-1:-1:-1;10095:2:14;10085:12;10013:99;10138:6;10129:5;:15;10125:99;;10173:6;10164:15;;;-1:-1:-1;10207:2:14;10197:12;10125:99;10250:6;10241:5;:15;10237:99;;10285:6;10276:15;;;-1:-1:-1;10319:2:14;10309:12;10237:99;10362:5;10353;:14;10349:96;;10396:5;10387:14;;;-1:-1:-1;10429:1:14;10419:11;10349:96;10471:5;10462;:14;10458:96;;10505:5;10496:14;;;-1:-1:-1;10538:1:14;10528:11;10458:96;10580:5;10571;:14;10567:96;;10614:5;10605:14;;;-1:-1:-1;10647:1:14;10637:11;10567:96;10689:5;10680;:14;10676:64;;10724:1;10714:11;10766:6;9889:890;-1:-1:-1;;9889:890:14:o;2112::5:-;2283:61;2310:4;2316:2;2320:12;2334:9;2283:26;:61::i;:::-;2371:1;2359:9;:13;2355:219;;;2500:63;;-1:-1:-1;;;2500:63:5;;19450:2:16;2500:63:5;;;19432:21:16;19489:2;19469:18;;;19462:30;19528:34;19508:18;;;19501:62;-1:-1:-1;;;19579:18:16;;;19572:51;19640:19;;2500:63:5;19248:417:16;2355:219:5;2602:12;-1:-1:-1;;;;;2629:18:5;;2625:183;;2663:40;2695:7;3811:10;:17;;3784:24;;;;:15;:24;;;;;:44;;;3838:24;;;;;;;;;;;;3708:161;2663:40;2625:183;;;2732:2;-1:-1:-1;;;;;2724:10:5;:4;-1:-1:-1;;;;;2724:10:5;;2720:88;;2750:47;2783:4;2789:7;2750:32;:47::i;:::-;-1:-1:-1;;;;;2821:16:5;;2817:179;;2853:45;2890:7;2853:36;:45::i;:::-;2817:179;;;2925:4;-1:-1:-1;;;;;2919:10:5;:2;-1:-1:-1;;;;;2919:10:5;;2915:81;;2945:40;2973:2;2977:7;2945:27;:40::i;:::-;2273:729;2112:890;;;;:::o;9091:920:2:-;-1:-1:-1;;;;;9170:16:2;;9162:61;;;;-1:-1:-1;;;9162:61:2;;19872:2:16;9162:61:2;;;19854:21:16;;;19891:18;;;19884:30;19950:34;19930:18;;;19923:62;20002:18;;9162:61:2;19670:356:16;9162:61:2;7321:4;6930:16;;;:7;:16;;;;;;-1:-1:-1;;;;;6930:16:2;7344:31;9233:58;;;;-1:-1:-1;;;9233:58:2;;20233:2:16;9233:58:2;;;20215:21:16;20272:2;20252:18;;;20245:30;20311;20291:18;;;20284:58;20359:18;;9233:58:2;20031:352:16;9233:58:2;9302:48;9331:1;9335:2;9339:7;9348:1;9302:20;:48::i;:::-;7321:4;6930:16;;;:7;:16;;;;;;-1:-1:-1;;;;;6930:16:2;7344:31;9437:58;;;;-1:-1:-1;;;9437:58:2;;20233:2:16;9437:58:2;;;20215:21:16;20272:2;20252:18;;;20245:30;20311;20291:18;;;20284:58;20359:18;;9437:58:2;20031:352:16;9437:58:2;-1:-1:-1;;;;;9837:13:2;;;;;;:9;:13;;;;;;;;:18;;9854:1;9837:18;;;9876:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9876:21:2;;;;;9913:33;9884:7;;9837:13;;9913:33;;9837:13;;9913:33;2534:190:15;2117:613;:::o;15698:396:2:-;15882:1;15870:9;:13;15866:222;;;-1:-1:-1;;;;;15903:18:2;;;15899:85;;-1:-1:-1;;;;;15941:15:2;;;;;;:9;:15;;;;;:28;;15960:9;;15941:15;:28;;15960:9;;15941:28;:::i;:::-;;;;-1:-1:-1;;15899:85:2;-1:-1:-1;;;;;16001:16:2;;;15997:81;;-1:-1:-1;;;;;16037:13:2;;;;;;:9;:13;;;;;:26;;16054:9;;16037:13;:26;;16054:9;;16037:26;:::i;:::-;;;;-1:-1:-1;;15698:396:2;;;;:::o;4486:970:5:-;4748:22;4798:1;4773:22;4790:4;4773:16;:22::i;:::-;:26;;;;:::i;:::-;4809:18;4830:26;;;:17;:26;;;;;;4748:51;;-1:-1:-1;4960:28:5;;;4956:323;;-1:-1:-1;;;;;5026:18:5;;5004:19;5026:18;;;:12;:18;;;;;;;;:34;;;;;;;;;5075:30;;;;;;:44;;;5191:30;;:17;:30;;;;;:43;;;4956:323;-1:-1:-1;5372:26:5;;;;:17;:26;;;;;;;;5365:33;;;-1:-1:-1;;;;;5415:18:5;;;;;:12;:18;;;;;:34;;;;;;;5408:41;4486:970::o;5744:1061::-;6018:10;:17;5993:22;;6018:21;;6038:1;;6018:21;:::i;:::-;6049:18;6070:24;;;:15;:24;;;;;;6438:10;:26;;5993:46;;-1:-1:-1;6070:24:5;;5993:46;;6438:26;;;;;;:::i;:::-;;;;;;;;;6416:48;;6500:11;6475:10;6486;6475:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;6579:28;;;:15;:28;;;;;;;:41;;;6748:24;;;;;6741:31;6782:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;5815:990;;;5744:1061;:::o;3296:217::-;3380:14;3397:20;3414:2;3397:16;:20::i;:::-;-1:-1:-1;;;;;3427:16:5;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;3471:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;3296:217:5:o;14:131:16:-;-1:-1:-1;;;;;;88:32:16;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:16;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:16;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:16:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:16;;1348:180;-1:-1:-1;1348:180:16:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:16;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:16:o;2178:615::-;2264:6;2272;2325:2;2313:9;2304:7;2300:23;2296:32;2293:52;;;2341:1;2338;2331:12;2293:52;2381:9;2368:23;2410:18;2451:2;2443:6;2440:14;2437:34;;;2467:1;2464;2457:12;2437:34;2505:6;2494:9;2490:22;2480:32;;2550:7;2543:4;2539:2;2535:13;2531:27;2521:55;;2572:1;2569;2562:12;2521:55;2612:2;2599:16;2638:2;2630:6;2627:14;2624:34;;;2654:1;2651;2644:12;2624:34;2707:7;2702:2;2692:6;2689:1;2685:14;2681:2;2677:23;2673:32;2670:45;2667:65;;;2728:1;2725;2718:12;2667:65;2759:2;2751:11;;;;;2781:6;;-1:-1:-1;2178:615:16;;-1:-1:-1;;;;2178:615:16:o;2980:160::-;3045:20;;3101:13;;3094:21;3084:32;;3074:60;;3130:1;3127;3120:12;3145:316;3219:6;3227;3235;3288:2;3276:9;3267:7;3263:23;3259:32;3256:52;;;3304:1;3301;3294:12;3256:52;3327:26;3343:9;3327:26;:::i;:::-;3317:36;3400:2;3385:18;;3372:32;;-1:-1:-1;3451:2:16;3436:18;;;3423:32;;3145:316;-1:-1:-1;;;3145:316:16:o;3466:328::-;3543:6;3551;3559;3612:2;3600:9;3591:7;3587:23;3583:32;3580:52;;;3628:1;3625;3618:12;3580:52;3651:29;3670:9;3651:29;:::i;:::-;3641:39;;3699:38;3733:2;3722:9;3718:18;3699:38;:::i;:::-;3689:48;;3784:2;3773:9;3769:18;3756:32;3746:42;;3466:328;;;;;:::o;3799:186::-;3858:6;3911:2;3899:9;3890:7;3886:23;3882:32;3879:52;;;3927:1;3924;3917:12;3879:52;3950:29;3969:9;3950:29;:::i;3990:127::-;4051:10;4046:3;4042:20;4039:1;4032:31;4082:4;4079:1;4072:15;4106:4;4103:1;4096:15;4122:632;4187:5;4217:18;4258:2;4250:6;4247:14;4244:40;;;4264:18;;:::i;:::-;4339:2;4333:9;4307:2;4393:15;;-1:-1:-1;;4389:24:16;;;4415:2;4385:33;4381:42;4369:55;;;4439:18;;;4459:22;;;4436:46;4433:72;;;4485:18;;:::i;:::-;4525:10;4521:2;4514:22;4554:6;4545:15;;4584:6;4576;4569:22;4624:3;4615:6;4610:3;4606:16;4603:25;4600:45;;;4641:1;4638;4631:12;4600:45;4691:6;4686:3;4679:4;4671:6;4667:17;4654:44;4746:1;4739:4;4730:6;4722;4718:19;4714:30;4707:41;;;;4122:632;;;;;:::o;4759:451::-;4828:6;4881:2;4869:9;4860:7;4856:23;4852:32;4849:52;;;4897:1;4894;4887:12;4849:52;4937:9;4924:23;4970:18;4962:6;4959:30;4956:50;;;5002:1;4999;4992:12;4956:50;5025:22;;5078:4;5070:13;;5066:27;-1:-1:-1;5056:55:16;;5107:1;5104;5097:12;5056:55;5130:74;5196:7;5191:2;5178:16;5173:2;5169;5165:11;5130:74;:::i;5215:254::-;5280:6;5288;5341:2;5329:9;5320:7;5316:23;5312:32;5309:52;;;5357:1;5354;5347:12;5309:52;5380:29;5399:9;5380:29;:::i;:::-;5370:39;;5428:35;5459:2;5448:9;5444:18;5428:35;:::i;:::-;5418:45;;5215:254;;;;;:::o;5474:667::-;5569:6;5577;5585;5593;5646:3;5634:9;5625:7;5621:23;5617:33;5614:53;;;5663:1;5660;5653:12;5614:53;5686:29;5705:9;5686:29;:::i;:::-;5676:39;;5734:38;5768:2;5757:9;5753:18;5734:38;:::i;:::-;5724:48;;5819:2;5808:9;5804:18;5791:32;5781:42;;5874:2;5863:9;5859:18;5846:32;5901:18;5893:6;5890:30;5887:50;;;5933:1;5930;5923:12;5887:50;5956:22;;6009:4;6001:13;;5997:27;-1:-1:-1;5987:55:16;;6038:1;6035;6028:12;5987:55;6061:74;6127:7;6122:2;6109:16;6104:2;6100;6096:11;6061:74;:::i;:::-;6051:84;;;5474:667;;;;;;;:::o;6146:260::-;6214:6;6222;6275:2;6263:9;6254:7;6250:23;6246:32;6243:52;;;6291:1;6288;6281:12;6243:52;6314:29;6333:9;6314:29;:::i;:::-;6304:39;;6362:38;6396:2;6385:9;6381:18;6362:38;:::i;6411:380::-;6490:1;6486:12;;;;6533;;;6554:61;;6608:4;6600:6;6596:17;6586:27;;6554:61;6661:2;6653:6;6650:14;6630:18;6627:38;6624:161;;6707:10;6702:3;6698:20;6695:1;6688:31;6742:4;6739:1;6732:15;6770:4;6767:1;6760:15;6624:161;;6411:380;;;:::o;7628:127::-;7689:10;7684:3;7680:20;7677:1;7670:31;7720:4;7717:1;7710:15;7744:4;7741:1;7734:15;7760:127;7821:10;7816:3;7812:20;7809:1;7802:31;7852:4;7849:1;7842:15;7876:4;7873:1;7866:15;7892:135;7931:3;7952:17;;;7949:43;;7972:18;;:::i;:::-;-1:-1:-1;8019:1:16;8008:13;;7892:135::o;8032:409::-;8234:2;8216:21;;;8273:2;8253:18;;;8246:30;8312:34;8307:2;8292:18;;8285:62;-1:-1:-1;;;8378:2:16;8363:18;;8356:43;8431:3;8416:19;;8032:409::o;9134:125::-;9199:9;;;9220:10;;;9217:36;;;9233:18;;:::i;9609:168::-;9682:9;;;9713;;9730:15;;;9724:22;;9710:37;9700:71;;9751:18;;:::i;11078:545::-;11180:2;11175:3;11172:11;11169:448;;;11216:1;11241:5;11237:2;11230:17;11286:4;11282:2;11272:19;11356:2;11344:10;11340:19;11337:1;11333:27;11327:4;11323:38;11392:4;11380:10;11377:20;11374:47;;;-1:-1:-1;11415:4:16;11374:47;11470:2;11465:3;11461:12;11458:1;11454:20;11448:4;11444:31;11434:41;;11525:82;11543:2;11536:5;11533:13;11525:82;;;11588:17;;;11569:1;11558:13;11525:82;;;11529:3;;;11078:545;;;:::o;11799:1352::-;11925:3;11919:10;11952:18;11944:6;11941:30;11938:56;;;11974:18;;:::i;:::-;12003:97;12093:6;12053:38;12085:4;12079:11;12053:38;:::i;:::-;12047:4;12003:97;:::i;:::-;12155:4;;12219:2;12208:14;;12236:1;12231:663;;;;12938:1;12955:6;12952:89;;;-1:-1:-1;13007:19:16;;;13001:26;12952:89;-1:-1:-1;;11756:1:16;11752:11;;;11748:24;11744:29;11734:40;11780:1;11776:11;;;11731:57;13054:81;;12201:944;;12231:663;11025:1;11018:14;;;11062:4;11049:18;;-1:-1:-1;;12267:20:16;;;12385:236;12399:7;12396:1;12393:14;12385:236;;;12488:19;;;12482:26;12467:42;;12580:27;;;;12548:1;12536:14;;;;12415:19;;12385:236;;;12389:3;12649:6;12640:7;12637:19;12634:201;;;12710:19;;;12704:26;-1:-1:-1;;12793:1:16;12789:14;;;12805:3;12785:24;12781:37;12777:42;12762:58;12747:74;;12634:201;-1:-1:-1;;;;;12881:1:16;12865:14;;;12861:22;12848:36;;-1:-1:-1;11799:1352:16:o;13156:348::-;13358:2;13340:21;;;13397:2;13377:18;;;13370:30;13436:26;13431:2;13416:18;;13409:54;13495:2;13480:18;;13156:348::o;14677:640::-;14957:3;14995:6;14989:13;15011:66;15070:6;15065:3;15058:4;15050:6;15046:17;15011:66;:::i;:::-;-1:-1:-1;;;15099:16:16;;;15124:18;;;15167:13;;15189:78;15167:13;15254:1;15243:13;;15236:4;15224:17;;15189:78;:::i;:::-;15287:20;15309:1;15283:28;;14677:640;-1:-1:-1;;;;14677:640:16:o;16090:401::-;16292:2;16274:21;;;16331:2;16311:18;;;16304:30;16370:34;16365:2;16350:18;;16343:62;-1:-1:-1;;;16436:2:16;16421:18;;16414:35;16481:3;16466:19;;16090:401::o;17255:414::-;17457:2;17439:21;;;17496:2;17476:18;;;17469:30;17535:34;17530:2;17515:18;;17508:62;-1:-1:-1;;;17601:2:16;17586:18;;17579:48;17659:3;17644:19;;17255:414::o;18500:489::-;-1:-1:-1;;;;;18769:15:16;;;18751:34;;18821:15;;18816:2;18801:18;;18794:43;18868:2;18853:18;;18846:34;;;18916:3;18911:2;18896:18;;18889:31;;;18694:4;;18937:46;;18963:19;;18955:6;18937:46;:::i;:::-;18929:54;18500:489;-1:-1:-1;;;;;;18500:489:16:o;18994:249::-;19063:6;19116:2;19104:9;19095:7;19091:23;19087:32;19084:52;;;19132:1;19129;19122:12;19084:52;19164:9;19158:16;19183:30;19207:5;19183:30;:::i;20388:128::-;20455:9;;;20476:11;;;20473:37;;;20490:18;;:::i;20521:127::-;20582:10;20577:3;20573:20;20570:1;20563:31;20613:4;20610:1;20603:15;20637:4;20634:1;20627:15

ipfs://72a2a59cee921d92b2e288d869746e7085ed6c9c9161b898c081e232dde83a3e