Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(address fro ...
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• interface IERC721Receiver
•    - function onERC721Received(address ope ...
•    - function supportsInterface(bytes4 int ...
•    - function _registerInterface(bytes4 in ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(address ...
•    - function _verifyCallResult(bool succe ...
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function add(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
• library EnumerableMap
•    - function _set(Map storage map, bytes3 ...
•    - function _remove(Map storage map, byt ...
•    - function _contains(Map storage map, b ...
•    - function _length(Map storage map)
•    - function _at(Map storage map, uint256 ...
•    - function _tryGet(Map storage map, byt ...
•    - function _get(Map storage map, bytes3 ...
•    - function _get(Map storage map, bytes3 ...
•    - function set(UintToAddressMap storage ...
•    - function remove(UintToAddressMap stor ...
•    - function contains(UintToAddressMap st ...
•    - function length(UintToAddressMap stor ...
•    - function at(UintToAddressMap storage ...
•    - function tryGet(UintToAddressMap stor ...
•    - function get(UintToAddressMap storage ...
•    - function get(UintToAddressMap storage ...
• library Strings
•    - function toString(uint256 value)
•  contract ERC721 is Context, ERC165 ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function baseURI()
•    - function tokenOfOwnerByIndex(address ...
•    - function totalSupply()
•    - function tokenByIndex(uint256 index)
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(address from, a ...
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function _safeTransfer(address from, ...
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(address to, uint25 ...
•    - function _mint(address to, uint256 to ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(address from, addr ...
•    - function _setTokenURI(uint256 tokenId ...
•    - function _setBaseURI(string memory ba ...
•    - function _checkOnERC721Received(addre ...
•    - function _approve(address to, uint256 ...
•    - function _beforeTokenTransfer(address ...
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•  contract MouthBreathers is ERC721, ... *
•    - function withdraw()
•    - function reserveMouthBreathers(addres ...
•    - function setBaseURI(string memory bas ...
•    - function flipSaleState()
•    - function tokensOfOwner(address _owner ...
•    - function tokenLicense(uint _id)
•    - function lockLicense()
•    - function changeLicense(string memory ...
•    - function mintMouthBreather(uint numbe ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-08-08
*/

/**
 *Submitted for verification at Etherscan.io on 2021-08-06
*/

// SPDX-License-Identifier: MIT

// GO TO LINE 1913 TO SEE WHERE THE MOUTH BREATHERS STARTS

// File: @openzeppelin/contracts/utils/Context.sol


//The MIT License

//Copyright (c) 2017-2019 0xcert, d.o.o. https://0xcert.org

//Permission is hereby granted, free of charge, to any person obtaining a copy
//of this software and associated documentation files (the "Software"), to deal
//in the Software without restriction, including without limitation the rights
//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//copies of the Software, and to permit persons to whom the Software is
//furnished to do so, subject to the following conditions:

//The above copyright notice and this permission notice shall be included in
//all copies or substantial portions of the Software.

//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//THE SOFTWARE.


pragma solidity >=0.6.2 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN 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 memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contracts/introspection/IERC165.sol



pragma solidity >=0.6.2 <0.8.0;

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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol



pragma solidity >=0.6.2 <0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Metadata.sol



pragma solidity >=0.6.2 <0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

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

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

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol



pragma solidity >=0.6.2 <0.8.0;


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

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol



pragma solidity >=0.6.2 <0.8.0;

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

// File: @openzeppelin/contracts/introspection/ERC165.sol



pragma solidity >=0.6.2 <0.8.0;


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

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

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

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

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

// File: @openzeppelin/contracts/math/SafeMath.sol



pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

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

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

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

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/utils/Address.sol



pragma solidity >=0.6.2 <0.8.0;

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 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");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/utils/EnumerableSet.sol



pragma solidity >=0.6.2 <0.8.0;

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

    struct Set {
        // Storage of set values
        bytes32[] _values;

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

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

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

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

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

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

// File: @openzeppelin/contracts/utils/EnumerableMap.sol



pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) { // Equivalent to !contains(map, key)
            map._entries.push(MapEntry({ _key: key, _value: value }));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

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

        if (keyIndex != 0) { // Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

            // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

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

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

   /**
    * @dev Returns the key-value pair stored at position `index` in the map. O(1).
    *
    * Note that there are no guarantees on the ordering of entries inside the
    * array, and it may change when more entries are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
        require(map._entries.length > index, "EnumerableMap: index out of bounds");

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        uint256 keyIndex = map._indexes[key];
        if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key)
        return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

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

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

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

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

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol



pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` 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);
        uint256 index = digits - 1;
        temp = value;
        while (temp != 0) {
            buffer[index--] = bytes1(uint8(48 + temp % 10));
            temp /= 10;
        }
        return string(buffer);
    }
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol



pragma solidity >=0.6.2 <0.8.0;

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */

contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

    // Mapping from holder address to their (enumerable) set of owned tokens
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Optional mapping for token URIs
    mapping (uint256 => string) private _tokenURIs;

    // Base URI
    string private _baseURI;

    /*
     *     bytes4(keccak256('balanceOf(address)')) == 0x70a08231
     *     bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
     *     bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
     *     bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
     *     bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
     *
     *     => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
     *        0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    /*
     *     bytes4(keccak256('name()')) == 0x06fdde03
     *     bytes4(keccak256('symbol()')) == 0x95d89b41
     *     bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
     *
     *     => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
     */
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

    /*
     *     bytes4(keccak256('totalSupply()')) == 0x18160ddd
     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
     *     bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
     *
     *     => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
     */
    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;

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

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _holderTokens[owner].length();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

    /**
     * @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) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }
        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(base, tokenId.toString()));
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a prefix in {tokenURI} to each token's URI, or
    * to the token ID if no specific URI is set for that token ID.
    */
    function baseURI() public view virtual returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

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

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _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 {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId); // internal owner

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

        // Clear approvals
        _approve(address(0), tokenId);

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
        private returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }
        bytes memory returndata = to.functionCall(abi.encodeWithSelector(
            IERC721Receiver(to).onERC721Received.selector,
            _msgSender(),
            from,
            tokenId,
            _data
        ), "ERC721: transfer to non ERC721Receiver implementer");
        bytes4 retval = abi.decode(returndata, (bytes4));
        return (retval == _ERC721_RECEIVED);
    }

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

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * 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, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}

// File: @openzeppelin/contracts/access/Ownable.sol



pragma solidity >=0.6.2 <0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), 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 {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}



//The biggest mouths on the blockchain!
//Mouth Breathers are 10,000 fish generated from 75 traits and a variety of colors.
//The supply and price ensure that Mouth Breathers is an accessible generative project to all.
//Go ahead and mint one...or two...or twenty, the price is unbeatable!
//WARNING: they may get mouthy with you.

// TEAM

//artist/dev/publciity - @THEFISHERY2 (twitter)
//mouth breathers page - @MOUTHBREATHERS0 (twitter)

pragma solidity >=0.6.2 <0.8.0;
pragma abicoder v2;

contract MouthBreathers is ERC721, Ownable {

    using SafeMath for uint256;

    string public LICENSE_TEXT = ""; // IT IS WHAT IT SAYS

    bool licenseLocked = false; // TEAM CAN'T EDIT THE LICENSE AFTER THIS GETS TRUE

    uint256 public constant mouthBreatherPrice = 10000000000000000; // 0.01 ETH

    uint public constant maxMouthBreatherPurchase = 20;

    uint256 public constant MAX_MOUTHBREATHERS = 10000;

    bool public saleIsActive = false;

    // Reserve 20 Mouth Breathers for team - Giveaways/gifts/personal MBs
    uint public mouthBreatherReserve = 20;

    event licenseisLocked(string _licenseText);

    constructor() ERC721("Mouth Breathers", "MBs") { }

    function withdraw() public onlyOwner {
        uint balance = address(this).balance;
        msg.sender.transfer(balance);
    }

    function reserveMouthBreathers(address _to, uint256 _reserveAmount) public onlyOwner {
        uint supply = totalSupply();
        require(_reserveAmount > 0 && _reserveAmount <= mouthBreatherReserve, "Not enough reserve left for team");
        for (uint i = 0; i < _reserveAmount; i++) {
            _safeMint(_to, supply + i);
        }
        mouthBreatherReserve = mouthBreatherReserve.sub(_reserveAmount);
    }

    
    function setBaseURI(string memory baseURI) public onlyOwner {
        _setBaseURI(baseURI);
    }


    function flipSaleState() public onlyOwner {
        saleIsActive = !saleIsActive;
    }


    function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
        uint256 tokenCount = balanceOf(_owner);
        if (tokenCount == 0) {
            // Return an empty array
            return new uint256[](0);
        } else {
            uint256[] memory result = new uint256[](tokenCount);
            uint256 index;
            for (index = 0; index < tokenCount; index++) {
                result[index] = tokenOfOwnerByIndex(_owner, index);
            }
            return result;
        }
    }

    // Returns the license for tokens
    function tokenLicense(uint _id) public view returns(string memory) {
        require(_id < totalSupply(), "CHOOSE A MOUTH BREATHER WITHIN RANGE");
        return LICENSE_TEXT;
    }

    // Locks the license to prevent further changes
    function lockLicense() public onlyOwner {
        licenseLocked =  true;
        emit licenseisLocked(LICENSE_TEXT);
    }

    // Change the license
    function changeLicense(string memory _license) public onlyOwner {
        require(licenseLocked == false, "License already locked");
        LICENSE_TEXT = _license;
    }


    function mintMouthBreather(uint numberOfTokens) public payable {
        require(saleIsActive, "Sale must be active to mint Mouth Breather");
        require(numberOfTokens > 0 && numberOfTokens <= maxMouthBreatherPurchase, "Can only mint 20 tokens at a time");
        require(totalSupply().add(numberOfTokens) <= MAX_MOUTHBREATHERS, "Purchase would exceed max supply of Mouth Breathers");
        require(msg.value >= mouthBreatherPrice.mul(numberOfTokens), "Ether value sent is not correct");

        for(uint i = 0; i < numberOfTokens; i++) {
            uint mintIndex = totalSupply();
            if (totalSupply() < MAX_MOUTHBREATHERS) {
                _safeMint(msg.sender, mintIndex);
            }
        }

    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_licenseText","type":"string"}],"name":"licenseisLocked","type":"event"},{"inputs":[],"name":"LICENSE_TEXT","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_MOUTHBREATHERS","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":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_license","type":"string"}],"name":"changeLicense","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockLicense","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxMouthBreatherPurchase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mintMouthBreather","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mouthBreatherPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mouthBreatherReserve","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_reserveAmount","type":"uint256"}],"name":"reserveMouthBreathers","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":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"tokenLicense","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"tokensOfOwner","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":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

68582:3415:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68901:50;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11520:150;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52804:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55590:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55120:404;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69135:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54598:211;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56480:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54360:162;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69978:89;;;;;;;;;;;;;:::i;:::-;;68960:50;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69290:131;;;;;;;;;;;;;:::i;:::-;;68818:62;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56856:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54886:172;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69869:99;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52560:177;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54179:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52277:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67515:148;;;;;;;;;;;;;:::i;:::-;;70077:540;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66864:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52973:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69429:426;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68669:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55883:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71069:174;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57078:285;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70909:125;;;;;;;;;;;;;:::i;:::-;;53148:792;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71253:739;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70664:184;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56249:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69019:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67818:244;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68901:50;68949:2;68901:50;:::o;11520:150::-;11605:4;11629:20;:33;11650:11;11629:33;;;;;;;;;;;;;;;;;;;;;;;;;;;11622:40;;11520:150;;;:::o;52804:100::-;52858:13;52891:5;52884:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52804:100;:::o;55590:221::-;55666:7;55694:16;55702:7;55694;:16::i;:::-;55686:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;55779:15;:24;55795:7;55779:24;;;;;;;;;;;;;;;;;;;;;55772:31;;55590:221;;;:::o;55120:404::-;55201:13;55217:23;55232:7;55217:14;:23::i;:::-;55201:39;;55265:5;55259:11;;:2;:11;;;;55251:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;55345:5;55329:21;;:12;:10;:12::i;:::-;:21;;;:69;;;;55354:44;55378:5;55385:12;:10;:12::i;:::-;55354:23;:44::i;:::-;55329:69;55321:161;;;;;;;;;;;;:::i;:::-;;;;;;;;;55495:21;55504:2;55508:7;55495:8;:21::i;:::-;55120:404;;;:::o;69135:37::-;;;;:::o;54598:211::-;54659:7;54780:21;:12;:19;:21::i;:::-;54773:28;;54598:211;:::o;56480:305::-;56641:41;56660:12;:10;:12::i;:::-;56674:7;56641:18;:41::i;:::-;56633:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;56749:28;56759:4;56765:2;56769:7;56749:9;:28::i;:::-;56480:305;;;:::o;54360:162::-;54457:7;54484:30;54508:5;54484:13;:20;54498:5;54484:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;54477:37;;54360:162;;;;:::o;69978:89::-;67095:12;:10;:12::i;:::-;67084:23;;:7;:5;:7::i;:::-;:23;;;67076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70047:12:::1;;;;;;;;;;;70046:13;70031:12;;:28;;;;;;;;;;;;;;;;;;69978:89::o:0;68960:50::-;69005:5;68960:50;:::o;69290:131::-;67095:12;:10;:12::i;:::-;67084:23;;:7;:5;:7::i;:::-;:23;;;67076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;69338:12:::1;69353:21;69338:36;;69385:10;:19;;:28;69405:7;69385:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;67155:1;69290:131::o:0;68818:62::-;68863:17;68818:62;:::o;56856:151::-;56960:39;56977:4;56983:2;56987:7;56960:39;;;;;;;;;;;;:16;:39::i;:::-;56856:151;;;:::o;54886:172::-;54961:7;54982:15;55003:22;55019:5;55003:12;:15;;:22;;;;:::i;:::-;54981:44;;;55043:7;55036:14;;;54886:172;;;:::o;69869:99::-;67095:12;:10;:12::i;:::-;67084:23;;:7;:5;:7::i;:::-;:23;;;67076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;69940:20:::1;69952:7;69940:11;:20::i;:::-;69869:99:::0;:::o;52560:177::-;52632:7;52659:70;52676:7;52659:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;52652:77;;52560:177;;;:::o;54179:97::-;54227:13;54260:8;54253:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54179:97;:::o;52277:221::-;52349:7;52394:1;52377:19;;:5;:19;;;;52369:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;52461:29;:13;:20;52475:5;52461:20;;;;;;;;;;;;;;;:27;:29::i;:::-;52454:36;;52277:221;;;:::o;67515:148::-;67095:12;:10;:12::i;:::-;67084:23;;:7;:5;:7::i;:::-;:23;;;67076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67622:1:::1;67585:40;;67606:6;;;;;;;;;;;67585:40;;;;;;;;;;;;67653:1;67636:6;;:19;;;;;;;;;;;;;;;;;;67515:148::o:0;70077:540::-;70138:16;70168:18;70189:17;70199:6;70189:9;:17::i;:::-;70168:38;;70235:1;70221:10;:15;70217:393;;;70312:1;70298:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70291:23;;;;;70217:393;70347:23;70387:10;70373:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70347:51;;70413:13;70441:130;70465:10;70457:5;:18;70441:130;;;70521:34;70541:6;70549:5;70521:19;:34::i;:::-;70505:6;70512:5;70505:13;;;;;;;;;;;;;:50;;;;;70477:7;;;;;;;70441:130;;;70592:6;70585:13;;;;;70077:540;;;;:::o;66864:87::-;66910:7;66937:6;;;;;;;;;;;66930:13;;66864:87;:::o;52973:104::-;53029:13;53062:7;53055:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52973:104;:::o;69429:426::-;67095:12;:10;:12::i;:::-;67084:23;;:7;:5;:7::i;:::-;:23;;;67076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;69525:11:::1;69539:13;:11;:13::i;:::-;69525:27;;69588:1;69571:14;:18;:60;;;;;69611:20;;69593:14;:38;;69571:60;69563:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;69684:6;69679:95;69700:14;69696:1;:18;69679:95;;;69736:26;69746:3;69760:1;69751:6;:10;69736:9;:26::i;:::-;69716:3;;;;;;;69679:95;;;;69807:40;69832:14;69807:20;;:24;;:40;;;;:::i;:::-;69784:20;:63;;;;67155:1;69429:426:::0;;:::o;68669:31::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55883:295::-;55998:12;:10;:12::i;:::-;55986:24;;:8;:24;;;;55978:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;56098:8;56053:18;:32;56072:12;:10;:12::i;:::-;56053:32;;;;;;;;;;;;;;;:42;56086:8;56053:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;56151:8;56122:48;;56137:12;:10;:12::i;:::-;56122:48;;;56161:8;56122:48;;;;;;:::i;:::-;;;;;;;;55883:295;;:::o;71069:174::-;67095:12;:10;:12::i;:::-;67084:23;;:7;:5;:7::i;:::-;:23;;;67076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;71169:5:::1;71152:22;;:13;;;;;;;;;;;:22;;;71144:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;71227:8;71212:12;:23;;;;;;;;;;;;:::i;:::-;;71069:174:::0;:::o;57078:285::-;57210:41;57229:12;:10;:12::i;:::-;57243:7;57210:18;:41::i;:::-;57202:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;57316:39;57330:4;57336:2;57340:7;57349:5;57316:13;:39::i;:::-;57078:285;;;;:::o;70909:125::-;67095:12;:10;:12::i;:::-;67084:23;;:7;:5;:7::i;:::-;:23;;;67076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70977:4:::1;70960:13;;:21;;;;;;;;;;;;;;;;;;70997:29;71013:12;70997:29;;;;;;:::i;:::-;;;;;;;;70909:125::o:0;53148:792::-;53221:13;53255:16;53263:7;53255;:16::i;:::-;53247:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;53336:23;53362:10;:19;53373:7;53362:19;;;;;;;;;;;53336:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53392:18;53413:9;:7;:9::i;:::-;53392:30;;53520:1;53504:4;53498:18;:23;53494:72;;;53545:9;53538:16;;;;;;53494:72;53696:1;53676:9;53670:23;:27;53666:108;;;53745:4;53751:9;53728:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;53714:48;;;;;;53666:108;53906:4;53912:18;:7;:16;:18::i;:::-;53889:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;53875:57;;;;53148:792;;;;:::o;71253:739::-;71335:12;;;;;;;;;;;71327:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;71430:1;71413:14;:18;:64;;;;;68949:2;71435:14;:42;;71413:64;71405:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;69005:5;71534:33;71552:14;71534:13;:11;:13::i;:::-;:17;;:33;;;;:::i;:::-;:55;;71526:119;;;;;;;;;;;;:::i;:::-;;;;;;;;;71677:38;71700:14;68863:17;71677:22;;:38;;;;:::i;:::-;71664:9;:51;;71656:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;71768:6;71764:219;71784:14;71780:1;:18;71764:219;;;71820:14;71837:13;:11;:13::i;:::-;71820:30;;69005:5;71869:13;:11;:13::i;:::-;:34;71865:107;;;71924:32;71934:10;71946:9;71924;:32::i;:::-;71865:107;71764:219;71800:3;;;;;;;71764:219;;;;71253:739;:::o;70664:184::-;70716:13;70756;:11;:13::i;:::-;70750:3;:19;70742:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70828:12;70821:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70664:184;;;:::o;56249:164::-;56346:4;56370:18;:25;56389:5;56370:25;;;;;;;;;;;;;;;:35;56396:8;56370:35;;;;;;;;;;;;;;;;;;;;;;;;;56363:42;;56249:164;;;;:::o;69019:32::-;;;;;;;;;;;;;:::o;67818:244::-;67095:12;:10;:12::i;:::-;67084:23;;:7;:5;:7::i;:::-;:23;;;67076:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;67927:1:::1;67907:22;;:8;:22;;;;67899:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;68017:8;67988:38;;68009:6;;;;;;;;;;;67988:38;;;;;;;;;;;;68046:8;68037:6;;:17;;;;;;;;;;;;;;;;;;67818:244:::0;:::o;58830:127::-;58895:4;58919:30;58941:7;58919:12;:21;;:30;;;;:::i;:::-;58912:37;;58830:127;;;:::o;1960:98::-;2013:7;2040:10;2033:17;;1960:98;:::o;64848:192::-;64950:2;64923:15;:24;64939:7;64923:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;65006:7;65002:2;64968:46;;64977:23;64992:7;64977:14;:23::i;:::-;64968:46;;;;;;;;;;;;64848:192;;:::o;45563:123::-;45632:7;45659:19;45667:3;:10;;45659:7;:19::i;:::-;45652:26;;45563:123;;;:::o;59124:355::-;59217:4;59242:16;59250:7;59242;:16::i;:::-;59234:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;59318:13;59334:23;59349:7;59334:14;:23::i;:::-;59318:39;;59387:5;59376:16;;:7;:16;;;:51;;;;59420:7;59396:31;;:20;59408:7;59396:11;:20::i;:::-;:31;;;59376:51;:94;;;;59431:39;59455:5;59462:7;59431:23;:39::i;:::-;59376:94;59368:103;;;59124:355;;;;:::o;62260:599::-;62385:4;62358:31;;:23;62373:7;62358:14;:23::i;:::-;:31;;;62350:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;62486:1;62472:16;;:2;:16;;;;62464:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;62542:39;62563:4;62569:2;62573:7;62542:20;:39::i;:::-;62646:29;62663:1;62667:7;62646:8;:29::i;:::-;62688:35;62715:7;62688:13;:19;62702:4;62688:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;62734:30;62756:7;62734:13;:17;62748:2;62734:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;62777:29;62794:7;62803:2;62777:12;:16;;:29;;;;;:::i;:::-;;62843:7;62839:2;62824:27;;62833:4;62824:27;;;;;;;;;;;;62260:599;;;:::o;37354:137::-;37425:7;37460:22;37464:3;:10;;37476:5;37460:3;:22::i;:::-;37452:31;;37445:38;;37354:137;;;;:::o;46025:236::-;46105:7;46114;46135:11;46148:13;46165:22;46169:3;:10;;46181:5;46165:3;:22::i;:::-;46134:53;;;;46214:3;46206:12;;46244:5;46236:14;;46198:55;;;;;;46025:236;;;;;:::o;63460:100::-;63544:8;63533;:19;;;;;;;;;;;;:::i;:::-;;63460:100;:::o;47311:213::-;47418:7;47469:44;47474:3;:10;;47494:3;47486:12;;47500;47469:4;:44::i;:::-;47461:53;;47438:78;;47311:213;;;;;:::o;36896:114::-;36956:7;36983:19;36991:3;:10;;36983:7;:19::i;:::-;36976:26;;36896:114;;;:::o;59822:110::-;59898:26;59908:2;59912:7;59898:26;;;;;;;;;;;;:9;:26::i;:::-;59822:110;;:::o;15544:158::-;15602:7;15635:1;15630;:6;;15622:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;15693:1;15689;:5;15682:12;;15544:158;;;;:::o;58245:272::-;58359:28;58369:4;58375:2;58379:7;58359:9;:28::i;:::-;58406:48;58429:4;58435:2;58439:7;58448:5;58406:22;:48::i;:::-;58398:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;58245:272;;;;:::o;47775:746::-;47831:13;48061:1;48052:5;:10;48048:53;;;48079:10;;;;;;;;;;;;;;;;;;;;;48048:53;48111:12;48126:5;48111:20;;48142:14;48167:78;48182:1;48174:4;:9;48167:78;;48200:8;;;;;;;48231:2;48223:10;;;;;;;;;48167:78;;;48255:19;48287:6;48277:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48255:39;;48305:13;48330:1;48321:6;:10;48305:26;;48349:5;48342:12;;48365:117;48380:1;48372:4;:9;48365:117;;48441:2;48434:4;:9;;;;;;48429:2;:14;48416:29;;48398:6;48405:7;;;;;;;48398:15;;;;;;;;;;;:47;;;;;;;;;;;48468:2;48460:10;;;;;;;;;48365:117;;;48506:6;48492:21;;;;;;47775:746;;;;:::o;15082:179::-;15140:7;15160:9;15176:1;15172;:5;15160:17;;15201:1;15196;:6;;15188:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;15252:1;15245:8;;;15082:179;;;;:::o;15961:220::-;16019:7;16048:1;16043;:6;16039:20;;;16058:1;16051:8;;;;16039:20;16070:9;16086:1;16082;:5;16070:17;;16115:1;16110;16106;:5;;;;;;:10;16098:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;16172:1;16165:8;;;15961:220;;;;;:::o;45324:151::-;45408:4;45432:35;45442:3;:10;;45462:3;45454:12;;45432:9;:35::i;:::-;45425:42;;45324:151;;;;:::o;42142:110::-;42198:7;42225:3;:12;;:19;;;;42218:26;;42142:110;;;:::o;65653:93::-;;;;:::o;36441:137::-;36511:4;36535:35;36543:3;:10;;36563:5;36555:14;;36535:7;:35::i;:::-;36528:42;;36441:137;;;;:::o;36134:131::-;36201:4;36225:32;36230:3;:10;;36250:5;36242:14;;36225:4;:32::i;:::-;36218:39;;36134:131;;;;:::o;44747:185::-;44836:4;44860:64;44865:3;:10;;44885:3;44877:12;;44915:5;44899:23;;44891:32;;44860:4;:64::i;:::-;44853:71;;44747:185;;;;;:::o;32392:204::-;32459:7;32508:5;32487:3;:11;;:18;;;;:26;32479:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;32570:3;:11;;32582:5;32570:18;;;;;;;;;;;;;;;;32563:25;;32392:204;;;;:::o;42607:279::-;42674:7;42683;42733:5;42711:3;:12;;:19;;;;:27;42703:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;42790:22;42815:3;:12;;42828:5;42815:19;;;;;;;;;;;;;;;;;;42790:44;;42853:5;:10;;;42865:5;:12;;;42845:33;;;;;42607:279;;;;;:::o;44104:319::-;44198:7;44218:16;44237:3;:12;;:17;44250:3;44237:17;;;;;;;;;;;;44218:36;;44285:1;44273:8;:13;;44288:12;44265:36;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;44355:3;:12;;44379:1;44368:8;:12;44355:26;;;;;;;;;;;;;;;;;;:33;;;44348:40;;;44104:319;;;;;:::o;31939:109::-;31995:7;32022:3;:11;;:18;;;;32015:25;;31939:109;;;:::o;60159:250::-;60255:18;60261:2;60265:7;60255:5;:18::i;:::-;60292:54;60323:1;60327:2;60331:7;60340:5;60292:22;:54::i;:::-;60284:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;60159:250;;;:::o;64125:604::-;64246:4;64273:15;:2;:13;;;:15::i;:::-;64268:60;;64312:4;64305:11;;;;64268:60;64338:23;64364:252;64417:45;;;64477:12;:10;:12::i;:::-;64504:4;64523:7;64545:5;64380:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64364:252;;;;;;;;;;;;;;;;;:2;:15;;;;:252;;;;;:::i;:::-;64338:278;;64627:13;64654:10;64643:32;;;;;;;;;;;;:::i;:::-;64627:48;;49274:10;64704:16;;64694:26;;;:6;:26;;;;64686:35;;;;64125:604;;;;;;;:::o;41922:125::-;41993:4;42038:1;42017:3;:12;;:17;42030:3;42017:17;;;;;;;;;;;;:22;;42010:29;;41922:125;;;;:::o;30094:1544::-;30160:4;30278:18;30299:3;:12;;:19;30312:5;30299:19;;;;;;;;;;;;30278:40;;30349:1;30335:10;:15;30331:1300;;30697:21;30734:1;30721:10;:14;30697:38;;30750:17;30791:1;30770:3;:11;;:18;;;;:22;30750:42;;31037:17;31057:3;:11;;31069:9;31057:22;;;;;;;;;;;;;;;;31037:42;;31203:9;31174:3;:11;;31186:13;31174:26;;;;;;;;;;;;;;;:38;;;;31322:1;31306:13;:17;31280:3;:12;;:23;31293:9;31280:23;;;;;;;;;;;:43;;;;31432:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;31527:3;:12;;:19;31540:5;31527:19;;;;;;;;;;;31520:26;;;31570:4;31563:11;;;;;;;;30331:1300;31614:5;31607:12;;;30094:1544;;;;;:::o;29504:414::-;29567:4;29589:21;29599:3;29604:5;29589:9;:21::i;:::-;29584:327;;29627:3;:11;;29644:5;29627:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29810:3;:11;;:18;;;;29788:3;:12;;:19;29801:5;29788:19;;;;;;;;;;;:40;;;;29850:4;29843:11;;;;29584:327;29894:5;29887:12;;29504:414;;;;;:::o;39422:692::-;39498:4;39614:16;39633:3;:12;;:17;39646:3;39633:17;;;;;;;;;;;;39614:36;;39679:1;39667:8;:13;39663:444;;;39734:3;:12;;39752:38;;;;;;;;39769:3;39752:38;;;;39782:5;39752:38;;;39734:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39949:3;:12;;:19;;;;39929:3;:12;;:17;39942:3;39929:17;;;;;;;;;;;:39;;;;39990:4;39983:11;;;;;39663:444;40063:5;40027:3;:12;;40051:1;40040:8;:12;40027:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;40090:5;40083:12;;;39422:692;;;;;;:::o;60745:404::-;60839:1;60825:16;;:2;:16;;;;60817:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;60898:16;60906:7;60898;:16::i;:::-;60897:17;60889:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;60960:45;60989:1;60993:2;60997:7;60960:20;:45::i;:::-;61018:30;61040:7;61018:13;:17;61032:2;61018:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;61061:29;61078:7;61087:2;61061:12;:16;;:29;;;;;:::i;:::-;;61133:7;61129:2;61108:33;;61125:1;61108:33;;;;;;;;;;;;60745:404;;:::o;20523:422::-;20583:4;20791:12;20902:7;20890:20;20882:28;;20936:1;20929:4;:8;20922:15;;;20523:422;;;:::o;23441:195::-;23544:12;23576:52;23598:6;23606:4;23612:1;23615:12;23576:21;:52::i;:::-;23569:59;;23441:195;;;;;:::o;31724:129::-;31797:4;31844:1;31821:3;:12;;:19;31834:5;31821:19;;;;;;;;;;;;:24;;31814:31;;31724:129;;;;:::o;24493:530::-;24620:12;24678:5;24653:21;:30;;24645:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;24745:18;24756:6;24745:10;:18::i;:::-;24737:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;24871:12;24885:23;24912:6;:11;;24932:5;24940:4;24912:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24870:75;;;;24963:52;24981:7;24990:10;25002:12;24963:17;:52::i;:::-;24956:59;;;;24493:530;;;;;;:::o;27033:742::-;27148:12;27177:7;27173:595;;;27208:10;27201:17;;;;27173:595;27342:1;27322:10;:17;:21;27318:439;;;27585:10;27579:17;27646:15;27633:10;27629:2;27625:19;27618:44;27533:148;27728:12;27721:20;;;;;;;;;;;:::i;:::-;;;;;;;;27033:742;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:342:1:-;;109:64;124:48;165:6;124:48;:::i;:::-;109:64;:::i;:::-;100:73;;196:6;189:5;182:21;234:4;227:5;223:16;272:3;263:6;258:3;254:16;251:25;248:2;;;289:1;286;279:12;248:2;302:41;336:6;331:3;326;302:41;:::i;:::-;90:259;;;;;;:::o;355:344::-;;458:65;473:49;515:6;473:49;:::i;:::-;458:65;:::i;:::-;449:74;;546:6;539:5;532:21;584:4;577:5;573:16;622:3;613:6;608:3;604:16;601:25;598:2;;;639:1;636;629:12;598:2;652:41;686:6;681:3;676;652:41;:::i;:::-;439:260;;;;;;:::o;705:139::-;;789:6;776:20;767:29;;805:33;832:5;805:33;:::i;:::-;757:87;;;;:::o;850:133::-;;931:6;918:20;909:29;;947:30;971:5;947:30;:::i;:::-;899:84;;;;:::o;989:137::-;;1072:6;1059:20;1050:29;;1088:32;1114:5;1088:32;:::i;:::-;1040:86;;;;:::o;1132:141::-;;1219:6;1213:13;1204:22;;1235:32;1261:5;1235:32;:::i;:::-;1194:79;;;;:::o;1292:271::-;;1396:3;1389:4;1381:6;1377:17;1373:27;1363:2;;1414:1;1411;1404:12;1363:2;1454:6;1441:20;1479:78;1553:3;1545:6;1538:4;1530:6;1526:17;1479:78;:::i;:::-;1470:87;;1353:210;;;;;:::o;1583:273::-;;1688:3;1681:4;1673:6;1669:17;1665:27;1655:2;;1706:1;1703;1696:12;1655:2;1746:6;1733:20;1771:79;1846:3;1838:6;1831:4;1823:6;1819:17;1771:79;:::i;:::-;1762:88;;1645:211;;;;;:::o;1862:139::-;;1946:6;1933:20;1924:29;;1962:33;1989:5;1962:33;:::i;:::-;1914:87;;;;:::o;2007:262::-;;2115:2;2103:9;2094:7;2090:23;2086:32;2083:2;;;2131:1;2128;2121:12;2083:2;2174:1;2199:53;2244:7;2235:6;2224:9;2220:22;2199:53;:::i;:::-;2189:63;;2145:117;2073:196;;;;:::o;2275:407::-;;;2400:2;2388:9;2379:7;2375:23;2371:32;2368:2;;;2416:1;2413;2406:12;2368:2;2459:1;2484:53;2529:7;2520:6;2509:9;2505:22;2484:53;:::i;:::-;2474:63;;2430:117;2586:2;2612:53;2657:7;2648:6;2637:9;2633:22;2612:53;:::i;:::-;2602:63;;2557:118;2358:324;;;;;:::o;2688:552::-;;;;2830:2;2818:9;2809:7;2805:23;2801:32;2798:2;;;2846:1;2843;2836:12;2798:2;2889:1;2914:53;2959:7;2950:6;2939:9;2935:22;2914:53;:::i;:::-;2904:63;;2860:117;3016:2;3042:53;3087:7;3078:6;3067:9;3063:22;3042:53;:::i;:::-;3032:63;;2987:118;3144:2;3170:53;3215:7;3206:6;3195:9;3191:22;3170:53;:::i;:::-;3160:63;;3115:118;2788:452;;;;;:::o;3246:809::-;;;;;3414:3;3402:9;3393:7;3389:23;3385:33;3382:2;;;3431:1;3428;3421:12;3382:2;3474:1;3499:53;3544:7;3535:6;3524:9;3520:22;3499:53;:::i;:::-;3489:63;;3445:117;3601:2;3627:53;3672:7;3663:6;3652:9;3648:22;3627:53;:::i;:::-;3617:63;;3572:118;3729:2;3755:53;3800:7;3791:6;3780:9;3776:22;3755:53;:::i;:::-;3745:63;;3700:118;3885:2;3874:9;3870:18;3857:32;3916:18;3908:6;3905:30;3902:2;;;3948:1;3945;3938:12;3902:2;3976:62;4030:7;4021:6;4010:9;4006:22;3976:62;:::i;:::-;3966:72;;3828:220;3372:683;;;;;;;:::o;4061:401::-;;;4183:2;4171:9;4162:7;4158:23;4154:32;4151:2;;;4199:1;4196;4189:12;4151:2;4242:1;4267:53;4312:7;4303:6;4292:9;4288:22;4267:53;:::i;:::-;4257:63;;4213:117;4369:2;4395:50;4437:7;4428:6;4417:9;4413:22;4395:50;:::i;:::-;4385:60;;4340:115;4141:321;;;;;:::o;4468:407::-;;;4593:2;4581:9;4572:7;4568:23;4564:32;4561:2;;;4609:1;4606;4599:12;4561:2;4652:1;4677:53;4722:7;4713:6;4702:9;4698:22;4677:53;:::i;:::-;4667:63;;4623:117;4779:2;4805:53;4850:7;4841:6;4830:9;4826:22;4805:53;:::i;:::-;4795:63;;4750:118;4551:324;;;;;:::o;4881:260::-;;4988:2;4976:9;4967:7;4963:23;4959:32;4956:2;;;5004:1;5001;4994:12;4956:2;5047:1;5072:52;5116:7;5107:6;5096:9;5092:22;5072:52;:::i;:::-;5062:62;;5018:116;4946:195;;;;:::o;5147:282::-;;5265:2;5253:9;5244:7;5240:23;5236:32;5233:2;;;5281:1;5278;5271:12;5233:2;5324:1;5349:63;5404:7;5395:6;5384:9;5380:22;5349:63;:::i;:::-;5339:73;;5295:127;5223:206;;;;:::o;5435:375::-;;5553:2;5541:9;5532:7;5528:23;5524:32;5521:2;;;5569:1;5566;5559:12;5521:2;5640:1;5629:9;5625:17;5612:31;5670:18;5662:6;5659:30;5656:2;;;5702:1;5699;5692:12;5656:2;5730:63;5785:7;5776:6;5765:9;5761:22;5730:63;:::i;:::-;5720:73;;5583:220;5511:299;;;;:::o;5816:262::-;;5924:2;5912:9;5903:7;5899:23;5895:32;5892:2;;;5940:1;5937;5930:12;5892:2;5983:1;6008:53;6053:7;6044:6;6033:9;6029:22;6008:53;:::i;:::-;5998:63;;5954:117;5882:196;;;;:::o;6084:179::-;;6174:46;6216:3;6208:6;6174:46;:::i;:::-;6252:4;6247:3;6243:14;6229:28;;6164:99;;;;:::o;6269:118::-;6356:24;6374:5;6356:24;:::i;:::-;6351:3;6344:37;6334:53;;:::o;6423:732::-;;6571:54;6619:5;6571:54;:::i;:::-;6641:86;6720:6;6715:3;6641:86;:::i;:::-;6634:93;;6751:56;6801:5;6751:56;:::i;:::-;6830:7;6861:1;6846:284;6871:6;6868:1;6865:13;6846:284;;;6947:6;6941:13;6974:63;7033:3;7018:13;6974:63;:::i;:::-;6967:70;;7060:60;7113:6;7060:60;:::i;:::-;7050:70;;6906:224;6893:1;6890;6886:9;6881:14;;6846:284;;;6850:14;7146:3;7139:10;;6547:608;;;;;;;:::o;7161:109::-;7242:21;7257:5;7242:21;:::i;:::-;7237:3;7230:34;7220:50;;:::o;7276:360::-;;7390:38;7422:5;7390:38;:::i;:::-;7444:70;7507:6;7502:3;7444:70;:::i;:::-;7437:77;;7523:52;7568:6;7563:3;7556:4;7549:5;7545:16;7523:52;:::i;:::-;7600:29;7622:6;7600:29;:::i;:::-;7595:3;7591:39;7584:46;;7366:270;;;;;:::o;7642:373::-;;7774:38;7806:5;7774:38;:::i;:::-;7828:88;7909:6;7904:3;7828:88;:::i;:::-;7821:95;;7925:52;7970:6;7965:3;7958:4;7951:5;7947:16;7925:52;:::i;:::-;8002:6;7997:3;7993:16;7986:23;;7750:265;;;;;:::o;8021:364::-;;8137:39;8170:5;8137:39;:::i;:::-;8192:71;8256:6;8251:3;8192:71;:::i;:::-;8185:78;;8272:52;8317:6;8312:3;8305:4;8298:5;8294:16;8272:52;:::i;:::-;8349:29;8371:6;8349:29;:::i;:::-;8344:3;8340:39;8333:46;;8113:272;;;;;:::o;8391:377::-;;8525:39;8558:5;8525:39;:::i;:::-;8580:89;8662:6;8657:3;8580:89;:::i;:::-;8573:96;;8678:52;8723:6;8718:3;8711:4;8704:5;8700:16;8678:52;:::i;:::-;8755:6;8750:3;8746:16;8739:23;;8501:267;;;;;:::o;8798:937::-;;8920:5;8914:12;8957:1;8946:9;8942:17;8973:1;8968:281;;;;9263:1;9258:471;;;;8935:794;;8968:281;9058:4;9054:1;9043:9;9039:17;9035:28;9083:71;9147:6;9142:3;9083:71;:::i;:::-;9076:78;;9198:4;9194:9;9183;9179:25;9174:3;9167:38;9234:4;9229:3;9225:14;9218:21;;8975:274;8968:281;;9258:471;9339:1;9328:9;9324:17;9361:71;9425:6;9420:3;9361:71;:::i;:::-;9354:78;;9460:38;9492:5;9460:38;:::i;:::-;9520:1;9534:154;9548:6;9545:1;9542:13;9534:154;;;9622:7;9616:14;9612:1;9607:3;9603:11;9596:35;9672:1;9663:7;9659:15;9648:26;;9570:4;9567:1;9563:12;9558:17;;9534:154;;;9717:1;9712:3;9708:11;9701:18;;9265:464;;;8935:794;;8887:848;;;;;:::o;9741:366::-;;9904:67;9968:2;9963:3;9904:67;:::i;:::-;9897:74;;10001:34;9997:1;9992:3;9988:11;9981:55;10067:4;10062:2;10057:3;10053:12;10046:26;10098:2;10093:3;10089:12;10082:19;;9887:220;;;:::o;10113:382::-;;10276:67;10340:2;10335:3;10276:67;:::i;:::-;10269:74;;10373:34;10369:1;10364:3;10360:11;10353:55;10439:20;10434:2;10429:3;10425:12;10418:42;10486:2;10481:3;10477:12;10470:19;;10259:236;;;:::o;10501:370::-;;10664:67;10728:2;10723:3;10664:67;:::i;:::-;10657:74;;10761:34;10757:1;10752:3;10748:11;10741:55;10827:8;10822:2;10817:3;10813:12;10806:30;10862:2;10857:3;10853:12;10846:19;;10647:224;;;:::o;10877:326::-;;11040:67;11104:2;11099:3;11040:67;:::i;:::-;11033:74;;11137:30;11133:1;11128:3;11124:11;11117:51;11194:2;11189:3;11185:12;11178:19;;11023:180;;;:::o;11209:325::-;;11372:67;11436:2;11431:3;11372:67;:::i;:::-;11365:74;;11469:29;11465:1;11460:3;11456:11;11449:50;11525:2;11520:3;11516:12;11509:19;;11355:179;;;:::o;11540:330::-;;11703:67;11767:2;11762:3;11703:67;:::i;:::-;11696:74;;11800:34;11796:1;11791:3;11787:11;11780:55;11861:2;11856:3;11852:12;11845:19;;11686:184;;;:::o;11876:368::-;;12039:67;12103:2;12098:3;12039:67;:::i;:::-;12032:74;;12136:34;12132:1;12127:3;12123:11;12116:55;12202:6;12197:2;12192:3;12188:12;12181:28;12235:2;12230:3;12226:12;12219:19;;12022:222;;;:::o;12250:323::-;;12413:67;12477:2;12472:3;12413:67;:::i;:::-;12406:74;;12510:27;12506:1;12501:3;12497:11;12490:48;12564:2;12559:3;12555:12;12548:19;;12396:177;;;:::o;12579:329::-;;12742:67;12806:2;12801:3;12742:67;:::i;:::-;12735:74;;12839:33;12835:1;12830:3;12826:11;12819:54;12899:2;12894:3;12890:12;12883:19;;12725:183;;;:::o;12914:328::-;;13077:67;13141:2;13136:3;13077:67;:::i;:::-;13070:74;;13174:32;13170:1;13165:3;13161:11;13154:53;13233:2;13228:3;13224:12;13217:19;;13060:182;;;:::o;13248:370::-;;13411:67;13475:2;13470:3;13411:67;:::i;:::-;13404:74;;13508:34;13504:1;13499:3;13495:11;13488:55;13574:8;13569:2;13564:3;13560:12;13553:30;13609:2;13604:3;13600:12;13593:19;;13394:224;;;:::o;13624:376::-;;13787:67;13851:2;13846:3;13787:67;:::i;:::-;13780:74;;13884:34;13880:1;13875:3;13871:11;13864:55;13950:14;13945:2;13940:3;13936:12;13929:36;13991:2;13986:3;13982:12;13975:19;;13770:230;;;:::o;14006:365::-;;14169:67;14233:2;14228:3;14169:67;:::i;:::-;14162:74;;14266:34;14262:1;14257:3;14253:11;14246:55;14332:3;14327:2;14322:3;14318:12;14311:25;14362:2;14357:3;14353:12;14346:19;;14152:219;;;:::o;14377:388::-;;14540:67;14604:2;14599:3;14540:67;:::i;:::-;14533:74;;14637:34;14633:1;14628:3;14624:11;14617:55;14703:26;14698:2;14693:3;14689:12;14682:48;14756:2;14751:3;14747:12;14740:19;;14523:242;;;:::o;14771:374::-;;14934:67;14998:2;14993:3;14934:67;:::i;:::-;14927:74;;15031:34;15027:1;15022:3;15018:11;15011:55;15097:12;15092:2;15087:3;15083:12;15076:34;15136:2;15131:3;15127:12;15120:19;;14917:228;;;:::o;15151:366::-;;15314:67;15378:2;15373:3;15314:67;:::i;:::-;15307:74;;15411:34;15407:1;15402:3;15398:11;15391:55;15477:4;15472:2;15467:3;15463:12;15456:26;15508:2;15503:3;15499:12;15492:19;;15297:220;;;:::o;15523:330::-;;15686:67;15750:2;15745:3;15686:67;:::i;:::-;15679:74;;15783:34;15779:1;15774:3;15770:11;15763:55;15844:2;15839:3;15835:12;15828:19;;15669:184;;;:::o;15859:365::-;;16022:67;16086:2;16081:3;16022:67;:::i;:::-;16015:74;;16119:34;16115:1;16110:3;16106:11;16099:55;16185:3;16180:2;16175:3;16171:12;16164:25;16215:2;16210:3;16206:12;16199:19;;16005:219;;;:::o;16230:376::-;;16393:67;16457:2;16452:3;16393:67;:::i;:::-;16386:74;;16490:34;16486:1;16481:3;16477:11;16470:55;16556:14;16551:2;16546:3;16542:12;16535:36;16597:2;16592:3;16588:12;16581:19;;16376:230;;;:::o;16612:330::-;;16775:67;16839:2;16834:3;16775:67;:::i;:::-;16768:74;;16872:34;16868:1;16863:3;16859:11;16852:55;16933:2;16928:3;16924:12;16917:19;;16758:184;;;:::o;16948:373::-;;17111:67;17175:2;17170:3;17111:67;:::i;:::-;17104:74;;17208:34;17204:1;17199:3;17195:11;17188:55;17274:11;17269:2;17264:3;17260:12;17253:33;17312:2;17307:3;17303:12;17296:19;;17094:227;;;:::o;17327:379::-;;17490:67;17554:2;17549:3;17490:67;:::i;:::-;17483:74;;17587:34;17583:1;17578:3;17574:11;17567:55;17653:17;17648:2;17643:3;17639:12;17632:39;17697:2;17692:3;17688:12;17681:19;;17473:233;;;:::o;17712:365::-;;17875:67;17939:2;17934:3;17875:67;:::i;:::-;17868:74;;17972:34;17968:1;17963:3;17959:11;17952:55;18038:3;18033:2;18028:3;18024:12;18017:25;18068:2;18063:3;18059:12;18052:19;;17858:219;;;:::o;18083:383::-;;18246:67;18310:2;18305:3;18246:67;:::i;:::-;18239:74;;18343:34;18339:1;18334:3;18330:11;18323:55;18409:21;18404:2;18399:3;18395:12;18388:43;18457:2;18452:3;18448:12;18441:19;;18229:237;;;:::o;18472:374::-;;18635:67;18699:2;18694:3;18635:67;:::i;:::-;18628:74;;18732:34;18728:1;18723:3;18719:11;18712:55;18798:12;18793:2;18788:3;18784:12;18777:34;18837:2;18832:3;18828:12;18821:19;;18618:228;;;:::o;18852:320::-;;19015:67;19079:2;19074:3;19015:67;:::i;:::-;19008:74;;19112:24;19108:1;19103:3;19099:11;19092:45;19163:2;19158:3;19154:12;19147:19;;18998:174;;;:::o;19178:381::-;;19341:67;19405:2;19400:3;19341:67;:::i;:::-;19334:74;;19438:34;19434:1;19429:3;19425:11;19418:55;19504:19;19499:2;19494:3;19490:12;19483:41;19550:2;19545:3;19541:12;19534:19;;19324:235;;;:::o;19565:327::-;;19728:67;19792:2;19787:3;19728:67;:::i;:::-;19721:74;;19825:31;19821:1;19816:3;19812:11;19805:52;19883:2;19878:3;19874:12;19867:19;;19711:181;;;:::o;19898:368::-;;20061:67;20125:2;20120:3;20061:67;:::i;:::-;20054:74;;20158:34;20154:1;20149:3;20145:11;20138:55;20224:6;20219:2;20214:3;20210:12;20203:28;20257:2;20252:3;20248:12;20241:19;;20044:222;;;:::o;20272:108::-;20349:24;20367:5;20349:24;:::i;:::-;20344:3;20337:37;20327:53;;:::o;20386:118::-;20473:24;20491:5;20473:24;:::i;:::-;20468:3;20461:37;20451:53;;:::o;20510:271::-;;20662:93;20751:3;20742:6;20662:93;:::i;:::-;20655:100;;20772:3;20765:10;;20644:137;;;;:::o;20787:435::-;;20989:95;21080:3;21071:6;20989:95;:::i;:::-;20982:102;;21101:95;21192:3;21183:6;21101:95;:::i;:::-;21094:102;;21213:3;21206:10;;20971:251;;;;;:::o;21228:222::-;;21359:2;21348:9;21344:18;21336:26;;21372:71;21440:1;21429:9;21425:17;21416:6;21372:71;:::i;:::-;21326:124;;;;:::o;21456:640::-;;21689:3;21678:9;21674:19;21666:27;;21703:71;21771:1;21760:9;21756:17;21747:6;21703:71;:::i;:::-;21784:72;21852:2;21841:9;21837:18;21828:6;21784:72;:::i;:::-;21866;21934:2;21923:9;21919:18;21910:6;21866:72;:::i;:::-;21985:9;21979:4;21975:20;21970:2;21959:9;21955:18;21948:48;22013:76;22084:4;22075:6;22013:76;:::i;:::-;22005:84;;21656:440;;;;;;;:::o;22102:373::-;;22283:2;22272:9;22268:18;22260:26;;22332:9;22326:4;22322:20;22318:1;22307:9;22303:17;22296:47;22360:108;22463:4;22454:6;22360:108;:::i;:::-;22352:116;;22250:225;;;;:::o;22481:210::-;;22606:2;22595:9;22591:18;22583:26;;22619:65;22681:1;22670:9;22666:17;22657:6;22619:65;:::i;:::-;22573:118;;;;:::o;22697:313::-;;22848:2;22837:9;22833:18;22825:26;;22897:9;22891:4;22887:20;22883:1;22872:9;22868:17;22861:47;22925:78;22998:4;22989:6;22925:78;:::i;:::-;22917:86;;22815:195;;;;:::o;23016:307::-;;23164:2;23153:9;23149:18;23141:26;;23213:9;23207:4;23203:20;23199:1;23188:9;23184:17;23177:47;23241:75;23311:4;23302:6;23241:75;:::i;:::-;23233:83;;23131:192;;;;:::o;23329:419::-;;23533:2;23522:9;23518:18;23510:26;;23582:9;23576:4;23572:20;23568:1;23557:9;23553:17;23546:47;23610:131;23736:4;23610:131;:::i;:::-;23602:139;;23500:248;;;:::o;23754:419::-;;23958:2;23947:9;23943:18;23935:26;;24007:9;24001:4;23997:20;23993:1;23982:9;23978:17;23971:47;24035:131;24161:4;24035:131;:::i;:::-;24027:139;;23925:248;;;:::o;24179:419::-;;24383:2;24372:9;24368:18;24360:26;;24432:9;24426:4;24422:20;24418:1;24407:9;24403:17;24396:47;24460:131;24586:4;24460:131;:::i;:::-;24452:139;;24350:248;;;:::o;24604:419::-;;24808:2;24797:9;24793:18;24785:26;;24857:9;24851:4;24847:20;24843:1;24832:9;24828:17;24821:47;24885:131;25011:4;24885:131;:::i;:::-;24877:139;;24775:248;;;:::o;25029:419::-;;25233:2;25222:9;25218:18;25210:26;;25282:9;25276:4;25272:20;25268:1;25257:9;25253:17;25246:47;25310:131;25436:4;25310:131;:::i;:::-;25302:139;;25200:248;;;:::o;25454:419::-;;25658:2;25647:9;25643:18;25635:26;;25707:9;25701:4;25697:20;25693:1;25682:9;25678:17;25671:47;25735:131;25861:4;25735:131;:::i;:::-;25727:139;;25625:248;;;:::o;25879:419::-;;26083:2;26072:9;26068:18;26060:26;;26132:9;26126:4;26122:20;26118:1;26107:9;26103:17;26096:47;26160:131;26286:4;26160:131;:::i;:::-;26152:139;;26050:248;;;:::o;26304:419::-;;26508:2;26497:9;26493:18;26485:26;;26557:9;26551:4;26547:20;26543:1;26532:9;26528:17;26521:47;26585:131;26711:4;26585:131;:::i;:::-;26577:139;;26475:248;;;:::o;26729:419::-;;26933:2;26922:9;26918:18;26910:26;;26982:9;26976:4;26972:20;26968:1;26957:9;26953:17;26946:47;27010:131;27136:4;27010:131;:::i;:::-;27002:139;;26900:248;;;:::o;27154:419::-;;27358:2;27347:9;27343:18;27335:26;;27407:9;27401:4;27397:20;27393:1;27382:9;27378:17;27371:47;27435:131;27561:4;27435:131;:::i;:::-;27427:139;;27325:248;;;:::o;27579:419::-;;27783:2;27772:9;27768:18;27760:26;;27832:9;27826:4;27822:20;27818:1;27807:9;27803:17;27796:47;27860:131;27986:4;27860:131;:::i;:::-;27852:139;;27750:248;;;:::o;28004:419::-;;28208:2;28197:9;28193:18;28185:26;;28257:9;28251:4;28247:20;28243:1;28232:9;28228:17;28221:47;28285:131;28411:4;28285:131;:::i;:::-;28277:139;;28175:248;;;:::o;28429:419::-;;28633:2;28622:9;28618:18;28610:26;;28682:9;28676:4;28672:20;28668:1;28657:9;28653:17;28646:47;28710:131;28836:4;28710:131;:::i;:::-;28702:139;;28600:248;;;:::o;28854:419::-;;29058:2;29047:9;29043:18;29035:26;;29107:9;29101:4;29097:20;29093:1;29082:9;29078:17;29071:47;29135:131;29261:4;29135:131;:::i;:::-;29127:139;;29025:248;;;:::o;29279:419::-;;29483:2;29472:9;29468:18;29460:26;;29532:9;29526:4;29522:20;29518:1;29507:9;29503:17;29496:47;29560:131;29686:4;29560:131;:::i;:::-;29552:139;;29450:248;;;:::o;29704:419::-;;29908:2;29897:9;29893:18;29885:26;;29957:9;29951:4;29947:20;29943:1;29932:9;29928:17;29921:47;29985:131;30111:4;29985:131;:::i;:::-;29977:139;;29875:248;;;:::o;30129:419::-;;30333:2;30322:9;30318:18;30310:26;;30382:9;30376:4;30372:20;30368:1;30357:9;30353:17;30346:47;30410:131;30536:4;30410:131;:::i;:::-;30402:139;;30300:248;;;:::o;30554:419::-;;30758:2;30747:9;30743:18;30735:26;;30807:9;30801:4;30797:20;30793:1;30782:9;30778:17;30771:47;30835:131;30961:4;30835:131;:::i;:::-;30827:139;;30725:248;;;:::o;30979:419::-;;31183:2;31172:9;31168:18;31160:26;;31232:9;31226:4;31222:20;31218:1;31207:9;31203:17;31196:47;31260:131;31386:4;31260:131;:::i;:::-;31252:139;;31150:248;;;:::o;31404:419::-;;31608:2;31597:9;31593:18;31585:26;;31657:9;31651:4;31647:20;31643:1;31632:9;31628:17;31621:47;31685:131;31811:4;31685:131;:::i;:::-;31677:139;;31575:248;;;:::o;31829:419::-;;32033:2;32022:9;32018:18;32010:26;;32082:9;32076:4;32072:20;32068:1;32057:9;32053:17;32046:47;32110:131;32236:4;32110:131;:::i;:::-;32102:139;;32000:248;;;:::o;32254:419::-;;32458:2;32447:9;32443:18;32435:26;;32507:9;32501:4;32497:20;32493:1;32482:9;32478:17;32471:47;32535:131;32661:4;32535:131;:::i;:::-;32527:139;;32425:248;;;:::o;32679:419::-;;32883:2;32872:9;32868:18;32860:26;;32932:9;32926:4;32922:20;32918:1;32907:9;32903:17;32896:47;32960:131;33086:4;32960:131;:::i;:::-;32952:139;;32850:248;;;:::o;33104:419::-;;33308:2;33297:9;33293:18;33285:26;;33357:9;33351:4;33347:20;33343:1;33332:9;33328:17;33321:47;33385:131;33511:4;33385:131;:::i;:::-;33377:139;;33275:248;;;:::o;33529:419::-;;33733:2;33722:9;33718:18;33710:26;;33782:9;33776:4;33772:20;33768:1;33757:9;33753:17;33746:47;33810:131;33936:4;33810:131;:::i;:::-;33802:139;;33700:248;;;:::o;33954:419::-;;34158:2;34147:9;34143:18;34135:26;;34207:9;34201:4;34197:20;34193:1;34182:9;34178:17;34171:47;34235:131;34361:4;34235:131;:::i;:::-;34227:139;;34125:248;;;:::o;34379:419::-;;34583:2;34572:9;34568:18;34560:26;;34632:9;34626:4;34622:20;34618:1;34607:9;34603:17;34596:47;34660:131;34786:4;34660:131;:::i;:::-;34652:139;;34550:248;;;:::o;34804:419::-;;35008:2;34997:9;34993:18;34985:26;;35057:9;35051:4;35047:20;35043:1;35032:9;35028:17;35021:47;35085:131;35211:4;35085:131;:::i;:::-;35077:139;;34975:248;;;:::o;35229:419::-;;35433:2;35422:9;35418:18;35410:26;;35482:9;35476:4;35472:20;35468:1;35457:9;35453:17;35446:47;35510:131;35636:4;35510:131;:::i;:::-;35502:139;;35400:248;;;:::o;35654:222::-;;35785:2;35774:9;35770:18;35762:26;;35798:71;35866:1;35855:9;35851:17;35842:6;35798:71;:::i;:::-;35752:124;;;;:::o;35882:278::-;;35948:2;35942:9;35932:19;;35990:4;35982:6;35978:17;36097:6;36085:10;36082:22;36061:18;36049:10;36046:34;36043:62;36040:2;;;36108:13;;:::i;:::-;36040:2;36143:10;36139:2;36132:22;35922:238;;;;:::o;36166:326::-;;36317:18;36309:6;36306:30;36303:2;;;36339:13;;:::i;:::-;36303:2;36419:4;36415:9;36408:4;36400:6;36396:17;36392:33;36384:41;;36480:4;36474;36470:15;36462:23;;36232:260;;;:::o;36498:327::-;;36650:18;36642:6;36639:30;36636:2;;;36672:13;;:::i;:::-;36636:2;36752:4;36748:9;36741:4;36733:6;36729:17;36725:33;36717:41;;36813:4;36807;36803:15;36795:23;;36565:260;;;:::o;36831:132::-;;36921:3;36913:11;;36951:4;36946:3;36942:14;36934:22;;36903:60;;;:::o;36969:141::-;;37041:3;37033:11;;37064:3;37061:1;37054:14;37098:4;37095:1;37085:18;37077:26;;37023:87;;;:::o;37116:114::-;;37217:5;37211:12;37201:22;;37190:40;;;:::o;37236:98::-;;37321:5;37315:12;37305:22;;37294:40;;;:::o;37340:99::-;;37426:5;37420:12;37410:22;;37399:40;;;:::o;37445:113::-;;37547:4;37542:3;37538:14;37530:22;;37520:38;;;:::o;37564:184::-;;37697:6;37692:3;37685:19;37737:4;37732:3;37728:14;37713:29;;37675:73;;;;:::o;37754:168::-;;37871:6;37866:3;37859:19;37911:4;37906:3;37902:14;37887:29;;37849:73;;;;:::o;37928:147::-;;38066:3;38051:18;;38041:34;;;;:::o;38081:169::-;;38199:6;38194:3;38187:19;38239:4;38234:3;38230:14;38215:29;;38177:73;;;;:::o;38256:148::-;;38395:3;38380:18;;38370:34;;;;:::o;38410:96::-;;38476:24;38494:5;38476:24;:::i;:::-;38465:35;;38455:51;;;:::o;38512:90::-;;38589:5;38582:13;38575:21;38564:32;;38554:48;;;:::o;38608:149::-;;38684:66;38677:5;38673:78;38662:89;;38652:105;;;:::o;38763:126::-;;38840:42;38833:5;38829:54;38818:65;;38808:81;;;:::o;38895:77::-;;38961:5;38950:16;;38940:32;;;:::o;38978:154::-;39062:6;39057:3;39052;39039:30;39124:1;39115:6;39110:3;39106:16;39099:27;39029:103;;;:::o;39138:307::-;39206:1;39216:113;39230:6;39227:1;39224:13;39216:113;;;39315:1;39310:3;39306:11;39300:18;39296:1;39291:3;39287:11;39280:39;39252:2;39249:1;39245:10;39240:15;;39216:113;;;39347:6;39344:1;39341:13;39338:2;;;39427:1;39418:6;39413:3;39409:16;39402:27;39338:2;39187:258;;;;:::o;39451:48::-;39484:9;39505:102;;39597:2;39593:7;39588:2;39581:5;39577:14;39573:28;39563:38;;39553:54;;;:::o;39613:122::-;39686:24;39704:5;39686:24;:::i;:::-;39679:5;39676:35;39666:2;;39725:1;39722;39715:12;39666:2;39656:79;:::o;39741:116::-;39811:21;39826:5;39811:21;:::i;:::-;39804:5;39801:32;39791:2;;39847:1;39844;39837:12;39791:2;39781:76;:::o;39863:120::-;39935:23;39952:5;39935:23;:::i;:::-;39928:5;39925:34;39915:2;;39973:1;39970;39963:12;39915:2;39905:78;:::o;39989:122::-;40062:24;40080:5;40062:24;:::i;:::-;40055:5;40052:35;40042:2;;40101:1;40098;40091:12;40042:2;40032:79;:::o

ipfs://919250bd1b1af0cb21219d7bc63d6b1ee10b7488ff71694f1379d28af2dc6fcc