Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
•    - function supportsInterface(bytes4 int ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
•    - function onERC721Received(
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function current(Counter storage coun ...
•    - function increment(Counter storage co ...
•    - function decrement(Counter storage co ...
•    - function reset(Counter storage counte ...
•    - function supportsInterface(bytes4 int ...
•    - function _throwError(RecoverError err ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes ...
•    - function tryRecover(bytes32 hash, byt ...
•    - function recover(bytes32 hash, bytes3 ...
•    - function tryRecover(bytes32 hash, uin ...
•    - function recover(bytes32 hash, uint8 ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toEthSignedMessageHash(bytes ...
•    - function toTypedDataHash(bytes32 doma ...
•    - function toDataWithIntendedValidatorH ...
•    - function _startTokenId()
•    - function totalSupply()
•    - function _totalMinted()
•    - function supportsInterface(bytes4 int ...
•    - function balanceOf(address owner)
•    - function _numberMinted(address owner)
•    - function _numberBurned(address owner)
•    - function _getAux(address owner)
•    - function _setAux(address owner, uint6 ...
•    - function _ownershipOf(uint256 tokenId ...
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function _baseURI()
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function _exists(uint256 tokenId)
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(
•    - function _mint(
•    - function _transfer(
•    - function _burn(uint256 tokenId)
•    - function _burn(uint256 tokenId, bool ...
•    - function _approve(
•    - function _checkContractOnERC721Receiv ...
•    - function _beforeTokenTransfers(
•    - function _afterTokenTransfers(
•    - function getAddressSlot(bytes32 slot)
•    - function getBooleanSlot(bytes32 slot)
•    - function getBytes32Slot(bytes32 slot)
•    - function getUint256Slot(bytes32 slot)
•    - function getStringSlot(bytes32 slot)
•    - function getStringSlot(string storage ...
•    - function getBytesSlot(bytes32 slot)
•    - function getBytesSlot(bytes storage s ...
•    - function toShortString(string memory ...
•    - function toString(ShortString sstr)
•    - function length(ShortString sstr)
•    - function toShortStringWithFallback(st ...
•    - function toStringWithFallback(ShortSt ...
•    - function eip712Domain()
•    - function _domainSeparatorV4()
•    - function _buildDomainSeparator()
•    - function _hashTypedDataV4(bytes32 str ...
•    - function eip712Domain()
•    - function presaleMint(uint qty, uint n ...
•    - function check(uint256 qty, uint256 n ...
•    - function _verify(uint256 qty, uint256 ...
•    - function _hash(uint256 qty, uint256 n ...
•    - function publicMint(uint qty)
•    - function devMint(uint qty)
•    - function bulkDrop(address[] memory us ...
•    - function bind(uint256 tokenId, bool b ...
•    - function burn(uint256 tokenId)
•    - function _beforeTokenTransfers(addres ...
•    - function _burn(uint256 tokenId)
•    - function totalBound()
•    - function _baseURI()
•    - function exists(uint256 tokenId)
•    - function tokenURI(uint tokenId)
•    - function setBoundURI(string memory _b ...
•    - function setBindRate(uint256 _rate)
•    - function setPhase(uint _phase)
•    - function setValidator(address _valida ...
•    - function setPresaleOnly(bool _state)
•    - function pause(bool _state)
•    - function withdraw()
•    - function revoke(uint256 tokenId)
•    - function setBaseURI(string memory bas ...
•    - function setRevealed(bool _state)
•    - function setNR(string memory _nr)
•    - function setMaxBound(uint256 _maxBoun ...
•    - function tokensOfOwner(address owner)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-03-23
*/

// File: contracts/NowPass.sol



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

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

pragma solidity ^0.8.0;
    //Ownable.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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        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);
    }
}

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

pragma solidity ^0.8.0;
    //IERC20.sol
/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
    interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

pragma solidity ^0.8.1;
    //Address.sol
/**
 * @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 functionCall(target, data, "Address: low-level call failed");
    }

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

pragma solidity ^0.8.0;
    //SafeERC20.sol
/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
    library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

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

pragma solidity ^0.8.0;
    //IERC721.sol
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
    interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

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

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}

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

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

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

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

pragma solidity ^0.8.0;
    //IERC721Enumerable.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);
}

pragma solidity ^0.8.0;
    //Strings.sol
/**
 * @dev String operations.
 */
    library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

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

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

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

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

pragma solidity ^0.8.0;
    //Counters.sol
/**
 * @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;
    }
}
pragma solidity ^0.8.0;
    //ERC165.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;
    }
}

pragma solidity ^0.8.0;
    //ECDSA.sol
/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
    library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

pragma solidity ^0.8.4;



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

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

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

    

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

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

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

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

  
 
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
        
    }
    
    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 1;
    }

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

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

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        
        return uint256(_addressData[owner].balance);
    }

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

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

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

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

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

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

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

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

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

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

        string memory 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 overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return '';
    }

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

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

        _approve(to, tokenId, owner);
    }

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

        return _tokenApprovals[tokenId];
    }

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

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;
    }

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

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

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        
        uint256 startTokenId = _currentIndex;
        
        if (quantity == 0) revert MintZeroQuantity();
          
        _beforeTokenTransfers(address(0), to, startTokenId, quantity);
       
        
        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

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

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

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

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

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

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

        _beforeTokenTransfers(from, to, tokenId, 1);

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

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

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

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

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

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

        address from = prevOwnership.addr;

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

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.0;
    //StorageSlot.sol
/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
    library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

pragma solidity ^0.8.8;


    type ShortString is bytes32;
    //ShortStrings.sol
/**
 * @dev This library provides functions to convert short memory strings
 * into a `ShortString` type that can be used as an immutable variable.
 * Strings of arbitrary length can be optimized if they are short enough by
 * the addition of a storage variable used as fallback.
 *
 * Usage example:
 *
 * ```solidity
 * contract Named {
 *     using ShortStrings for *;
 *
 *     ShortString private immutable _name;
 *     string private _nameFallback;
 *
 *     constructor(string memory contractName) {
 *         _name = contractName.toShortStringWithFallback(_nameFallback);
 *     }
 *
 *     function name() external view returns (string memory) {
 *         return _name.toStringWithFallback(_nameFallback);
 *     }
 * }
 * ```
 */
    library ShortStrings {
    error StringTooLong(string str);

    /**
     * @dev Encode a string of at most 31 chars into a `ShortString`.
     *
     * This will trigger a `StringTooLong` error is the input string is too long.
     */
    function toShortString(string memory str) internal pure returns (ShortString) {
        bytes memory bstr = bytes(str);
        if (bstr.length > 31) {
            revert StringTooLong(str);
        }
        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
    }

    /**
     * @dev Decode a `ShortString` back to a "normal" string.
     */
    function toString(ShortString sstr) internal pure returns (string memory) {
        uint256 len = length(sstr);
        // using `new string(len)` would work locally but is not memory safe.
        string memory str = new string(32);
        /// @solidity memory-safe-assembly
        assembly {
            mstore(str, len)
            mstore(add(str, 0x20), sstr)
        }
        return str;
    }

    /**
     * @dev Return the length of a `ShortString`.
     */
    function length(ShortString sstr) internal pure returns (uint256) {
        return uint256(ShortString.unwrap(sstr)) & 0xFF;
    }

    /**
     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.
     */
    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
        if (bytes(value).length < 32) {
            return toShortString(value);
        } else {
            StorageSlot.getStringSlot(store).value = value;
            return ShortString.wrap(0);
        }
    }

    /**
     * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
     */
    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
        if (length(value) > 0) {
            return toString(value);
        } else {
            return store;
        }
    }
}

pragma solidity ^0.8.0;
    //IERC5267.sol
    interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );   
}

pragma solidity ^0.8.8;
    //EIP712.sol
/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the `_domainSeparatorV4` function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 *
 * _Available since v3.4._
 *
 * @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
 */
    abstract contract EIP712 is IERC5267 {
    using ShortStrings for *;

    bytes32 private constant _TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _cachedDomainSeparator;
    uint256 private immutable _cachedChainId;
    address private immutable _cachedThis;

    ShortString private immutable _name;
    ShortString private immutable _version;
    string private _nameFallback;
    string private _versionFallback;

    bytes32 private immutable _hashedName;
    bytes32 private immutable _hashedVersion;

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        _name = name.toShortStringWithFallback(_nameFallback);
        _version = version.toShortStringWithFallback(_versionFallback);
        _hashedName = keccak256(bytes(name));
        _hashedVersion = keccak256(bytes(version));

        _cachedChainId = block.chainid;
        _cachedDomainSeparator = _buildDomainSeparator();
        _cachedThis = address(this);
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
            return _cachedDomainSeparator;
        } else {
            return _buildDomainSeparator();
        }
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {EIP-5267}.
     */
    function eip712Domain()
        public
        view
        virtual
        override
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        return (
            hex"0f", // 01111
            _name.toStringWithFallback(_nameFallback),
            _version.toStringWithFallback(_versionFallback),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }
}


pragma solidity ^0.8.4;
/*
MMMMMMMWKKWMMMMMMMMMMMMMMMMMMWOkNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMM0ll0WMMMMMMMMMMMMMMW0l:OWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMWO,.cONMMMMMMMMMMW0c.,OWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMM0; .;kNMMMMMMWOc. ,0WMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMK:   ,dXMMWO:.  ;0MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMXc    'ox:.   :KMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMXl          cXMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMNo.      .lXMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMWk;.  .;kNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMN0kk0NMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMWX0kxxxkO0XWMMMMMMMMMMMMMMMMMMWNKOOkdddxk0XNWMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWWWWWWWWWWWWWWWWWWMMWWWWWWWWWWWWWM
NOxoc::::::::::::oXW0o:..      ..;o0WMMMMMMMMMMMWXkl;':xOOx;   ..',lxKWWKkxdc:;;;;;;;;;;;;cxXWKxo:;;;;;;;;;;;;;ox0NKkxdc;;;;;:oxkK
WNXKl.           .oddxOkc.         .cKWMMMMMMMNOc.   ,0MMMMNl        .:kXNNXx.            ,0WMWNKc             oNWMWWWXo.   'xXWWW
MMMMK,            ;OWMMMNc           ,0MMMMMWO;.     oWMMMMMK,          ;kNMWx.           .kMMMMM0'            ;XMMMMMMX:  :KMMMMM
MMMMK,            dWMMMMWd            lNMMMXl.       dWMMMMMWd.          .cKMXc            :XMMMMWo            .dWMMMMMWl ;KMMMMMM
MMMMK,           .xMMMMMWd            ;KMM0;         lWMMMMMM0'            ,0WO.           .xMMMMMK,            ;KMMMMMNc,OMMMMMMM
MMMMK;           .xMMMMMWd            ,KMK;          :XMMMMMMX:             ;KNl            ;XMMMMX:            .dWMMMM0cxWMMMMMMM
MMMMK;           .xMMMMMWd            ,KWo           ,KMMMMMMWl              lN0'           .dWMMWk:'            ,KMMMWdoXMMMMMMMM
MMMMK;           .xMMMMMWd            ,K0'           .kMMMMMMMx.             '0Wd.           ,KMMXoxk.            oWMMOlOMMMMMMMMM
MMMMK;           .xMMMMMWd            ,Kk.           .dWMMMMMMO'             .kMK;           .dWWxoXNl            ,0MNodNMMMMMMMMM
MMMMK;           .xMMMMMWd            ,Kx.            cNMMMMMMX;             .kMWx.           ,0KokWM0'            oNkl0MMMMMMMMMM
MMMMK;           .xMMMMMWd            ,KO.            ;KMMMMMMNl             '0MMX:            lddNMMWo            'xlxWMMMMMMMMMM
MMMMK;           .xMMMMMWd            ,KX:            .OMMMMMMWd.            lNMMMO.           .;OMMMMK;            .lXMMMMMMMMMMM
MMMMK;           .xMMMMMWd            ,KWO.            dWMMMMMMk.           :KMMMMNl            lNMMMMWx.           .kMMMMMMMMMMMM
MMMMK;           .xMMMMMWd            ,KMWk'           :XMMMMMM0'          cKMMMMMM0'          'OMMMMMMX:           lNMMMMMMMMMMMM
MMMMK;           .xMMMMMWd            ,KMMMK:.         .OMMMMMMK,        .dNMMMMMMMWo.         oWMMMMMMMO.         '0MMMMMMMMMMMMM
MMMMK,           .xMMMMMWd            ,KMMMMNk;.        cNMMMMMK,      .lKWMMMMMMMMMK;        ,0MMMMMMMMNl        .dWMMMMMMMMMMMMM
MWWNx.           .dWMMMMXc            .kWMMMMMNOl'      .xWMMMMk.    'l0WMMMMMMMMMMMWx.      .oWMMMMMMMMM0'       ;XMMMMMMMMMMMMMM
Kxxo;'''''''''''''cxONXko;'''''''''''',cxkONMMMMMNOo:'.  .lOK0x;.';lkNMMMMMMMMMMMMMMMXc......:KMMMMMMMMMMWd......'kMMMMMMMMMMMMMMM
WNNNNNNNNNNNNNNNNNNNNWWWNNNNNWNNNNNNNNNNNNWMMMMMMMMMWNKOxddxkOk0XNWMMMMMMMMMMMMMMMMMMMNKKKKKKXWMMMMMMMMMMMWKKKKKKXWMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
0oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooood0
                                                                                                                                 
                    .'''''...                    .'''.                      .',,'.                   ..,,,'.                     
                   .xNNNNNNNKOl.                'ONNNK:                  .:kXNXXNXOl.              'd0NNXXXKx,                   
                   .kMMKo::dXMWd.              .kWWNWM0,                 :XMWx;':xOk:             .kMMKc',oOOo.                  
                   .kMM0;..cKMMx.             .oNMO:xWWk.                ;KMWXkdooc,.             .xWMNOxdoo:.                   
                   .kMMWXXXNWNk,              cXMWx;oXMWd.                'lxO0XNWWXl.             .:dk0KXWMNk'                  
                   .kMMKocc:;'               ;KMMWNNNWMMNl               ;odl,..cKMMO.            .loo:..,xWMNc                  
                   .kMMO.                   'OMWk;,,,;xWMK;              ,kNWXOOKWW0:             .lKWN0OOXWXd.                  
                    ,cl;                    .cl:.     .:lc,                ':loolc,.                .;clool:.                    
                                                                                                                                                                                                                                                               

*/

    contract NowPass is ERC721A, EIP712, Ownable {
    using Counters for Counters.Counter;
    using Strings for uint;

    Counters.Counter private bindCounter;
    
    string private constant SIGNING_DOMAIN = "NOWPASS";
    string private constant SIGNATURE_VERSION = "1";

    uint256 public publicCost = 0.25 ether;
    uint public maxSupply = 2750;
    uint256 public bindRate;
    uint public maxBound = 0;

    mapping(uint256 => bool) public binds;
    mapping(bytes => bool) public sigs;
  
    string public boundURI;
    string public NR = "ipfs://HIDDEN_METADATA/";
    bool public presaleOnly = true;
    bool public revealed = false;
    bool public paused = true;
    uint public phase = 0;
    address public validator;

    event DevMinted(address indexed to, uint256 quantity, uint256 indexed tokenId);
    event PresaleMinted(address indexed to, uint256 quantity, uint256 indexed tokenId);
    event PublicMinted(address indexed to, uint256 quantity, uint256 indexed tokenId);
    event Revoke(address indexed to, uint256 indexed tokenId);
    event Bind(address indexed from, uint256 indexed tokenId);

    constructor() ERC721A("NOWPASS", "NOW") EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION)
    {
        validator = owner();
    }
    
//****Minting Functions*****

    //@dev Presale ECDSA verified that signature and typed message resolves to Owner or a set Validator's wallet
    
        function presaleMint(uint qty, uint nonce, address addr, bytes memory signature) external payable 
        {
            uint tm = totalSupply();
            uint _cost = publicCost;

            require(paused==false, "Paused");
            require(check(qty, nonce, addr, signature) == validator, "Not verified");
            require(addr == msg.sender, "Destination address and sender dont match");
            require(sigs[signature] == false, "This signature has already been used");
            require(_numberMinted(msg.sender) + qty < 3, "Exceeds limit"); 
            require(tm + qty < 2751, "SOLD OUT!");
            require(msg.value + 1 > qty * _cost, "Not Enough ETH sent");
                               
        sigs[signature] = true;                                          
        _mint(addr, qty,"", false);

        emit PresaleMinted(addr, qty, tm + qty);
        }

    //@dev used for ECDSA signature verification

        function check(uint256 qty, uint256 nonce, address addr, bytes memory signature) public view returns (address) 
        {
            return _verify(qty, nonce, addr, signature);
        }

        function _verify(uint256 qty, uint256 nonce, address addr, bytes memory signature) internal view returns (address) 
        {
            bytes32 digest = _hash(qty, nonce, addr);
            return ECDSA.recover(digest, signature);
        }

        function _hash(uint256 qty, uint256 nonce, address addr) internal view returns (bytes32) 
        {
            return _hashTypedDataV4(keccak256(abi.encode(
                keccak256("Web3Struct(uint256 qty,uint256 nonce,address addr)"),
                qty,
                nonce,
                addr
        )));
        }

    //@dev Public mint with no ECDSA verfication

        function publicMint(uint qty) external payable 
        {
            uint tm = totalSupply();
            uint _cost = publicCost;

            require(_numberMinted(msg.sender) + qty < 4, "Exceeds limit"); 
            require(paused==false,"Paused");
            require(presaleOnly==false,"Presale Only");       
            require(msg.sender == tx.origin, "no bots");       
            require(tm + qty < 2751, "SOLD OUT!");
            require(msg.value + 1 > qty * _cost, "Not Enough ETH sent");

        _mint(msg.sender, qty,"", false);

        emit PublicMinted(msg.sender, qty, tm + qty);        
     
        }

    //@dev Developer Mints to Owner wallet    
    
        function devMint(uint qty) public onlyOwner 
        {
            uint tm = totalSupply();
            require(tm + qty < 2751, "SOLD OUT!");  
            
        _mint(msg.sender, qty,"", false);
            
        emit DevMinted(msg.sender, qty, tm + qty);

        }

    //@dev Bulk Mint to users wallets *CAUTION* NO CHECKS

        function bulkDrop(address[] memory users) external onlyOwner 
        {

            for (uint256 i; i < users.length; i++) 
            {
            uint tm = totalSupply();
            require(tm + 1 < 2751, "SOLD OUT!"); 

        _mint(users[i], 1, '', true);

        emit DevMinted(users[i], 1, tm + 1);             
            }
        }


//****Binding Functions*****

    // Function to BIND the token to the users wallet permanently. Philosophical opposite of BURN. BINDING allows for off-chain incentives through the lens of customer loyalty.
        function bind(uint256 tokenId, bool bindVal) public payable 
        {
            require(maxBound > 0, "Binding not available yet");
            require(ownerOf(tokenId) == msg.sender, "Only owner of the token can bind it");
            require(bindVal == true, "Bind value must be true");
            require(bindCounter.current() < maxBound, "No more tokens can currently be bound");
            require(msg.value >= bindRate, "Not enough ether sent to bind");
            
        bindCounter.increment();
        binds[tokenId] = bindVal;
        emit Bind(msg.sender,tokenId);
        }

    // Function to BURN the token.
        function burn(uint256 tokenId) external 
        {
            require(ownerOf(tokenId) == msg.sender, "Only owner of the token can burn it");

            if (binds[tokenId] == true) 
            {
                binds[tokenId] = false;
                bindCounter.decrement();
            }

            _burn(tokenId);
        }


    // Function to ensure is a token is not BOUND before transfer
        function _beforeTokenTransfers(address from, address to, uint256 tokenId, uint quantity) internal virtual override(ERC721A)
        {
            if (binds[tokenId] == true) 
            {
                require(from == address(0) || to == address(0), "Not allowed to transfer token");            
            }
        }

        function _burn(uint256 tokenId) internal override(ERC721A) 
        {
            super._burn(tokenId);
        }
   
    // Function to return the total number of BOUND tokens
        function totalBound() public view returns (uint256) 
        {
            return bindCounter.current();
        } 

//****Metadata Functions****

        string private _baseTokenURI;

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

        function exists(uint256 tokenId) public view returns (bool) 
        {
            return _exists(tokenId);
        }

    // Function to set the tokenURI based on whether the collection has been revealed and if it is bound
        function tokenURI(uint tokenId) public view virtual override(ERC721A) returns (string memory) 
        {
            if (revealed == false) 
            {
                return NR;
            }

            else if (binds[tokenId] == true){
    
                    return bytes(boundURI).length > 0
            ? string(abi.encodePacked(boundURI, tokenId.toString(), ".json"))
            : "";
            }

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



    //@dev Function to set the URI for bound tokens in the collection
        function setBoundURI(string memory _boundURI) public onlyOwner 
        {
            boundURI = _boundURI;
        } 

    //@dev Function to set the price for Binding
        function setBindRate(uint256 _rate) public onlyOwner 
        {
            bindRate = _rate;
        }         

    //@dev Set the phase of the mint
        function setPhase(uint _phase) public onlyOwner 
        {
            phase = _phase;
        }   

    //@dev Set an approved validator for the Minting website
        function setValidator(address _validator) public onlyOwner 
        {
            require(_validator != address(0), "Validator cannot be address 0");
            validator = _validator;
        }
    
    //@dev Set the state of presale period
        function setPresaleOnly(bool _state) external onlyOwner 
        {
            if (presaleOnly == false) 
            {
                require(_state == false, "Cannot go back to presale");
            }
            
            presaleOnly = _state;//set to false for main mint
        }

    //@dev Pause the mint
        function pause(bool _state) public onlyOwner() 
        {
            paused = _state;
        }
    
    //@dev withdraws all remaining funds from the smart contract
        function withdraw() public payable onlyOwner 
        {
            (bool success, ) = payable(msg.sender).call{value: address(this).balance}("");
            require(success);
        }

        function revoke(uint256 tokenId) external onlyOwner 
        {
            require(ownerOf(tokenId) == msg.sender, "Only owner of the token can burn it");

            if (binds[tokenId] == true) 
            {
                binds[tokenId] = false;
                bindCounter.decrement();
            }

            _burn(tokenId);
        }

    //@dev Sets the base URI of the collection
        function setBaseURI(string memory baseURI) external onlyOwner 
        {
            _baseTokenURI = baseURI;
        }

    //@dev Sets the state of whether the collection metadata is revealed
        function setRevealed(bool _state) public onlyOwner 
        {
            require(revealed == false, "Cannot be unrevealed");
            revealed = _state;
        }

    //@dev Sets the Not Revealed URI for the collection
        function setNR(string memory _nr) public onlyOwner() 
        {
            NR = _nr;
        }

    //@dev Sets the total number of tokens that can be currently BOUND
        function setMaxBound(uint256 _maxBound) public onlyOwner 
        {
            require(_maxBound > maxBound, "Maximum soulbounds must be greater than previously.");
            maxBound = _maxBound;
        }

    // Returns the owned tokens of a specific address
        function tokensOfOwner(address owner) external view returns (uint256[] memory) {
            unchecked {
                uint256 tokenIdsIdx;
                address currOwnershipAddr;
                uint256 tokenIdsLength = balanceOf(owner);
                uint256[] memory tokenIds = new uint256[](tokenIdsLength);
                TokenOwnership memory ownership;
                for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) {
                    ownership = _ownershipOf(i);
                    if (ownership.burned) {
                        continue;
                    }
                    if (ownership.addr != address(0)) {
                        currOwnershipAddr = ownership.addr;
                    }
                    if (currOwnershipAddr == owner) {
                        tokenIds[tokenIdsIdx++] = i;
                    }
                }
                return tokenIds;
            }
        }        
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Bind","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"quantity","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"DevMinted","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"quantity","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"PresaleMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"quantity","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"PublicMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Revoke","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"NR","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"_numberMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bool","name":"bindVal","type":"bool"}],"name":"bind","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"bindRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"binds","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"boundURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"users","type":"address[]"}],"name":"bulkDrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"check","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"devMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxBound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"phase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"address","name":"addr","type":"address"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"presaleMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"presaleOnly","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"qty","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"revoke","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":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rate","type":"uint256"}],"name":"setBindRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_boundURI","type":"string"}],"name":"setBoundURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxBound","type":"uint256"}],"name":"setMaxBound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_nr","type":"string"}],"name":"setNR","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_phase","type":"uint256"}],"name":"setPhase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setPresaleOnly","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_validator","type":"address"}],"name":"setValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"","type":"bytes"}],"name":"sigs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"validator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

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

0x6080604052600436106103555760003560e01c806351830227116101bb5780638da5cb5b116100f7578063c87b56dd11610095578063e0a808531161006f578063e0a80853146109b8578063e985e9c5146109d8578063ee8fd0f314610a21578063f2fde38b14610a3657600080fd5b8063c87b56dd1461096c578063cbd9e3131461098c578063d5abeb01146109a257600080fd5b80639c16f214116100d15780639c16f214146108f6578063a22cb46514610916578063b1c9fe6e14610936578063b88d4fde1461094c57600080fd5b80638da5cb5b146108b0578063923a62e6146108ce57806395d89b41146108e157600080fd5b80636f0b6e42116101645780638210d3fb1161013e5780638210d3fb146108255780638462151c1461084557806384b0196e146108725780638693da201461089a57600080fd5b80636f0b6e421461079557806370a08231146107d0578063715018a61461081057600080fd5b80636352211e116101955780636352211e146107455780636619434014610765578063672a7fe01461077b57600080fd5b806351830227146106e657806355f804b3146107055780635c975abb1461072557600080fd5b80632b9b47e4116102955780633ccfd60b11610233578063458b221a1161020d578063458b221a146106525780634d388a98146106675780634dcddb7a146106b35780634f558e79146106c657600080fd5b80633ccfd60b1461060a57806342842e0e1461061257806342966c681461063257600080fd5b80632de7d61d1161026f5780632de7d61d1461057a57806330a464f5146105aa578063375a069a146105ca5780633a5381b5146105ea57600080fd5b80632b9b47e4146105275780632cc82655146105475780632db115441461056757600080fd5b80630d960de3116103025780631d65d159116102dc5780631d65d159146104b257806320c5429b146104c757806323b872dd146104e757806324839c8f1461050757600080fd5b80630d960de31461044b5780631327d3d81461046b57806318160ddd1461048b57600080fd5b8063081812fc11610333578063081812fc146103d3578063095ea7b31461040b5780630af123ef1461042b57600080fd5b806301ffc9a71461035a57806302329a291461038f57806306fdde03146103b1575b600080fd5b34801561036657600080fd5b5061037a6103753660046135fb565b610a56565b60405190151581526020015b60405180910390f35b34801561039b57600080fd5b506103af6103aa36600461362d565b610af3565b005b3480156103bd57600080fd5b506103c6610b5c565b6040516103869190613698565b3480156103df57600080fd5b506103f36103ee3660046136ab565b610bee565b6040516001600160a01b039091168152602001610386565b34801561041757600080fd5b506103af6104263660046136db565b610c4b565b34801561043757600080fd5b506103af61044636600461374c565b610d27565b34801561045757600080fd5b506103af610466366004613851565b610e8e565b34801561047757600080fd5b506103af61048636600461389a565b610ee2565b34801561049757600080fd5b5060015460005403600019015b604051908152602001610386565b3480156104be57600080fd5b506104a4610faf565b3480156104d357600080fd5b506103af6104e23660046136ab565b610fbf565b3480156104f357600080fd5b506103af6105023660046138b5565b6110ba565b34801561051357600080fd5b506103af6105223660046136ab565b6110c5565b34801561053357600080fd5b506103f3610542366004613911565b611189565b34801561055357600080fd5b506103af6105623660046136ab565b6111a2565b6103af6105753660046136ab565b6111ef565b34801561058657600080fd5b5061037a6105953660046136ab565b60106020526000908152604090205460ff1681565b3480156105b657600080fd5b506103af6105c536600461362d565b611469565b3480156105d657600080fd5b506103af6105e53660046136ab565b611521565b3480156105f657600080fd5b506016546103f3906001600160a01b031681565b6103af611626565b34801561061e57600080fd5b506103af61062d3660046138b5565b6116c3565b34801561063e57600080fd5b506103af61064d3660046136ab565b611007565b34801561065e57600080fd5b506103c66116de565b34801561067357600080fd5b506104a461068236600461389a565b6001600160a01b031660009081526005602052604090205468010000000000000000900467ffffffffffffffff1690565b6103af6106c1366004613911565b61176c565b3480156106d257600080fd5b5061037a6106e13660046136ab565b611b0d565b3480156106f257600080fd5b5060145461037a90610100900460ff1681565b34801561071157600080fd5b506103af610720366004613851565b611b18565b34801561073157600080fd5b5060145461037a9062010000900460ff1681565b34801561075157600080fd5b506103f36107603660046136ab565b611b6c565b34801561077157600080fd5b506104a4600e5481565b34801561078757600080fd5b5060145461037a9060ff1681565b3480156107a157600080fd5b5061037a6107b0366004613972565b805160208183018101805160118252928201919093012091525460ff1681565b3480156107dc57600080fd5b506104a46107eb36600461389a565b6001600160a01b031660009081526005602052604090205467ffffffffffffffff1690565b34801561081c57600080fd5b506103af611b7e565b34801561083157600080fd5b506103af610840366004613851565b611bd2565b34801561085157600080fd5b5061086561086036600461389a565b611c26565b60405161038691906139e2565b34801561087e57600080fd5b50610887611d43565b60405161038697969594939291906139f5565b3480156108a657600080fd5b506104a4600c5481565b3480156108bc57600080fd5b50600a546001600160a01b03166103f3565b6103af6108dc366004613a7f565b611de8565b3480156108ed57600080fd5b506103c6612019565b34801561090257600080fd5b506103af6109113660046136ab565b612028565b34801561092257600080fd5b506103af610931366004613aab565b612075565b34801561094257600080fd5b506104a460155481565b34801561095857600080fd5b506103af610967366004613ad5565b61211c565b34801561097857600080fd5b506103c66109873660046136ab565b61216d565b34801561099857600080fd5b506104a4600f5481565b3480156109ae57600080fd5b506104a4600d5481565b3480156109c457600080fd5b506103af6109d336600461362d565b6122e9565b3480156109e457600080fd5b5061037a6109f3366004613b25565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b348015610a2d57600080fd5b506103c66123a3565b348015610a4257600080fd5b506103af610a5136600461389a565b6123b0565b60006001600160e01b031982167f80ac58cd000000000000000000000000000000000000000000000000000000001480610ab957506001600160e01b031982167f5b5e139f00000000000000000000000000000000000000000000000000000000145b80610aed57507f01ffc9a7000000000000000000000000000000000000000000000000000000006001600160e01b03198316145b92915050565b600a546001600160a01b03163314610b405760405162461bcd60e51b81526020600482018190526024820152600080516020613ed283398151915260448201526064015b60405180910390fd5b60148054911515620100000262ff000019909216919091179055565b606060028054610b6b90613b4f565b80601f0160208091040260200160405190810160405280929190818152602001828054610b9790613b4f565b8015610be45780601f10610bb957610100808354040283529160200191610be4565b820191906000526020600020905b815481529060010190602001808311610bc757829003601f168201915b5050505050905090565b6000610bf9826124b1565b610c2f576040517fcf4700e400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b506000908152600660205260409020546001600160a01b031690565b6000610c5682611b6c565b9050806001600160a01b0316836001600160a01b031603610ca3576040517f943f7b8c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b336001600160a01b03821614801590610ce057506001600160a01b038116600090815260076020908152604080832033845290915290205460ff16155b15610d17576040517fcfb3b94200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610d228383836124ea565b505050565b600a546001600160a01b03163314610d6f5760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b60005b8151811015610e8a576000610d906001546000546000199190030190565b9050610abf610da0826001613b9f565b10610dd95760405162461bcd60e51b8152602060048201526009602482015268534f4c44204f55542160b81b6044820152606401610b37565b610e0f838381518110610dee57610dee613bb2565b60200260200101516001604051806020016040528060008152506001612553565b610e1a816001613b9f565b838381518110610e2c57610e2c613bb2565b60200260200101516001600160a01b03167f93b50fdd18133a0522113a04aa86e1e698c359f4ee0217c33e9906a23086bbda6001604051610e6f91815260200190565b60405180910390a35080610e8281613bc8565b915050610d72565b5050565b600a546001600160a01b03163314610ed65760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b6013610e8a8282613c2f565b600a546001600160a01b03163314610f2a5760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b6001600160a01b038116610f805760405162461bcd60e51b815260206004820152601d60248201527f56616c696461746f722063616e6e6f74206265206164647265737320300000006044820152606401610b37565b6016805473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0392909216919091179055565b6000610fba600b5490565b905090565b600a546001600160a01b031633146110075760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b3361101182611b6c565b6001600160a01b0316146110735760405162461bcd60e51b815260206004820152602360248201527f4f6e6c79206f776e6572206f662074686520746f6b656e2063616e206275726e604482015262081a5d60ea1b6064820152608401610b37565b60008181526010602052604090205460ff1615156001036110ae576000818152601060205260409020805460ff191690556110ae600b612738565b6110b78161278f565b50565b610d22838383612798565b600a546001600160a01b0316331461110d5760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b600f5481116111845760405162461bcd60e51b815260206004820152603360248201527f4d6178696d756d20736f756c626f756e6473206d75737420626520677265617460448201527f6572207468616e2070726576696f75736c792e000000000000000000000000006064820152608401610b37565b600f55565b6000611197858585856129a2565b90505b949350505050565b600a546001600160a01b031633146111ea5760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b601555565b60006112046001546000546000199190030190565b600c543360009081526005602052604090205491925090600490849068010000000000000000900467ffffffffffffffff166112409190613b9f565b1061127d5760405162461bcd60e51b815260206004820152600d60248201526c115e18d959591cc81b1a5b5a5d609a1b6044820152606401610b37565b60145462010000900460ff16156112bf5760405162461bcd60e51b815260206004820152600660248201526514185d5cd95960d21b6044820152606401610b37565b60145460ff16156113125760405162461bcd60e51b815260206004820152600c60248201527f50726573616c65204f6e6c7900000000000000000000000000000000000000006044820152606401610b37565b3332146113615760405162461bcd60e51b815260206004820152600760248201527f6e6f20626f7473000000000000000000000000000000000000000000000000006044820152606401610b37565b610abf61136e8484613b9f565b106113a75760405162461bcd60e51b8152602060048201526009602482015268534f4c44204f55542160b81b6044820152606401610b37565b6113b18184613cef565b6113bc346001613b9f565b116114095760405162461bcd60e51b815260206004820152601360248201527f4e6f7420456e6f756768204554482073656e74000000000000000000000000006044820152606401610b37565b6114253384604051806020016040528060008152506000612553565b61142f8383613b9f565b60405184815233907fc1a73b31b32801ebbb4cae30b73eae4345be9f2915ea60306383c245ef8fac449060200160405180910390a3505050565b600a546001600160a01b031633146114b15760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b60145460ff16151560000361150e57801561150e5760405162461bcd60e51b815260206004820152601960248201527f43616e6e6f7420676f206261636b20746f2070726573616c65000000000000006044820152606401610b37565b6014805460ff1916911515919091179055565b600a546001600160a01b031633146115695760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b600061157e6001546000546000199190030190565b9050610abf61158d8383613b9f565b106115c65760405162461bcd60e51b8152602060048201526009602482015268534f4c44204f55542160b81b6044820152606401610b37565b6115e23383604051806020016040528060008152506000612553565b6115ec8282613b9f565b60405183815233907f93b50fdd18133a0522113a04aa86e1e698c359f4ee0217c33e9906a23086bbda906020015b60405180910390a35050565b600a546001600160a01b0316331461166e5760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b604051600090339047908381818185875af1925050503d80600081146116b0576040519150601f19603f3d011682016040523d82523d6000602084013e6116b5565b606091505b50509050806110b757600080fd5b610d228383836040518060200160405280600081525061211c565b601380546116eb90613b4f565b80601f016020809104026020016040519081016040528092919081815260200182805461171790613b4f565b80156117645780601f1061173957610100808354040283529160200191611764565b820191906000526020600020905b81548152906001019060200180831161174757829003601f168201915b505050505081565b60006117816001546000546000199190030190565b600c546014549192509062010000900460ff16156117ca5760405162461bcd60e51b815260206004820152600660248201526514185d5cd95960d21b6044820152606401610b37565b6016546001600160a01b03166117e287878787611189565b6001600160a01b0316146118385760405162461bcd60e51b815260206004820152600c60248201527f4e6f7420766572696669656400000000000000000000000000000000000000006044820152606401610b37565b6001600160a01b03841633146118b65760405162461bcd60e51b815260206004820152602960248201527f44657374696e6174696f6e206164647265737320616e642073656e646572206460448201527f6f6e74206d6174636800000000000000000000000000000000000000000000006064820152608401610b37565b6011836040516118c69190613d06565b9081526040519081900360200190205460ff161561194b5760405162461bcd60e51b8152602060048201526024808201527f54686973207369676e61747572652068617320616c7265616479206265656e2060448201527f75736564000000000000000000000000000000000000000000000000000000006064820152608401610b37565b33600090815260056020526040902054600390879068010000000000000000900467ffffffffffffffff166119809190613b9f565b106119bd5760405162461bcd60e51b815260206004820152600d60248201526c115e18d959591cc81b1a5b5a5d609a1b6044820152606401610b37565b610abf6119ca8784613b9f565b10611a035760405162461bcd60e51b8152602060048201526009602482015268534f4c44204f55542160b81b6044820152606401610b37565b611a0d8187613cef565b611a18346001613b9f565b11611a655760405162461bcd60e51b815260206004820152601360248201527f4e6f7420456e6f756768204554482073656e74000000000000000000000000006044820152606401610b37565b6001601184604051611a779190613d06565b908152602001604051809103902060006101000a81548160ff021916908315150217905550611ab88487604051806020016040528060008152506000612553565b611ac28683613b9f565b846001600160a01b03167f6a12a358b1ea6cc11eebc8b59ef2beac4a9954ad7b2e29b85b7675421896e5b088604051611afd91815260200190565b60405180910390a3505050505050565b6000610aed826124b1565b600a546001600160a01b03163314611b605760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b6017610e8a8282613c2f565b6000611b77826129c6565b5192915050565b600a546001600160a01b03163314611bc65760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b611bd06000612b08565b565b600a546001600160a01b03163314611c1a5760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b6012610e8a8282613c2f565b60606000806000611c56856001600160a01b031660009081526005602052604090205467ffffffffffffffff1690565b905060008167ffffffffffffffff811115611c7357611c73613705565b604051908082528060200260200182016040528015611c9c578160200160208202803683370190505b50604080516060810182526000808252602082018190529181019190915290915060015b838614611d3757611cd0816129c6565b91508160400151611d2f5781516001600160a01b031615611cf057815194505b876001600160a01b0316856001600160a01b031603611d2f5780838780600101985081518110611d2257611d22613bb2565b6020026020010181815250505b600101611cc0565b50909695505050505050565b600060608082808083611d777f4e4f5750415353000000000000000000000000000000000000000000000000076008612b67565b611da27f31000000000000000000000000000000000000000000000000000000000000016009612b67565b604080516000808252602082019092527f0f000000000000000000000000000000000000000000000000000000000000009b939a50919850469750309650945092509050565b6000600f5411611e3a5760405162461bcd60e51b815260206004820152601960248201527f42696e64696e67206e6f7420617661696c61626c6520796574000000000000006044820152606401610b37565b33611e4483611b6c565b6001600160a01b031614611ea65760405162461bcd60e51b815260206004820152602360248201527f4f6e6c79206f776e6572206f662074686520746f6b656e2063616e2062696e64604482015262081a5d60ea1b6064820152608401610b37565b600181151514611ef85760405162461bcd60e51b815260206004820152601760248201527f42696e642076616c7565206d75737420626520747275650000000000000000006044820152606401610b37565b600f54600b5410611f715760405162461bcd60e51b815260206004820152602560248201527f4e6f206d6f726520746f6b656e732063616e2063757272656e746c792062652060448201527f626f756e640000000000000000000000000000000000000000000000000000006064820152608401610b37565b600e54341015611fc35760405162461bcd60e51b815260206004820152601d60248201527f4e6f7420656e6f7567682065746865722073656e7420746f2062696e640000006044820152606401610b37565b611fd1600b80546001019055565b600082815260106020526040808220805460ff191684151517905551839133917f38c5113fd00406b6b80d11ab47aa56c96e3a6d7115e48f6854f06176e16fef759190a35050565b606060038054610b6b90613b4f565b600a546001600160a01b031633146120705760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b600e55565b336001600160a01b038316036120b7576040517fb06307db00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b3360008181526007602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910161161a565b612127848484612798565b6001600160a01b0383163b15158015612149575061214784848484612c0c565b155b15612167576040516368d2bf6b60e11b815260040160405180910390fd5b50505050565b601454606090610100900460ff161515600003612216576013805461219190613b4f565b80601f01602080910402602001604051908101604052809291908181526020018280546121bd90613b4f565b801561220a5780601f106121df5761010080835404028352916020019161220a565b820191906000526020600020905b8154815290600101906020018083116121ed57829003601f168201915b50505050509050919050565b60008281526010602052604090205460ff16151560010361228d5760006012805461224090613b4f565b90501161225c5760405180602001604052806000815250610aed565b601261226783612cf4565b604051602001612278929190613d22565b60405160208183030381529060405292915050565b6000612297612e29565b905060008151116122b757604051806020016040528060008152506122e2565b806122c184612cf4565b6040516020016122d2929190613dd1565b6040516020818303038152906040525b9392505050565b600a546001600160a01b031633146123315760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b601454610100900460ff16156123895760405162461bcd60e51b815260206004820152601460248201527f43616e6e6f7420626520756e72657665616c65640000000000000000000000006044820152606401610b37565b601480549115156101000261ff0019909216919091179055565b601280546116eb90613b4f565b600a546001600160a01b031633146123f85760405162461bcd60e51b81526020600482018190526024820152600080516020613ed28339815191526044820152606401610b37565b6001600160a01b0381166124745760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f64647265737300000000000000000000000000000000000000000000000000006064820152608401610b37565b6110b781612b08565b60006020835110156124995761249283612e38565b9050610aed565b816124a48482613c2f565b5060009050610aed565b90565b6000816001111580156124c5575060005482105b8015610aed575050600090815260046020526040902054600160e01b900460ff161590565b600082815260066020526040808220805473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b6000805490849003612591576040517fb562e8dd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61259e6000868387612e8f565b6001600160a01b038516600081815260056020908152604080832080547fffffffffffffffffffffffffffffffff00000000000000000000000000000000811667ffffffffffffffff8083168c0181169182176801000000000000000067ffffffffffffffff1990941690921783900481168c01811690920217909155858452600490925290912080546001600160e01b031916909217600160a01b42909216919091021790558080850183801561265f57506001600160a01b0387163b15155b156126e7575b60405182906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a46126b06000888480600101955088612c0c565b6126cd576040516368d2bf6b60e11b815260040160405180910390fd5b8082036126655782600054146126e257600080fd5b61272c565b5b6040516001830192906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a48082036126e8575b506000555b5050505050565b8054806127875760405162461bcd60e51b815260206004820152601b60248201527f436f756e7465723a2064656372656d656e74206f766572666c6f7700000000006044820152606401610b37565b600019019055565b6110b781612f13565b60006127a3826129c6565b9050836001600160a01b031681600001516001600160a01b0316146127f4576040517fa114810000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000336001600160a01b038616148061283057506001600160a01b038516600090815260076020908152604080832033845290915290205460ff165b8061284b57503361284084610bee565b6001600160a01b0316145b90508061286b57604051632ce44b5f60e11b815260040160405180910390fd5b6001600160a01b0384166128ab576040517fea553b3400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6128b88585856001612e8f565b6128c4600084876124ea565b6001600160a01b038581166000908152600560209081526040808320805467ffffffffffffffff1980821667ffffffffffffffff92831660001901831617909255898616808652838620805493841693831660019081018416949094179055898652600490945282852080546001600160e01b031916909417600160a01b4290921691909102178355870180845292208054919390911661299a57600054821461299a578054602086015167ffffffffffffffff16600160a01b026001600160e01b03199091166001600160a01b038a16171781555b505050612731565b6000806129b0868686612f1e565b90506129bc8184612f89565b9695505050505050565b604080516060810182526000808252602082018190529181019190915281806001111580156129f6575060005481105b15612ad657600081815260046020908152604091829020825160608101845290546001600160a01b0381168252600160a01b810467ffffffffffffffff1692820192909252600160e01b90910460ff16151591810182905290612ad45780516001600160a01b031615612a6a579392505050565b5060001901600081815260046020908152604091829020825160608101845290546001600160a01b038116808352600160a01b820467ffffffffffffffff1693830193909352600160e01b900460ff1615159281019290925215612acf579392505050565b612a6a565b505b6040517fdf2d9b4200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600a80546001600160a01b0383811673ffffffffffffffffffffffffffffffffffffffff19831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b606060ff831615612b7b5761249283612fad565b818054612b8790613b4f565b80601f0160208091040260200160405190810160405280929190818152602001828054612bb390613b4f565b8015612c005780601f10612bd557610100808354040283529160200191612c00565b820191906000526020600020905b815481529060010190602001808311612be357829003601f168201915b50505050509050610aed565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a0290612c41903390899088908890600401613df7565b6020604051808303816000875af1925050508015612c7c575060408051601f3d908101601f19168201909252612c7991810190613e29565b60015b612cda573d808015612caa576040519150601f19603f3d011682016040523d82523d6000602084013e612caf565b606091505b508051600003612cd2576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b14905061119a565b606081600003612d3757505060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015290565b8160005b8115612d615780612d4b81613bc8565b9150612d5a9050600a83613e5c565b9150612d3b565b60008167ffffffffffffffff811115612d7c57612d7c613705565b6040519080825280601f01601f191660200182016040528015612da6576020820181803683370190505b5090505b841561119a57612dbb600183613e70565b9150612dc8600a86613e83565b612dd3906030613b9f565b60f81b818381518110612de857612de8613bb2565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350612e22600a86613e5c565b9450612daa565b606060178054610b6b90613b4f565b600080829050601f81511115612e7c57826040517f305a27a9000000000000000000000000000000000000000000000000000000008152600401610b379190613698565b8051612e8782613e97565b179392505050565b60008281526010602052604090205460ff161515600103612167576001600160a01b0384161580612ec757506001600160a01b038316155b6121675760405162461bcd60e51b815260206004820152601d60248201527f4e6f7420616c6c6f77656420746f207472616e7366657220746f6b656e0000006044820152606401610b37565b6110b7816000612fe2565b604080517f9a094fb5fd89e66cec1414c63b376e65df8952d6092e43505a86dddaeeed99636020820152908101849052606081018390526001600160a01b038216608082015260009061119a9060a00160405160208183030381529060405280519060200120613204565b6000806000612f98858561324c565b91509150612fa581613291565b509392505050565b60408051602080825281830190925260609160ff84169160009180820181803683375050509182525060208101929092525090565b6000612fed836129c6565b80519091508215613071576000336001600160a01b038316148061303457506001600160a01b038216600090815260076020908152604080832033845290915290205460ff165b8061304f57503361304486610bee565b6001600160a01b0316145b90508061306f57604051632ce44b5f60e11b815260040160405180910390fd5b505b61307f816000866001612e8f565b61308b600085836124ea565b6001600160a01b038082166000818152600560209081526040808320805470010000000000000000000000000000000060001967ffffffffffffffff80841691909101811667ffffffffffffffff19841681178390048216600190810183169093027fffffffffffffffff0000000000000000ffffffffffffffff0000000000000000909416179290921783558b8652600490945282852080547fffffff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffff42909316600160a01b026001600160e01b03199091169097179690961716600160e01b1785559189018084529220805491949091166131ba5760005482146131ba578054602087015167ffffffffffffffff16600160a01b026001600160e01b03199091166001600160a01b038716171781555b5050604051869250600091506001600160a01b038416907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908390a4505060018054810190555050565b6000610aed6132116133f6565b836040517f19010000000000000000000000000000000000000000000000000000000000008152600281019290925260228201526042902090565b60008082516041036132825760208301516040840151606085015160001a61327687828585613521565b9450945050505061328a565b506000905060025b9250929050565b60008160048111156132a5576132a5613ebb565b036132ad5750565b60018160048111156132c1576132c1613ebb565b0361330e5760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610b37565b600281600481111561332257613322613ebb565b0361336f5760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610b37565b600381600481111561338357613383613ebb565b036110b75760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c60448201527f75650000000000000000000000000000000000000000000000000000000000006064820152608401610b37565b6000306001600160a01b037f0000000000000000000000008408baccc231a6bba766ed15571403468b32bfa51614801561344f57507f000000000000000000000000000000000000000000000000000000000000000146145b1561347957507f30a99fd1ba86d6a2039db5efecf75026f7059a174861b7f5733de0e132b4840290565b610fba604080517f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f60208201527f3358a3c69b829a6767aa6599d383215e21ff61d2ef3ab99254f0c0ee17f59122918101919091527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc660608201524660808201523060a082015260009060c00160405160208183030381529060405280519060200120905090565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a083111561355857506000905060036135dc565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa1580156135ac573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b0381166135d5576000600192509250506135dc565b9150600090505b94509492505050565b6001600160e01b0319811681146110b757600080fd5b60006020828403121561360d57600080fd5b81356122e2816135e5565b8035801515811461362857600080fd5b919050565b60006020828403121561363f57600080fd5b6122e282613618565b60005b8381101561366357818101518382015260200161364b565b50506000910152565b60008151808452613684816020860160208601613648565b601f01601f19169290920160200192915050565b6020815260006122e2602083018461366c565b6000602082840312156136bd57600080fd5b5035919050565b80356001600160a01b038116811461362857600080fd5b600080604083850312156136ee57600080fd5b6136f7836136c4565b946020939093013593505050565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff8111828210171561374457613744613705565b604052919050565b6000602080838503121561375f57600080fd5b823567ffffffffffffffff8082111561377757600080fd5b818501915085601f83011261378b57600080fd5b81358181111561379d5761379d613705565b8060051b91506137ae84830161371b565b81815291830184019184810190888411156137c857600080fd5b938501935b838510156137ed576137de856136c4565b825293850193908501906137cd565b98975050505050505050565b600067ffffffffffffffff83111561381357613813613705565b613826601f8401601f191660200161371b565b905082815283838301111561383a57600080fd5b828260208301376000602084830101529392505050565b60006020828403121561386357600080fd5b813567ffffffffffffffff81111561387a57600080fd5b8201601f8101841361388b57600080fd5b61119a848235602084016137f9565b6000602082840312156138ac57600080fd5b6122e2826136c4565b6000806000606084860312156138ca57600080fd5b6138d3846136c4565b92506138e1602085016136c4565b9150604084013590509250925092565b600082601f83011261390257600080fd5b6122e2838335602085016137f9565b6000806000806080858703121561392757600080fd5b843593506020850135925061393e604086016136c4565b9150606085013567ffffffffffffffff81111561395a57600080fd5b613966878288016138f1565b91505092959194509250565b60006020828403121561398457600080fd5b813567ffffffffffffffff81111561399b57600080fd5b61119a848285016138f1565b600081518084526020808501945080840160005b838110156139d7578151875295820195908201906001016139bb565b509495945050505050565b6020815260006122e260208301846139a7565b7fff000000000000000000000000000000000000000000000000000000000000008816815260e060208201526000613a3060e083018961366c565b8281036040840152613a42818961366c565b90508660608401526001600160a01b03861660808401528460a084015282810360c0840152613a7181856139a7565b9a9950505050505050505050565b60008060408385031215613a9257600080fd5b82359150613aa260208401613618565b90509250929050565b60008060408385031215613abe57600080fd5b613ac7836136c4565b9150613aa260208401613618565b60008060008060808587031215613aeb57600080fd5b613af4856136c4565b9350613b02602086016136c4565b925060408501359150606085013567ffffffffffffffff81111561395a57600080fd5b60008060408385031215613b3857600080fd5b613b41836136c4565b9150613aa2602084016136c4565b600181811c90821680613b6357607f821691505b602082108103613b8357634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b80820180821115610aed57610aed613b89565b634e487b7160e01b600052603260045260246000fd5b600060018201613bda57613bda613b89565b5060010190565b601f821115610d2257600081815260208120601f850160051c81016020861015613c085750805b601f850160051c820191505b81811015613c2757828155600101613c14565b505050505050565b815167ffffffffffffffff811115613c4957613c49613705565b613c5d81613c578454613b4f565b84613be1565b602080601f831160018114613c925760008415613c7a5750858301515b600019600386901b1c1916600185901b178555613c27565b600085815260208120601f198616915b82811015613cc157888601518255948401946001909101908401613ca2565b5085821015613cdf5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b8082028115828204841417610aed57610aed613b89565b60008251613d18818460208701613648565b9190910192915050565b6000808454613d3081613b4f565b60018281168015613d485760018114613d5d57613d8c565b60ff1984168752821515830287019450613d8c565b8860005260208060002060005b85811015613d835781548a820152908401908201613d6a565b50505082870194505b505050508351613da0818360208801613648565b7f2e6a736f6e0000000000000000000000000000000000000000000000000000009101908152600501949350505050565b60008351613de3818460208801613648565b835190830190613da0818360208801613648565b60006001600160a01b038087168352808616602084015250836040830152608060608301526129bc608083018461366c565b600060208284031215613e3b57600080fd5b81516122e2816135e5565b634e487b7160e01b600052601260045260246000fd5b600082613e6b57613e6b613e46565b500490565b81810381811115610aed57610aed613b89565b600082613e9257613e92613e46565b500690565b80516020808301519190811015613b835760001960209190910360031b1b16919050565b634e487b7160e01b600052602160045260246000fdfe4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572a2646970667358221220015fe6ec817bebf9b35f2146d630f4a1f9fad7c35562b3d14c658dca2e98fe4164736f6c63430008110033

83729:11700:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46875:305;;;;;;;;;;-1:-1:-1;46875:305:0;;;;;:::i;:::-;;:::i;:::-;;;611:14:1;;604:22;586:41;;574:2;559:18;46875:305:0;;;;;;;;92744:99;;;;;;;;;;-1:-1:-1;92744:99:0;;;;;:::i;:::-;;:::i;:::-;;49925:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;51428:204::-;;;;;;;;;;-1:-1:-1;51428:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2093:55:1;;;2075:74;;2063:2;2048:18;51428:204:0;1929:226:1;50991:371:0;;;;;;;;;;-1:-1:-1;50991:371:0;;;;;:::i;:::-;;:::i;88072:359::-;;;;;;;;;;-1:-1:-1;88072:359:0;;;;;:::i;:::-;;:::i;93989:98::-;;;;;;;;;;-1:-1:-1;93989:98:0;;;;;:::i;:::-;;:::i;92149:199::-;;;;;;;;;;-1:-1:-1;92149:199:0;;;;;:::i;:::-;;:::i;46124:303::-;;;;;;;;;;-1:-1:-1;45981:1:0;46378:12;46168:7;46362:13;:28;-1:-1:-1;;46362:46:0;46124:303;;;5251:25:1;;;5239:2;5224:18;46124:303:0;5105:177:1;90262:117:0;;;;;;;;;;;;;:::i;93127:355::-;;;;;;;;;;-1:-1:-1;93127:355:0;;;;;:::i;:::-;;:::i;52293:170::-;;;;;;;;;;-1:-1:-1;52293:170:0;;;;;:::i;:::-;;:::i;94171:213::-;;;;;;;;;;-1:-1:-1;94171:213:0;;;;;:::i;:::-;;:::i;86149:191::-;;;;;;;;;;-1:-1:-1;86149:191:0;;;;;:::i;:::-;;:::i;91973:99::-;;;;;;;;;;-1:-1:-1;91973:99:0;;;;;:::i;:::-;;:::i;87008:642::-;;;;;;:::i;:::-;;:::i;84159:37::-;;;;;;;;;;-1:-1:-1;84159:37:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;92408:297;;;;;;;;;;-1:-1:-1;92408:297:0;;;;;:::i;:::-;;:::i;87716:283::-;;;;;;;;;;-1:-1:-1;87716:283:0;;;;;:::i;:::-;;:::i;84460:24::-;;;;;;;;;;-1:-1:-1;84460:24:0;;;;-1:-1:-1;;;;;84460:24:0;;;92925:190;;;:::i;52534:185::-;;;;;;;;;;-1:-1:-1;52534:185:0;;;;;:::i;:::-;;:::i;89307:343::-;;;;;;;;;;-1:-1:-1;89307:343:0;;;;;:::i;:::-;;:::i;84277:44::-;;;;;;;;;;;;;:::i;47471:135::-;;;;;;;;;;-1:-1:-1;47471:135:0;;;;;:::i;:::-;-1:-1:-1;;;;;47565:19:0;47530:7;47565:19;;;:12;:19;;;;;:32;;;;;;;47471:135;85178:907;;;;;;:::i;:::-;;:::i;90609:120::-;;;;;;;;;;-1:-1:-1;90609:120:0;;;;;:::i;:::-;;:::i;84365:28::-;;;;;;;;;;-1:-1:-1;84365:28:0;;;;;;;;;;;93542:122;;;;;;;;;;-1:-1:-1;93542:122:0;;;;;:::i;:::-;;:::i;84400:25::-;;;;;;;;;;-1:-1:-1;84400:25:0;;;;;;;;;;;49733:125;;;;;;;;;;-1:-1:-1;49733:125:0;;;;;:::i;:::-;;:::i;84096:23::-;;;;;;;;;;;;;;;;84328:30;;;;;;;;;;-1:-1:-1;84328:30:0;;;;;;;;84203:34;;;;;;;;;;-1:-1:-1;84203:34:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47244:145;;;;;;;;;;-1:-1:-1;47244:145:0;;;;;:::i;:::-;-1:-1:-1;;;;;47353:19:0;47308:7;47353:19;;;:12;:19;;;;;:27;;;;47244:145;2459:103;;;;;;;;;;;;;:::i;91625:120::-;;;;;;;;;;-1:-1:-1;91625:120:0;;;;;:::i;:::-;;:::i;94451:967::-;;;;;;;;;;-1:-1:-1;94451:967:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;77230:657::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;84016:38::-;;;;;;;;;;;;;;;;1808:87;;;;;;;;;;-1:-1:-1;1881:6:0;;-1:-1:-1;;;;;1881:6:0;1808:87;;88655:604;;;;;;:::i;:::-;;:::i;50094:104::-;;;;;;;;;;;;;:::i;91808:106::-;;;;;;;;;;-1:-1:-1;91808:106:0;;;;;:::i;:::-;;:::i;51704:287::-;;;;;;;;;;-1:-1:-1;51704:287:0;;;;;:::i;:::-;;:::i;84432:21::-;;;;;;;;;;;;;;;;52790:369;;;;;;;;;;-1:-1:-1;52790:369:0;;;;;:::i;:::-;;:::i;90847:649::-;;;;;;;;;;-1:-1:-1;90847:649:0;;;;;:::i;:::-;;:::i;84126:24::-;;;;;;;;;;;;;;;;84061:28;;;;;;;;;;;;;;;;93750:170;;;;;;;;;;-1:-1:-1;93750:170:0;;;;;:::i;:::-;;:::i;52062:164::-;;;;;;;;;;-1:-1:-1;52062:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;52183:25:0;;;52159:4;52183:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;52062:164;84248:22;;;;;;;;;;;;;:::i;2717:201::-;;;;;;;;;;-1:-1:-1;2717:201:0;;;;;:::i;:::-;;:::i;46875:305::-;46977:4;-1:-1:-1;;;;;;47014:40:0;;47029:25;47014:40;;:105;;-1:-1:-1;;;;;;;47071:48:0;;47086:33;47071:48;47014:105;:158;;;-1:-1:-1;33307:25:0;-1:-1:-1;;;;;;33292:40:0;;;47136:36;46994:178;46875:305;-1:-1:-1;;46875:305:0:o;92744:99::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;;;;;;;;;92816:6:::1;:15:::0;;;::::1;;::::0;::::1;-1:-1:-1::0;;92816:15:0;;::::1;::::0;;;::::1;::::0;;92744:99::o;49925:100::-;49979:13;50012:5;50005:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49925:100;:::o;51428:204::-;51496:7;51521:16;51529:7;51521;:16::i;:::-;51516:64;;51546:34;;;;;;;;;;;;;;51516:64;-1:-1:-1;51600:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;51600:24:0;;51428:204::o;50991:371::-;51064:13;51080:24;51096:7;51080:15;:24::i;:::-;51064:40;;51125:5;-1:-1:-1;;;;;51119:11:0;:2;-1:-1:-1;;;;;51119:11:0;;51115:48;;51139:24;;;;;;;;;;;;;;51115:48;706:10;-1:-1:-1;;;;;51180:21:0;;;;;;:63;;-1:-1:-1;;;;;;52183:25:0;;52159:4;52183:25;;;:18;:25;;;;;;;;706:10;52183:35;;;;;;;;;;51205:38;51180:63;51176:138;;;51267:35;;;;;;;;;;;;;;51176:138;51326:28;51335:2;51339:7;51348:5;51326:8;:28::i;:::-;51053:309;50991:371;;:::o;88072:359::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;88165:9:::1;88160:260;88180:5;:12;88176:1;:16;88160:260;;;88228:7;88238:13;45981:1:::0;46378:12;46168:7;46362:13;-1:-1:-1;;46362:28:0;;;:46;;46124:303;88238:13:::1;88228:23:::0;-1:-1:-1;88283:4:0::1;88274:6;88228:23:::0;88279:1:::1;88274:6;:::i;:::-;:13;88266:35;;;::::0;-1:-1:-1;;;88266:35:0;;11057:2:1;88266:35:0::1;::::0;::::1;11039:21:1::0;11096:1;11076:18;;;11069:29;-1:-1:-1;;;11114:18:1;;;11107:39;11163:18;;88266:35:0::1;10855:332:1::0;88266:35:0::1;88315:28;88321:5;88327:1;88321:8;;;;;;;;:::i;:::-;;;;;;;88331:1;88315:28;;;;;;;;;;;::::0;88338:4:::1;88315:5;:28::i;:::-;88384:6;:2:::0;88389:1:::1;88384:6;:::i;:::-;88371:5;88377:1;88371:8;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;88361:30:0::1;;88381:1;88361:30;;;;5251:25:1::0;;5239:2;5224:18;;5105:177;88361:30:0::1;;;;;;;;-1:-1:-1::0;88194:3:0;::::1;::::0;::::1;:::i;:::-;;;;88160:260;;;;88072:359:::0;:::o;93989:98::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;94067:2:::1;:8;94072:3:::0;94067:2;:8:::1;:::i;92149:199::-:0;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;-1:-1:-1;;;;;92241:24:0;::::1;92233:66;;;::::0;-1:-1:-1;;;92233:66:0;;14117:2:1;92233:66:0::1;::::0;::::1;14099:21:1::0;14156:2;14136:18;;;14129:30;14195:31;14175:18;;;14168:59;14244:18;;92233:66:0::1;13915:353:1::0;92233:66:0::1;92314:9;:22:::0;;-1:-1:-1;;92314:22:0::1;-1:-1:-1::0;;;;;92314:22:0;;;::::1;::::0;;;::::1;::::0;;92149:199::o;90262:117::-;90305:7;90346:21;:11;31939:14;;31847:114;90346:21;90339:28;;90262:117;:::o;93127:355::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;93232:10:::1;93212:16;93220:7:::0;93212::::1;:16::i;:::-;-1:-1:-1::0;;;;;93212:30:0::1;;93204:78;;;::::0;-1:-1:-1;;;93204:78:0;;14475:2:1;93204:78:0::1;::::0;::::1;14457:21:1::0;14514:2;14494:18;;;14487:30;14553:34;14533:18;;;14526:62;-1:-1:-1;;;14604:18:1;;;14597:33;14647:19;;93204:78:0::1;14273:399:1::0;93204:78:0::1;93303:14;::::0;;;:5:::1;:14;::::0;;;;;::::1;;:22;;:14:::0;:22;93299:141:::1;;93377:5;93360:14:::0;;;:5:::1;:14;::::0;;;;:22;;-1:-1:-1;;93360:22:0::1;::::0;;93401:23:::1;:11;:21;:23::i;:::-;93456:14;93462:7;93456:5;:14::i;:::-;93127:355:::0;:::o;52293:170::-;52427:28;52437:4;52443:2;52447:7;52427:9;:28::i;94171:213::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;94273:8:::1;;94261:9;:20;94253:84;;;::::0;-1:-1:-1;;;94253:84:0;;14879:2:1;94253:84:0::1;::::0;::::1;14861:21:1::0;14918:2;14898:18;;;14891:30;14957:34;14937:18;;;14930:62;15028:21;15008:18;;;15001:49;15067:19;;94253:84:0::1;14677:415:1::0;94253:84:0::1;94352:8;:20:::0;94171:213::o;86149:191::-;86251:7;86292:36;86300:3;86305:5;86312:4;86318:9;86292:7;:36::i;:::-;86285:43;;86149:191;;;;;;;:::o;91973:99::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;92046:5:::1;:14:::0;91973:99::o;87008:642::-;87080:7;87090:13;45981:1;46378:12;46168:7;46362:13;-1:-1:-1;;46362:28:0;;;:46;;46124:303;87090:13;87131:10;;87180;47530:7;47565:19;;;:12;:19;;;;;:32;87080:23;;-1:-1:-1;87131:10:0;87200:1;;87194:3;;47565:32;;;;;87166:31;;;;:::i;:::-;:35;87158:61;;;;-1:-1:-1;;;87158:61:0;;15299:2:1;87158:61:0;;;15281:21:1;15338:2;15318:18;;;15311:30;-1:-1:-1;;;15357:18:1;;;15350:43;15410:18;;87158:61:0;15097:337:1;87158:61:0;87243:6;;;;;;;:13;87235:31;;;;-1:-1:-1;;;87235:31:0;;15641:2:1;87235:31:0;;;15623:21:1;15680:1;15660:18;;;15653:29;-1:-1:-1;;;15698:18:1;;;15691:36;15744:18;;87235:31:0;15439:329:1;87235:31:0;87289:11;;;;:18;87281:42;;;;-1:-1:-1;;;87281:42:0;;15975:2:1;87281:42:0;;;15957:21:1;16014:2;15994:18;;;15987:30;16053:14;16033:18;;;16026:42;16085:18;;87281:42:0;15773:336:1;87281:42:0;87353:10;87367:9;87353:23;87345:43;;;;-1:-1:-1;;;87345:43:0;;16316:2:1;87345:43:0;;;16298:21:1;16355:1;16335:18;;;16328:29;16393:9;16373:18;;;16366:37;16420:18;;87345:43:0;16114:330:1;87345:43:0;87429:4;87418:8;87423:3;87418:2;:8;:::i;:::-;:15;87410:37;;;;-1:-1:-1;;;87410:37:0;;11057:2:1;87410:37:0;;;11039:21:1;11096:1;11076:18;;;11069:29;-1:-1:-1;;;11114:18:1;;;11107:39;11163:18;;87410:37:0;10855:332:1;87410:37:0;87486:11;87492:5;87486:3;:11;:::i;:::-;87470:13;:9;87482:1;87470:13;:::i;:::-;:27;87462:59;;;;-1:-1:-1;;;87462:59:0;;16824:2:1;87462:59:0;;;16806:21:1;16863:2;16843:18;;;16836:30;16902:21;16882:18;;;16875:49;16941:18;;87462:59:0;16622:343:1;87462:59:0;87534:32;87540:10;87552:3;87534:32;;;;;;;;;;;;87560:5;87534;:32::i;:::-;87614:8;87619:3;87614:2;:8;:::i;:::-;87584:39;;5251:25:1;;;87597:10:0;;87584:39;;5239:2:1;5224:18;87584:39:0;;;;;;;87065:585;;87008:642;:::o;92408:297::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;92493:11:::1;::::0;::::1;;:20;;:11;:20:::0;92489:128:::1;;92556:15:::0;::::1;92548:53;;;::::0;-1:-1:-1;;;92548:53:0;;17172:2:1;92548:53:0::1;::::0;::::1;17154:21:1::0;17211:2;17191:18;;;17184:30;17250:27;17230:18;;;17223:55;17295:18;;92548:53:0::1;16970:349:1::0;92548:53:0::1;92645:11;:20:::0;;-1:-1:-1;;92645:20:0::1;::::0;::::1;;::::0;;;::::1;::::0;;92408:297::o;87716:283::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;87785:7:::1;87795:13;45981:1:::0;46378:12;46168:7;46362:13;-1:-1:-1;;46362:28:0;;;:46;;46124:303;87795:13:::1;87785:23:::0;-1:-1:-1;87842:4:0::1;87831:8;87836:3:::0;87785:23;87831:8:::1;:::i;:::-;:15;87823:37;;;::::0;-1:-1:-1;;;87823:37:0;;11057:2:1;87823:37:0::1;::::0;::::1;11039:21:1::0;11096:1;11076:18;;;11069:29;-1:-1:-1;;;11114:18:1;;;11107:39;11163:18;;87823:37:0::1;10855:332:1::0;87823:37:0::1;87887:32;87893:10;87905:3;87887:32;;;;;;;;;;;::::0;87913:5:::1;87887;:32::i;:::-;87976:8;87981:3:::0;87976:2;:8:::1;:::i;:::-;87949:36;::::0;5251:25:1;;;87959:10:0::1;::::0;87949:36:::1;::::0;5239:2:1;5224:18;87949:36:0::1;;;;;;;;87770:229;87716:283:::0;:::o;92925:190::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;93014:58:::1;::::0;92996:12:::1;::::0;93022:10:::1;::::0;93046:21:::1;::::0;92996:12;93014:58;92996:12;93014:58;93046:21;93022:10;93014:58:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;92995:77;;;93095:7;93087:16;;;::::0;::::1;52534:185:::0;52672:39;52689:4;52695:2;52699:7;52672:39;;;;;;;;;;;;:16;:39::i;84277:44::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;85178:907::-;85301:7;85311:13;45981:1;46378:12;46168:7;46362:13;-1:-1:-1;;46362:28:0;;;:46;;46124:303;85311:13;85352:10;;85387:6;;85301:23;;-1:-1:-1;85352:10:0;85387:6;;;;;:13;85379:32;;;;-1:-1:-1;;;85379:32:0;;15641:2:1;85379:32:0;;;15623:21:1;15680:1;15660:18;;;15653:29;-1:-1:-1;;;15698:18:1;;;15691:36;15744:18;;85379:32:0;15439:329:1;85379:32:0;85472:9;;-1:-1:-1;;;;;85472:9:0;85434:34;85440:3;85445:5;85452:4;85458:9;85434:5;:34::i;:::-;-1:-1:-1;;;;;85434:47:0;;85426:72;;;;-1:-1:-1;;;85426:72:0;;17736:2:1;85426:72:0;;;17718:21:1;17775:2;17755:18;;;17748:30;17814:14;17794:18;;;17787:42;17846:18;;85426:72:0;17534:336:1;85426:72:0;-1:-1:-1;;;;;85521:18:0;;85529:10;85521:18;85513:72;;;;-1:-1:-1;;;85513:72:0;;18077:2:1;85513:72:0;;;18059:21:1;18116:2;18096:18;;;18089:30;18155:34;18135:18;;;18128:62;18226:11;18206:18;;;18199:39;18255:19;;85513:72:0;17875:405:1;85513:72:0;85608:4;85613:9;85608:15;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:24;85600:73;;;;-1:-1:-1;;;85600:73:0;;18779:2:1;85600:73:0;;;18761:21:1;18818:2;18798:18;;;18791:30;18857:34;18837:18;;;18830:62;18928:6;18908:18;;;18901:34;18952:19;;85600:73:0;18577:400:1;85600:73:0;85710:10;47530:7;47565:19;;;:12;:19;;;;;:32;85730:1;;85724:3;;47565:32;;;;;85696:31;;;;:::i;:::-;:35;85688:61;;;;-1:-1:-1;;;85688:61:0;;15299:2:1;85688:61:0;;;15281:21:1;15338:2;15318:18;;;15311:30;-1:-1:-1;;;15357:18:1;;;15350:43;15410:18;;85688:61:0;15097:337:1;85688:61:0;85784:4;85773:8;85778:3;85773:2;:8;:::i;:::-;:15;85765:37;;;;-1:-1:-1;;;85765:37:0;;11057:2:1;85765:37:0;;;11039:21:1;11096:1;11076:18;;;11069:29;-1:-1:-1;;;11114:18:1;;;11107:39;11163:18;;85765:37:0;10855:332:1;85765:37:0;85841:11;85847:5;85841:3;:11;:::i;:::-;85825:13;:9;85837:1;85825:13;:::i;:::-;:27;85817:59;;;;-1:-1:-1;;;85817:59:0;;16824:2:1;85817:59:0;;;16806:21:1;16863:2;16843:18;;;16836:30;16902:21;16882:18;;;16875:49;16941:18;;85817:59:0;16622:343:1;85817:59:0;85938:4;85920;85925:9;85920:15;;;;;;:::i;:::-;;;;;;;;;;;;;;:22;;;;;;;;;;;;;;;;;;85995:26;86001:4;86007:3;85995:26;;;;;;;;;;;;86015:5;85995;:26::i;:::-;86064:8;86069:3;86064:2;:8;:::i;:::-;86053:4;-1:-1:-1;;;;;86039:34:0;;86059:3;86039:34;;;;5251:25:1;;5239:2;5224:18;;5105:177;86039:34:0;;;;;;;;85286:799;;85178:907;;;;:::o;90609:120::-;90663:4;90701:16;90709:7;90701;:16::i;93542:122::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;93629:13:::1;:23;93645:7:::0;93629:13;:23:::1;:::i;49733:125::-:0;49797:7;49824:21;49837:7;49824:12;:21::i;:::-;:26;;49733:125;-1:-1:-1;;49733:125:0:o;2459:103::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;2524:30:::1;2551:1;2524:18;:30::i;:::-;2459:103::o:0;91625:120::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;91713:8:::1;:20;91724:9:::0;91713:8;:20:::1;:::i;94451:967::-:0;94512:16;94574:19;94612:25;94656:22;94681:16;94691:5;-1:-1:-1;;;;;47353:19:0;47308:7;47353:19;;;:12;:19;;;;;:27;;;;47244:145;94681:16;94656:41;;94716:25;94758:14;94744:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;94744:29:0;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;94716:57:0;;-1:-1:-1;45981:1:0;94842:516;94891:14;94876:11;:29;94842:516;;94947:15;94960:1;94947:12;:15::i;:::-;94935:27;;94989:9;:16;;;95034:8;94985:81;95092:14;;-1:-1:-1;;;;;95092:28:0;;95088:119;;95169:14;;;-1:-1:-1;95088:119:0;95254:5;-1:-1:-1;;;;;95233:26:0;:17;-1:-1:-1;;;;;95233:26:0;;95229:110;;95314:1;95288:8;95297:13;;;;;;95288:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;95229:110;94907:3;;94842:516;;;-1:-1:-1;95383:8:0;;94451:967;-1:-1:-1;;;;;;94451:967:0:o;77230:657::-;77351:13;77379:18;;77351:13;;;77379:18;77653:41;:5;77680:13;77653:26;:41::i;:::-;77709:47;:8;77739:16;77709:29;:47::i;:::-;77852:16;;;77835:1;77852:16;;;;;;;;;77600:279;;;;-1:-1:-1;77600:279:0;;-1:-1:-1;77771:13:0;;-1:-1:-1;77807:4:0;;-1:-1:-1;77835:1:0;-1:-1:-1;77852:16:0;-1:-1:-1;77600:279:0;-1:-1:-1;77230:657:0:o;88655:604::-;88759:1;88748:8;;:12;88740:50;;;;-1:-1:-1;;;88740:50:0;;19184:2:1;88740:50:0;;;19166:21:1;19223:2;19203:18;;;19196:30;19262:27;19242:18;;;19235:55;19307:18;;88740:50:0;18982:349:1;88740:50:0;88833:10;88813:16;88821:7;88813;:16::i;:::-;-1:-1:-1;;;;;88813:30:0;;88805:78;;;;-1:-1:-1;;;88805:78:0;;19538:2:1;88805:78:0;;;19520:21:1;19577:2;19557:18;;;19550:30;19616:34;19596:18;;;19589:62;-1:-1:-1;;;19667:18:1;;;19660:33;19710:19;;88805:78:0;19336:399:1;88805:78:0;88917:4;88906:15;;;;88898:51;;;;-1:-1:-1;;;88898:51:0;;19942:2:1;88898:51:0;;;19924:21:1;19981:2;19961:18;;;19954:30;20020:25;20000:18;;;19993:53;20063:18;;88898:51:0;19740:347:1;88898:51:0;88996:8;;88972:11;31939:14;88972:32;88964:82;;;;-1:-1:-1;;;88964:82:0;;20294:2:1;88964:82:0;;;20276:21:1;20333:2;20313:18;;;20306:30;20372:34;20352:18;;;20345:62;20443:7;20423:18;;;20416:35;20468:19;;88964:82:0;20092:401:1;88964:82:0;89082:8;;89069:9;:21;;89061:63;;;;-1:-1:-1;;;89061:63:0;;20700:2:1;89061:63:0;;;20682:21:1;20739:2;20719:18;;;20712:30;20778:31;20758:18;;;20751:59;20827:18;;89061:63:0;20498:353:1;89061:63:0;89149:23;:11;32058:19;;32076:1;32058:19;;;31969:127;89149:23;89183:14;;;;:5;:14;;;;;;:24;;-1:-1:-1;;89183:24:0;;;;;;;89223;89183:14;;89228:10;;89223:24;;89183:14;89223:24;88655:604;;:::o;50094:104::-;50150:13;50183:7;50176:14;;;;;:::i;91808:106::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;91886:8:::1;:16:::0;91808:106::o;51704:287::-;706:10;-1:-1:-1;;;;;51803:24:0;;;51799:54;;51836:17;;;;;;;;;;;;;;51799:54;706:10;51866:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;51866:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;51866:53:0;;;;;;;;;;51935:48;;586:41:1;;;51866:42:0;;706:10;51935:48;;559:18:1;51935:48:0;446:187:1;52790:369:0;52957:28;52967:4;52973:2;52977:7;52957:9;:28::i;:::-;-1:-1:-1;;;;;53000:13:0;;10114:19;:23;;53000:76;;;;;53020:56;53051:4;53057:2;53061:7;53070:5;53020:30;:56::i;:::-;53019:57;53000:76;52996:156;;;53100:40;;-1:-1:-1;;;53100:40:0;;;;;;;;;;;52996:156;52790:369;;;;:::o;90847:649::-;90970:8;;90926:13;;90970:8;;;;;:17;;90982:5;90970:17;90966:304;;91029:2;91022:9;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;90847:649;;;:::o;90966:304::-;91072:14;;;;:5;:14;;;;;;;;:22;;:14;:22;91068:202;;91156:1;91137:8;91131:22;;;;;:::i;:::-;;;:26;:123;;;;;;;;;;;;;;;;;91197:8;91207:18;:7;:16;:18::i;:::-;91180:55;;;;;;;;;:::i;:::-;;;;;;;;;;;;;91124:130;90847:649;-1:-1:-1;;90847:649:0:o;91068:202::-;91286:28;91317:10;:8;:10::i;:::-;91286:41;;91380:1;91355:14;91349:28;:32;:135;;;;;;;;;;;;;;;;;91421:14;91437:18;:7;:16;:18::i;:::-;91404:61;;;;;;;;;:::i;:::-;;;;;;;;;;;;;91349:135;91342:142;90847:649;-1:-1:-1;;;90847:649:0:o;93750:170::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;93834:8:::1;::::0;::::1;::::0;::::1;;;:17;93826:50;;;::::0;-1:-1:-1;;;93826:50:0;;22918:2:1;93826:50:0::1;::::0;::::1;22900:21:1::0;22957:2;22937:18;;;22930:30;22996:22;22976:18;;;22969:50;23036:18;;93826:50:0::1;22716:344:1::0;93826:50:0::1;93891:8;:17:::0;;;::::1;;;;-1:-1:-1::0;;93891:17:0;;::::1;::::0;;;::::1;::::0;;93750:170::o;84248:22::-;;;;;;;:::i;2717:201::-;1881:6;;-1:-1:-1;;;;;1881:6:0;706:10;2028:23;2020:68;;;;-1:-1:-1;;;2020:68:0;;9935:2:1;2020:68:0;;;9917:21:1;;;9954:18;;;9947:30;-1:-1:-1;;;;;;;;;;;9993:18:1;;;9986:62;10065:18;;2020:68:0;9733:356:1;2020:68:0;-1:-1:-1;;;;;2806:22:0;::::1;2798:73;;;::::0;-1:-1:-1;;;2798:73:0;;23267:2:1;2798:73:0::1;::::0;::::1;23249:21:1::0;23306:2;23286:18;;;23279:30;23345:34;23325:18;;;23318:62;23416:8;23396:18;;;23389:36;23442:19;;2798:73:0::1;23065:402:1::0;2798:73:0::1;2882:28;2901:8;2882:18;:28::i;70925:331::-:0;71021:11;71071:2;71055:5;71049:19;:24;71045:204;;;71097:20;71111:5;71097:13;:20::i;:::-;71090:27;;;;71045:204;71176:5;71150:46;71191:5;71176;71150:46;:::i;:::-;-1:-1:-1;71235:1:0;;-1:-1:-1;71211:26:0;;67873:207;68052:10;67873:207::o;53414:174::-;53471:4;53514:7;45981:1;53495:26;;:53;;;;;53535:13;;53525:7;:23;53495:53;:85;;;;-1:-1:-1;;53553:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;53553:27:0;;;;53552:28;;53414:174::o;61517:196::-;61632:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;61632:29:0;-1:-1:-1;;;;;61632:29:0;;;;;;;;;61677:28;;61632:24;;61677:28;;;;;;;61517:196;;;:::o;54485:1763::-;54634:20;54657:13;;;54695;;;54691:44;;54717:18;;;;;;;;;;;;;;54691:44;54758:61;54788:1;54792:2;54796:12;54810:8;54758:21;:61::i;:::-;-1:-1:-1;;;;;55113:16:0;;;;;;:12;:16;;;;;;;;:44;;55172:49;;;55113:44;;;;;;;;55172:49;;;;-1:-1:-1;;55113:44:0;;;;;;55172:49;;;;;;;;;;;;;;;;55238:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;55288:66:0;;;;-1:-1:-1;;;55338:15:0;55288:66;;;;;;;;;;55238:25;55435:23;;;55479:4;:23;;;;-1:-1:-1;;;;;;55487:13:0;;10114:19;:23;;55487:15;55475:641;;;55523:314;55554:38;;55579:12;;-1:-1:-1;;;;;55554:38:0;;;55571:1;;55554:38;;55571:1;;55554:38;55620:69;55659:1;55663:2;55667:14;;;;;;55683:5;55620:30;:69::i;:::-;55615:174;;55725:40;;-1:-1:-1;;;55725:40:0;;;;;;;;;;;55615:174;55832:3;55816:12;:19;55523:314;;55918:12;55901:13;;:29;55897:43;;55932:8;;;55897:43;55475:641;;;55981:120;56012:40;;56037:14;;;;;-1:-1:-1;;;;;56012:40:0;;;56029:1;;56012:40;;56029:1;;56012:40;56096:3;56080:12;:19;55981:120;;55475:641;-1:-1:-1;56130:13:0;:28;56180:60;54613:1635;54485:1763;;;;:::o;32104:235::-;32184:14;;32217:9;32209:49;;;;-1:-1:-1;;;32209:49:0;;23674:2:1;32209:49:0;;;23656:21:1;23713:2;23693:18;;;23686:30;23752:29;23732:18;;;23725:57;23799:18;;32209:49:0;23472:351:1;32209:49:0;-1:-1:-1;;32311:9:0;32294:26;;32104:235::o;90071:116::-;90155:20;90167:7;90155:11;:20::i;56502:2088::-;56617:35;56655:21;56668:7;56655:12;:21::i;:::-;56617:59;;56715:4;-1:-1:-1;;;;;56693:26:0;:13;:18;;;-1:-1:-1;;;;;56693:26:0;;56689:67;;56728:28;;;;;;;;;;;;;;56689:67;56769:22;706:10;-1:-1:-1;;;;;56795:20:0;;;;:73;;-1:-1:-1;;;;;;52183:25:0;;52159:4;52183:25;;;:18;:25;;;;;;;;706:10;52183:35;;;;;;;;;;56832:36;56795:126;;;-1:-1:-1;706:10:0;56885:20;56897:7;56885:11;:20::i;:::-;-1:-1:-1;;;;;56885:36:0;;56795:126;56769:153;;56940:17;56935:66;;56966:35;;-1:-1:-1;;;56966:35:0;;;;;;;;;;;56935:66;-1:-1:-1;;;;;57016:16:0;;57012:52;;57041:23;;;;;;;;;;;;;;57012:52;57077:43;57099:4;57105:2;57109:7;57118:1;57077:21;:43::i;:::-;57185:35;57202:1;57206:7;57215:4;57185:8;:35::i;:::-;-1:-1:-1;;;;;57516:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;57516:31:0;;;;;;;-1:-1:-1;;57516:31:0;;;;;;;57562:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;57562:29:0;;;;;;;;;;;57642:20;;;:11;:20;;;;;;57677:18;;-1:-1:-1;;;;;;57710:49:0;;;;-1:-1:-1;;;57743:15:0;57710:49;;;;;;;;;;58033:11;;58093:24;;;;;58136:13;;57642:20;;58093:24;;58136:13;58132:384;;58346:13;;58331:11;:28;58327:174;;58384:20;;58453:28;;;;58427:54;;-1:-1:-1;;;58427:54:0;-1:-1:-1;;;;;;58427:54:0;;;-1:-1:-1;;;;;58384:20:0;;58427:54;;;;58327:174;57491:1036;;;58540:42;52790:369;86352:246;86458:7;86492:14;86509:23;86515:3;86520:5;86527:4;86509:5;:23::i;:::-;86492:40;;86554:32;86568:6;86576:9;86554:13;:32::i;:::-;86547:39;86352:246;-1:-1:-1;;;;;;86352:246:0:o;48562:1109::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;48673:7:0;;45981:1;48722:23;;:47;;;;;48756:13;;48749:4;:20;48722:47;48718:886;;;48790:31;48824:17;;;:11;:17;;;;;;;;;48790:51;;;;;;;;;-1:-1:-1;;;;;48790:51:0;;;;-1:-1:-1;;;48790:51:0;;;;;;;;;;;-1:-1:-1;;;48790:51:0;;;;;;;;;;;;;;48860:729;;48910:14;;-1:-1:-1;;;;;48910:28:0;;48906:101;;48974:9;48562:1109;-1:-1:-1;;;48562:1109:0:o;48906:101::-;-1:-1:-1;;;49349:6:0;49394:17;;;;:11;:17;;;;;;;;;49382:29;;;;;;;;;-1:-1:-1;;;;;49382:29:0;;;;;-1:-1:-1;;;49382:29:0;;;;;;;;;;;-1:-1:-1;;;49382:29:0;;;;;;;;;;;;;49442:28;49438:109;;49510:9;48562:1109;-1:-1:-1;;;48562:1109:0:o;49438:109::-;49309:261;;;48771:833;48718:886;49632:31;;;;;;;;;;;;;;3078:191;3171:6;;;-1:-1:-1;;;;;3188:17:0;;;-1:-1:-1;;3188:17:0;;;;;;;3221:40;;3171:6;;;3188:17;3171:6;;3221:40;;3152:16;;3221:40;3141:128;3078:191;:::o;71392:244::-;71486:13;70794:4;70758:40;;71516:17;71512:117;;71557:15;71566:5;71557:8;:15::i;71512:117::-;71612:5;71605:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62205:667;62389:72;;-1:-1:-1;;;62389:72:0;;62368:4;;-1:-1:-1;;;;;62389:36:0;;;;;:72;;706:10;;62440:4;;62446:7;;62455:5;;62389:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62389:72:0;;;;;;;;-1:-1:-1;;62389:72:0;;;;;;;;;;;;:::i;:::-;;;62385:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62623:6;:13;62640:1;62623:18;62619:235;;62669:40;;-1:-1:-1;;;62669:40:0;;;;;;;;;;;62619:235;62812:6;62806:13;62797:6;62793:2;62789:15;62782:38;62385:480;-1:-1:-1;;;;;;62508:55:0;-1:-1:-1;;;62508:55:0;;-1:-1:-1;62501:62:0;;29308:723;29364:13;29585:5;29594:1;29585:10;29581:53;;-1:-1:-1;;29612:10:0;;;;;;;;;;;;;;;;;;29308:723::o;29581:53::-;29659:5;29644:12;29700:78;29707:9;;29700:78;;29733:8;;;;:::i;:::-;;-1:-1:-1;29756:10:0;;-1:-1:-1;29764:2:0;29756:10;;:::i;:::-;;;29700:78;;;29788:19;29820:6;29810:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;29810:17:0;;29788:39;;29838:154;29845:10;;29838:154;;29872:11;29882:1;29872:11;;:::i;:::-;;-1:-1:-1;29941:10:0;29949:2;29941:5;:10;:::i;:::-;29928:24;;:2;:24;:::i;:::-;29915:39;;29898:6;29905;29898:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;29969:11:0;29978:2;29969:11;;:::i;:::-;;;29838:154;;90465:132;90525:13;90572;90565:20;;;;;:::i;69805:292::-;69870:11;69894:17;69920:3;69894:30;;69953:2;69939:4;:11;:16;69935:74;;;69993:3;69979:18;;;;;;;;;;;:::i;69935:74::-;70076:11;;70059:13;70076:4;70059:13;:::i;:::-;70051:36;;69805:292;-1:-1:-1;;;69805:292:0:o;89731:328::-;89883:14;;;;:5;:14;;;;;;;;:22;;:14;:22;89879:169;;-1:-1:-1;;;;;89948:18:0;;;;:38;;-1:-1:-1;;;;;;89970:16:0;;;89948:38;89940:80;;;;-1:-1:-1;;;89940:80:0;;25667:2:1;89940:80:0;;;25649:21:1;25706:2;25686:18;;;25679:30;25745:31;25725:18;;;25718:59;25794:18;;89940:80:0;25465:353:1;58673:89:0;58733:21;58739:7;58748:5;58733;:21::i;86610:334::-;86758:172;;;86787:63;86758:172;;;26054:25:1;26095:18;;;26088:34;;;26138:18;;;26131:34;;;-1:-1:-1;;;;;26201:55:1;;26181:18;;;26174:83;86690:7:0;;86731:201;;26026:19:1;;86758:172:0;;;;;;;;;;;;86748:183;;;;;;86731:16;:201::i;36971:231::-;37049:7;37070:17;37089:18;37111:27;37122:4;37128:9;37111:10;:27::i;:::-;37069:69;;;;37149:18;37161:5;37149:11;:18::i;:::-;-1:-1:-1;37185:9:0;36971:231;-1:-1:-1;;;36971:231:0:o;70186:411::-;70407:14;;;70418:2;70407:14;;;;;;;;;70245:13;;70794:4;70758:40;;;70271:11;;70407:14;;;70418:2;;70407:14;;;-1:-1:-1;;;70500:16:0;;;-1:-1:-1;70546:4:0;70537:14;;70530:28;;;;-1:-1:-1;70500:16:0;70186:411::o;58991:2408::-;59071:35;59109:21;59122:7;59109:12;:21::i;:::-;59158:18;;59071:59;;-1:-1:-1;59189:290:0;;;;59223:22;706:10;-1:-1:-1;;;;;59249:20:0;;;;:77;;-1:-1:-1;;;;;;52183:25:0;;52159:4;52183:25;;;:18;:25;;;;;;;;706:10;52183:35;;;;;;;;;;59290:36;59249:134;;;-1:-1:-1;706:10:0;59347:20;59359:7;59347:11;:20::i;:::-;-1:-1:-1;;;;;59347:36:0;;59249:134;59223:161;;59406:17;59401:66;;59432:35;;-1:-1:-1;;;59432:35:0;;;;;;;;;;;59401:66;59208:271;59189:290;59491:51;59513:4;59527:1;59531:7;59540:1;59491:21;:51::i;:::-;59607:35;59624:1;59628:7;59637:4;59607:8;:35::i;:::-;-1:-1:-1;;;;;59972:18:0;;;59938:31;59972:18;;;:12;:18;;;;;;;;60005:24;;60044:29;-1:-1:-1;;60005:24:0;;;;;;;;;;-1:-1:-1;;60005:24:0;;;;60044:29;;;;;60028:1;60044:29;;;;;;;;;;;;;;;;;;;60206:20;;;:11;:20;;;;;;60241;;60340:22;60309:15;60276:49;;;-1:-1:-1;;;60276:49:0;-1:-1:-1;;;;;;60276:49:0;;;;;;;;;;60340:22;-1:-1:-1;;;60340:22:0;;;60632:11;;;60692:24;;;;;60735:13;;59972:18;;60692:24;;60735:13;60731:384;;60945:13;;60930:11;:28;60926:174;;60983:20;;61052:28;;;;61026:54;;-1:-1:-1;;;61026:54:0;-1:-1:-1;;;;;;61026:54:0;;;-1:-1:-1;;;;;60983:20:0;;61026:54;;;;60926:174;-1:-1:-1;;61143:35:0;;61170:7;;-1:-1:-1;61166:1:0;;-1:-1:-1;;;;;;61143:35:0;;;;;61166:1;;61143:35;-1:-1:-1;;61366:12:0;:14;;;;;;-1:-1:-1;;58991:2408:0:o;77008:167::-;77085:7;77112:55;77134:20;:18;:20::i;:::-;77156:10;41958:4;41952:11;41989:10;41977:23;;42030:4;42021:14;;42014:39;;;;42083:4;42074:14;;42067:34;42138:4;42123:20;;;41755:406;35422:747;35503:7;35512:12;35541:9;:16;35561:2;35541:22;35537:625;;35885:4;35870:20;;35864:27;35935:4;35920:20;;35914:27;35993:4;35978:20;;35972:27;35580:9;35964:36;36036:25;36047:4;35964:36;35864:27;35914;36036:10;:25::i;:::-;36029:32;;;;;;;;;35537:625;-1:-1:-1;36110:1:0;;-1:-1:-1;36114:35:0;35537:625;35422:747;;;;;:::o;33815:521::-;33893:20;33884:5;:29;;;;;;;;:::i;:::-;;33880:449;;33815:521;:::o;33880:449::-;33991:29;33982:5;:38;;;;;;;;:::i;:::-;;33978:351;;34037:34;;-1:-1:-1;;;34037:34:0;;26659:2:1;34037:34:0;;;26641:21:1;26698:2;26678:18;;;26671:30;26737:26;26717:18;;;26710:54;26781:18;;34037:34:0;26457:348:1;33978:351:0;34102:35;34093:5;:44;;;;;;;;:::i;:::-;;34089:240;;34154:41;;-1:-1:-1;;;34154:41:0;;27012:2:1;34154:41:0;;;26994:21:1;27051:2;27031:18;;;27024:30;27090:33;27070:18;;;27063:61;27141:18;;34154:41:0;26810:355:1;34089:240:0;34226:30;34217:5;:39;;;;;;;;:::i;:::-;;34213:116;;34273:44;;-1:-1:-1;;;34273:44:0;;27372:2:1;34273:44:0;;;27354:21:1;27411:2;27391:18;;;27384:30;27450:34;27430:18;;;27423:62;27521:4;27501:18;;;27494:32;27543:19;;34273:44:0;27170:398:1;75908:268:0;75961:7;75993:4;-1:-1:-1;;;;;76002:11:0;75985:28;;:63;;;;;76034:14;76017:13;:31;75985:63;75981:188;;;-1:-1:-1;76072:22:0;;75908:268::o;75981:188::-;76134:23;76276:81;;;74100:95;76276:81;;;28235:25:1;76299:11:0;28276:18:1;;;28269:34;;;;76312:14:0;28319:18:1;;;28312:34;76328:13:0;28362:18:1;;;28355:34;76351:4:0;28405:19:1;;;28398:84;76239:7:0;;28207:19:1;;76276:81:0;;;;;;;;;;;;76266:92;;;;;;76259:99;;76184:182;;38355:1477;38443:7;;39377:66;39364:79;;39360:163;;;-1:-1:-1;39476:1:0;;-1:-1:-1;39480:30:0;39460:51;;39360:163;39637:24;;;39620:14;39637:24;;;;;;;;;27800:25:1;;;27873:4;27861:17;;27841:18;;;27834:45;;;;27895:18;;;27888:34;;;27938:18;;;27931:34;;;39637:24:0;;27772:19:1;;39637:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;39637:24:0;;-1:-1:-1;;39637:24:0;;;-1:-1:-1;;;;;;;39676:20:0;;39672:103;;39729:1;39733:29;39713:50;;;;;;;39672:103;39795:6;-1:-1:-1;39803:20:0;;-1:-1:-1;38355:1477:0;;;;;;;;:::o;14:177:1:-;-1:-1:-1;;;;;;92:5:1;88:78;81:5;78:89;68:117;;181:1;178;171:12;196:245;254:6;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;362:9;349:23;381:30;405:5;381:30;:::i;638:160::-;703:20;;759:13;;752:21;742:32;;732:60;;788:1;785;778:12;732:60;638:160;;;:::o;803:180::-;859:6;912:2;900:9;891:7;887:23;883:32;880:52;;;928:1;925;918:12;880:52;951:26;967:9;951:26;:::i;988:250::-;1073:1;1083:113;1097:6;1094:1;1091:13;1083:113;;;1173:11;;;1167:18;1154:11;;;1147:39;1119:2;1112:10;1083:113;;;-1:-1:-1;;1230:1:1;1212:16;;1205:27;988:250::o;1243:271::-;1285:3;1323:5;1317:12;1350:6;1345:3;1338:19;1366:76;1435:6;1428:4;1423:3;1419:14;1412:4;1405:5;1401:16;1366:76;:::i;:::-;1496:2;1475:15;-1:-1:-1;;1471:29:1;1462:39;;;;1503:4;1458:50;;1243:271;-1:-1:-1;;1243:271:1:o;1519:220::-;1668:2;1657:9;1650:21;1631:4;1688:45;1729:2;1718:9;1714:18;1706:6;1688:45;:::i;1744:180::-;1803:6;1856:2;1844:9;1835:7;1831:23;1827:32;1824:52;;;1872:1;1869;1862:12;1824:52;-1:-1:-1;1895:23:1;;1744:180;-1:-1:-1;1744:180:1:o;2160:196::-;2228:20;;-1:-1:-1;;;;;2277:54:1;;2267:65;;2257:93;;2346:1;2343;2336:12;2361:254;2429:6;2437;2490:2;2478:9;2469:7;2465:23;2461:32;2458:52;;;2506:1;2503;2496:12;2458:52;2529:29;2548:9;2529:29;:::i;:::-;2519:39;2605:2;2590:18;;;;2577:32;;-1:-1:-1;;;2361:254:1:o;2620:184::-;-1:-1:-1;;;2669:1:1;2662:88;2769:4;2766:1;2759:15;2793:4;2790:1;2783:15;2809:275;2880:2;2874:9;2945:2;2926:13;;-1:-1:-1;;2922:27:1;2910:40;;2980:18;2965:34;;3001:22;;;2962:62;2959:88;;;3027:18;;:::i;:::-;3063:2;3056:22;2809:275;;-1:-1:-1;2809:275:1:o;3089:952::-;3173:6;3204:2;3247;3235:9;3226:7;3222:23;3218:32;3215:52;;;3263:1;3260;3253:12;3215:52;3303:9;3290:23;3332:18;3373:2;3365:6;3362:14;3359:34;;;3389:1;3386;3379:12;3359:34;3427:6;3416:9;3412:22;3402:32;;3472:7;3465:4;3461:2;3457:13;3453:27;3443:55;;3494:1;3491;3484:12;3443:55;3530:2;3517:16;3552:2;3548;3545:10;3542:36;;;3558:18;;:::i;:::-;3604:2;3601:1;3597:10;3587:20;;3627:28;3651:2;3647;3643:11;3627:28;:::i;:::-;3689:15;;;3759:11;;;3755:20;;;3720:12;;;;3787:19;;;3784:39;;;3819:1;3816;3809:12;3784:39;3843:11;;;;3863:148;3879:6;3874:3;3871:15;3863:148;;;3945:23;3964:3;3945:23;:::i;:::-;3933:36;;3896:12;;;;3989;;;;3863:148;;;4030:5;3089:952;-1:-1:-1;;;;;;;;3089:952:1:o;4046:407::-;4111:5;4145:18;4137:6;4134:30;4131:56;;;4167:18;;:::i;:::-;4205:57;4250:2;4229:15;;-1:-1:-1;;4225:29:1;4256:4;4221:40;4205:57;:::i;:::-;4196:66;;4285:6;4278:5;4271:21;4325:3;4316:6;4311:3;4307:16;4304:25;4301:45;;;4342:1;4339;4332:12;4301:45;4391:6;4386:3;4379:4;4372:5;4368:16;4355:43;4445:1;4438:4;4429:6;4422:5;4418:18;4414:29;4407:40;4046:407;;;;;:::o;4458:451::-;4527:6;4580:2;4568:9;4559:7;4555:23;4551:32;4548:52;;;4596:1;4593;4586:12;4548:52;4636:9;4623:23;4669:18;4661:6;4658:30;4655:50;;;4701:1;4698;4691:12;4655:50;4724:22;;4777:4;4769:13;;4765:27;-1:-1:-1;4755:55:1;;4806:1;4803;4796:12;4755:55;4829:74;4895:7;4890:2;4877:16;4872:2;4868;4864:11;4829:74;:::i;4914:186::-;4973:6;5026:2;5014:9;5005:7;5001:23;4997:32;4994:52;;;5042:1;5039;5032:12;4994:52;5065:29;5084:9;5065:29;:::i;5287:328::-;5364:6;5372;5380;5433:2;5421:9;5412:7;5408:23;5404:32;5401:52;;;5449:1;5446;5439:12;5401:52;5472:29;5491:9;5472:29;:::i;:::-;5462:39;;5520:38;5554:2;5543:9;5539:18;5520:38;:::i;:::-;5510:48;;5605:2;5594:9;5590:18;5577:32;5567:42;;5287:328;;;;;:::o;5620:221::-;5662:5;5715:3;5708:4;5700:6;5696:17;5692:27;5682:55;;5733:1;5730;5723:12;5682:55;5755:80;5831:3;5822:6;5809:20;5802:4;5794:6;5790:17;5755:80;:::i;5846:531::-;5941:6;5949;5957;5965;6018:3;6006:9;5997:7;5993:23;5989:33;5986:53;;;6035:1;6032;6025:12;5986:53;6071:9;6058:23;6048:33;;6128:2;6117:9;6113:18;6100:32;6090:42;;6151:38;6185:2;6174:9;6170:18;6151:38;:::i;:::-;6141:48;;6240:2;6229:9;6225:18;6212:32;6267:18;6259:6;6256:30;6253:50;;;6299:1;6296;6289:12;6253:50;6322:49;6363:7;6354:6;6343:9;6339:22;6322:49;:::i;:::-;6312:59;;;5846:531;;;;;;;:::o;6382:320::-;6450:6;6503:2;6491:9;6482:7;6478:23;6474:32;6471:52;;;6519:1;6516;6509:12;6471:52;6559:9;6546:23;6592:18;6584:6;6581:30;6578:50;;;6624:1;6621;6614:12;6578:50;6647:49;6688:7;6679:6;6668:9;6664:22;6647:49;:::i;6707:435::-;6760:3;6798:5;6792:12;6825:6;6820:3;6813:19;6851:4;6880:2;6875:3;6871:12;6864:19;;6917:2;6910:5;6906:14;6938:1;6948:169;6962:6;6959:1;6956:13;6948:169;;;7023:13;;7011:26;;7057:12;;;;7092:15;;;;6984:1;6977:9;6948:169;;;-1:-1:-1;7133:3:1;;6707:435;-1:-1:-1;;;;;6707:435:1:o;7147:261::-;7326:2;7315:9;7308:21;7289:4;7346:56;7398:2;7387:9;7383:18;7375:6;7346:56;:::i;7413:996::-;7810:66;7802:6;7798:79;7787:9;7780:98;7914:3;7909:2;7898:9;7894:18;7887:31;7761:4;7941:46;7982:3;7971:9;7967:19;7959:6;7941:46;:::i;:::-;8035:9;8027:6;8023:22;8018:2;8007:9;8003:18;7996:50;8069:33;8095:6;8087;8069:33;:::i;:::-;8055:47;;8138:6;8133:2;8122:9;8118:18;8111:34;-1:-1:-1;;;;;8186:6:1;8182:55;8176:3;8165:9;8161:19;8154:84;8275:6;8269:3;8258:9;8254:19;8247:35;8331:9;8323:6;8319:22;8313:3;8302:9;8298:19;8291:51;8359:44;8396:6;8388;8359:44;:::i;:::-;8351:52;7413:996;-1:-1:-1;;;;;;;;;;7413:996:1:o;8414:248::-;8479:6;8487;8540:2;8528:9;8519:7;8515:23;8511:32;8508:52;;;8556:1;8553;8546:12;8508:52;8592:9;8579:23;8569:33;;8621:35;8652:2;8641:9;8637:18;8621:35;:::i;:::-;8611:45;;8414:248;;;;;:::o;8667:254::-;8732:6;8740;8793:2;8781:9;8772:7;8768:23;8764:32;8761:52;;;8809:1;8806;8799:12;8761:52;8832:29;8851:9;8832:29;:::i;:::-;8822:39;;8880:35;8911:2;8900:9;8896:18;8880:35;:::i;8926:537::-;9021:6;9029;9037;9045;9098:3;9086:9;9077:7;9073:23;9069:33;9066:53;;;9115:1;9112;9105:12;9066:53;9138:29;9157:9;9138:29;:::i;:::-;9128:39;;9186:38;9220:2;9209:9;9205:18;9186:38;:::i;:::-;9176:48;;9271:2;9260:9;9256:18;9243:32;9233:42;;9326:2;9315:9;9311:18;9298:32;9353:18;9345:6;9342:30;9339:50;;;9385:1;9382;9375:12;9468:260;9536:6;9544;9597:2;9585:9;9576:7;9572:23;9568:32;9565:52;;;9613:1;9610;9603:12;9565:52;9636:29;9655:9;9636:29;:::i;:::-;9626:39;;9684:38;9718:2;9707:9;9703:18;9684:38;:::i;10094:437::-;10173:1;10169:12;;;;10216;;;10237:61;;10291:4;10283:6;10279:17;10269:27;;10237:61;10344:2;10336:6;10333:14;10313:18;10310:38;10307:218;;-1:-1:-1;;;10378:1:1;10371:88;10482:4;10479:1;10472:15;10510:4;10507:1;10500:15;10307:218;;10094:437;;;:::o;10536:184::-;-1:-1:-1;;;10585:1:1;10578:88;10685:4;10682:1;10675:15;10709:4;10706:1;10699:15;10725:125;10790:9;;;10811:10;;;10808:36;;;10824:18;;:::i;11192:184::-;-1:-1:-1;;;11241:1:1;11234:88;11341:4;11338:1;11331:15;11365:4;11362:1;11355:15;11571:135;11610:3;11631:17;;;11628:43;;11651:18;;:::i;:::-;-1:-1:-1;11698:1:1;11687:13;;11571:135::o;11837:545::-;11939:2;11934:3;11931:11;11928:448;;;11975:1;12000:5;11996:2;11989:17;12045:4;12041:2;12031:19;12115:2;12103:10;12099:19;12096:1;12092:27;12086:4;12082:38;12151:4;12139:10;12136:20;12133:47;;;-1:-1:-1;12174:4:1;12133:47;12229:2;12224:3;12220:12;12217:1;12213:20;12207:4;12203:31;12193:41;;12284:82;12302:2;12295:5;12292:13;12284:82;;;12347:17;;;12328:1;12317:13;12284:82;;;12288:3;;;11837:545;;;:::o;12558:1352::-;12684:3;12678:10;12711:18;12703:6;12700:30;12697:56;;;12733:18;;:::i;:::-;12762:97;12852:6;12812:38;12844:4;12838:11;12812:38;:::i;:::-;12806:4;12762:97;:::i;:::-;12914:4;;12978:2;12967:14;;12995:1;12990:663;;;;13697:1;13714:6;13711:89;;;-1:-1:-1;13766:19:1;;;13760:26;13711:89;-1:-1:-1;;12515:1:1;12511:11;;;12507:24;12503:29;12493:40;12539:1;12535:11;;;12490:57;13813:81;;12960:944;;12990:663;11784:1;11777:14;;;11821:4;11808:18;;-1:-1:-1;;13026:20:1;;;13144:236;13158:7;13155:1;13152:14;13144:236;;;13247:19;;;13241:26;13226:42;;13339:27;;;;13307:1;13295:14;;;;13174:19;;13144:236;;;13148:3;13408:6;13399:7;13396:19;13393:201;;;13469:19;;;13463:26;-1:-1:-1;;13552:1:1;13548:14;;;13564:3;13544:24;13540:37;13536:42;13521:58;13506:74;;13393:201;-1:-1:-1;;;;;13640:1:1;13624:14;;;13620:22;13607:36;;-1:-1:-1;12558:1352:1:o;16449:168::-;16522:9;;;16553;;16570:15;;;16564:22;;16550:37;16540:71;;16591:18;;:::i;18285:287::-;18414:3;18452:6;18446:13;18468:66;18527:6;18522:3;18515:4;18507:6;18503:17;18468:66;:::i;:::-;18550:16;;;;;18285:287;-1:-1:-1;;18285:287:1:o;20856:1187::-;21133:3;21162:1;21195:6;21189:13;21225:36;21251:9;21225:36;:::i;:::-;21280:1;21297:18;;;21324:133;;;;21471:1;21466:356;;;;21290:532;;21324:133;-1:-1:-1;;21357:24:1;;21345:37;;21430:14;;21423:22;21411:35;;21402:45;;;-1:-1:-1;21324:133:1;;21466:356;21497:6;21494:1;21487:17;21527:4;21572:2;21569:1;21559:16;21597:1;21611:165;21625:6;21622:1;21619:13;21611:165;;;21703:14;;21690:11;;;21683:35;21746:16;;;;21640:10;;21611:165;;;21615:3;;;21805:6;21800:3;21796:16;21789:23;;21290:532;;;;;21853:6;21847:13;21869:68;21928:8;21923:3;21916:4;21908:6;21904:17;21869:68;:::i;:::-;22000:7;21959:18;;21986:22;;;22035:1;22024:13;;20856:1187;-1:-1:-1;;;;20856:1187:1:o;22048:663::-;22328:3;22366:6;22360:13;22382:66;22441:6;22436:3;22429:4;22421:6;22417:17;22382:66;:::i;:::-;22511:13;;22470:16;;;;22533:70;22511:13;22470:16;22580:4;22568:17;;22533:70;:::i;23828:512::-;24022:4;-1:-1:-1;;;;;24132:2:1;24124:6;24120:15;24109:9;24102:34;24184:2;24176:6;24172:15;24167:2;24156:9;24152:18;24145:43;;24224:6;24219:2;24208:9;24204:18;24197:34;24267:3;24262:2;24251:9;24247:18;24240:31;24288:46;24329:3;24318:9;24314:19;24306:6;24288:46;:::i;24345:249::-;24414:6;24467:2;24455:9;24446:7;24442:23;24438:32;24435:52;;;24483:1;24480;24473:12;24435:52;24515:9;24509:16;24534:30;24558:5;24534:30;:::i;24599:184::-;-1:-1:-1;;;24648:1:1;24641:88;24748:4;24745:1;24738:15;24772:4;24769:1;24762:15;24788:120;24828:1;24854;24844:35;;24859:18;;:::i;:::-;-1:-1:-1;24893:9:1;;24788:120::o;24913:128::-;24980:9;;;25001:11;;;24998:37;;;25015:18;;:::i;25046:112::-;25078:1;25104;25094:35;;25109:18;;:::i;:::-;-1:-1:-1;25143:9:1;;25046:112::o;25163:297::-;25281:12;;25328:4;25317:16;;;25311:23;;25281:12;25346:16;;25343:111;;;-1:-1:-1;;25420:4:1;25416:17;;;;25413:1;25409:25;25405:38;25394:50;;25163:297;-1:-1:-1;25163:297:1:o;26268:184::-;-1:-1:-1;;;26317:1:1;26310:88;26417:4;26414:1;26407:15;26441:4;26438:1;26431:15

ipfs://015fe6ec817bebf9b35f2146d630f4a1f9fad7c35562b3d14c658dca2e98fe41