Contract 0xf7b6c94837d9fa6162eda75f0909b21ee54534bb 9

/**
 *Submitted for verification at snowtrace.io on 2022-03-21
*/

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

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

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

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

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

interface IERC721Mintable is IERC721 {
    /**
     * @dev Creates a new token for the given `owner`.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     *
     */
    function mint(address _to) external;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

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

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

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

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not 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 {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: 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 _owners[tokenId] != address(0);
    }

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

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

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

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

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

        _balances[to] += 1;
        _owners[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);

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

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

        _balances[owner] -= 1;
        delete _owners[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");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

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

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

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

    /**
     * @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` and `to` are never both zero.
     *
     * 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 {}
}

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

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

    bool private _paused;

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

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

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

/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be irreversibly burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721Burnable: caller is not owner nor approved");
        _burn(tokenId);
    }
}


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

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

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

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

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

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

        _;

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

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

        return c;
    }

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

        uint256 c = a * b;
        require(c / a == b, errorMessage);

        return c;
    }

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

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

        return c;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @dev HeroesChained Project base NFT class.
 */
 contract HC_NFT_Base is Ownable {    

    uint public constant MAX_SUPPLY = 10000;
    uint private totalAllowedNFTCount;

    mapping(address => uint) private addressIndices;
    Info[] private allowedAddresses;

    struct Info {
        address allowedAddress;
        uint initialBalance;
        uint remainingBalance;
    }

    modifier onlyAllowedAddresses() {
        require(allowedAddresses.length > 0, "Address is not allowed to mint NFTs.");
        uint256 _index = addressIndices[ msg.sender ];
        require( msg.sender == allowedAddresses[ _index ].allowedAddress, "Address is not allowed to mint NFTs." );
        _;
    }

    function addAllowedAddress(address _address, uint _allowedNFTCount) external onlyOwner {
        require( _address != address(0), "Address cannot be empty." );        
        require( _allowedNFTCount > 0, "NFT count must be greater than 0." );

        uint256 index = addressIndices[ _address ];
        if (allowedAddresses.length > 0) {
            if (index > 0)
            {
                require(false, "Address already exists."); //Force throw exception
            }
            else
            {
                require(_address != allowedAddresses[0].allowedAddress, "Address already exists.");
            }
        }
        require( _allowedNFTCount + totalAllowedNFTCount <= MAX_SUPPLY, "Total NFT count cannot exceed MAX_SUPPLY." );

        allowedAddresses.push( Info({
                    allowedAddress: _address,
                    initialBalance: _allowedNFTCount,
                    remainingBalance: _allowedNFTCount
        }));

        addressIndices[_address] = allowedAddresses.length - 1;
        totalAllowedNFTCount = totalAllowedNFTCount + _allowedNFTCount;
    }

    function removeAllowedAddress(address _address) external onlyOwner {
        require(_address != address(0), "Address cannot be empty." );        
        require(allowedAddresses.length > 0, "Address not found.");

        uint256 _index = addressIndices[ _address ];
        require( _address == allowedAddresses[ _index ].allowedAddress, "Address to be removed not found in list." );

        totalAllowedNFTCount = totalAllowedNFTCount - (allowedAddresses[ _index ].remainingBalance);

        allowedAddresses[ _index ].allowedAddress = address(0);
        allowedAddresses[ _index ].initialBalance = 0;
        allowedAddresses[ _index ].remainingBalance = 0;

        delete addressIndices[_address];
    }

    function getMintableNFTBalance(address _address) public view returns (uint) {
        require(_address != address(0), "Address cannot be empty." );        
        require(allowedAddresses.length > 0, "Address not found.");

        uint256 _index = addressIndices[ _address ];
        require( _address == allowedAddresses[ _index ].allowedAddress, "Address is not allowed to mint NFTs." );

        return (allowedAddresses[ _index ].remainingBalance);
    } 

    function decreaseNFTAllowance() internal {
        uint256 _index = addressIndices[ msg.sender ];
        allowedAddresses[ _index ].remainingBalance = (allowedAddresses[ _index ].remainingBalance) - 1;
    }

    function getAllowedAddress(uint256 _index) view external onlyOwner returns(Info memory) {
        return allowedAddresses[_index];
    }
}

/**
 * @dev HeroesChained Project ERC721 token for special MayinHara heroes.
 */
contract HC_MayinHara_NFT is IERC721Mintable, ERC721, Pausable, Ownable, HC_NFT_Base, ReentrancyGuard {  
    using Counters for Counters.Counter;
    
    Counters.Counter private _tokenIdCounter;
    string private _baseTokenURI;

    constructor(
        string memory name,
        string memory symbol,
        string memory baseTokenURI
    ) ERC721(name, symbol) {
        _baseTokenURI = baseTokenURI;
    }

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

    function setBaseURI(string memory baseTokenURI) external onlyOwner {
        _baseTokenURI = baseTokenURI;
    }

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        return string( abi.encodePacked(super.tokenURI(tokenId),".json") );
    }

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

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

    function renounceOwnership() public view override onlyOwner {
        revert ("Renouncing ownership is prevented.");
    }

    function mint(address to) public override nonReentrant whenNotPaused onlyAllowedAddresses {
        require (getMintableNFTBalance(msg.sender) > 0, "No more NFT allowance for minting.");
        require (_tokenIdCounter.current() < MAX_SUPPLY, "MAX_SUPPLY reached. Cannot mint new NFT.");

        _tokenIdCounter.increment();

        uint256 tokenId = _tokenIdCounter.current();

        decreaseNFTAllowance();

        _safeMint(to, tokenId);
    }

    function totalSupply() public view returns (uint256) {
        return _tokenIdCounter.current();
    }

    function totalRemainingSupply() public view returns (uint256) {
        return MAX_SUPPLY - totalSupply();
    }

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

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"baseTokenURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"uint256","name":"_allowedNFTCount","type":"uint256"}],"name":"addAllowedAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"getAllowedAddress","outputs":[{"components":[{"internalType":"address","name":"allowedAddress","type":"address"},{"internalType":"uint256","name":"initialBalance","type":"uint256"},{"internalType":"uint256","name":"remainingBalance","type":"uint256"}],"internalType":"struct HC_NFT_Base.Info","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"getMintableNFTBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeAllowedAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseTokenURI","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":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRemainingSupply","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":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000c4843204d6179696e486172610000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000448434d4800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003068747470733a2f2f6d6179696e686172612e73332e65752d63656e7472616c2d312e616d617a6f6e6177732e636f6d2f00000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): HC MayinHara
Arg [1] : symbol (string): HCMH
Arg [2] : baseTokenURI (string): https://mayinhara.s3.eu-central-1.amazonaws.com/

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [3] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [4] : 4843204d6179696e486172610000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [6] : 48434d4800000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000030
Arg [8] : 68747470733a2f2f6d6179696e686172612e73332e65752d63656e7472616c2d
Arg [9] : 312e616d617a6f6e6177732e636f6d2f00000000000000000000000000000000

58137:2011:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20091:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21036:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22595:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59854:114;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22118:411;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59742:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23345:339;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54716:39;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56477:727;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59066:65;;;:::i;:::-;;23755:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58694:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;33514:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20730:239;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59271:463;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;20460:208;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59139:124;;;:::i;:::-;;57212:468;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58997:61;;;:::i;:::-;;35619:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21205:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55341:1128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;22888:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57908:138;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;24011:328;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58816:173;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23114:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36528:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;20091:305;20193:4;20245:25;20230:40;;;:11;:40;;;;:105;;;;20302:33;20287:48;;;:11;:48;;;;20230:105;:158;;;;20352:36;20376:11;20352:23;:36::i;:::-;20230:158;20210:178;;20091:305;;;:::o;21036:100::-;21090:13;21123:5;21116:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21036:100;:::o;22595:221::-;22671:7;22699:16;22707:7;22699;:16::i;:::-;22691:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;22784:15;:24;22800:7;22784:24;;;;;;;;;;;;;;;;;;;;;22777:31;;22595:221;;;:::o;59854:114::-;59907:7;59947:13;:11;:13::i;:::-;54750:5;59934:26;;;;:::i;:::-;59927:33;;59854:114;:::o;22118:411::-;22199:13;22215:23;22230:7;22215:14;:23::i;:::-;22199:39;;22263:5;22257:11;;:2;:11;;;;22249:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;22357:5;22341:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;22366:37;22383:5;22390:12;:10;:12::i;:::-;22366:16;:37::i;:::-;22341:62;22319:168;;;;;;;;;;;;:::i;:::-;;;;;;;;;22500:21;22509:2;22513:7;22500:8;:21::i;:::-;22118:411;;;:::o;59742:104::-;59786:7;59813:25;:15;:23;:25::i;:::-;59806:32;;59742:104;:::o;23345:339::-;23540:41;23559:12;:10;:12::i;:::-;23573:7;23540:18;:41::i;:::-;23532:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;23648:28;23658:4;23664:2;23668:7;23648:9;:28::i;:::-;23345:339;;;:::o;54716:39::-;54750:5;54716:39;:::o;56477:727::-;35850:12;:10;:12::i;:::-;35839:23;;:7;:5;:7::i;:::-;:23;;;35831:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;56583:1:::1;56563:22;;:8;:22;;;;56555:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;56668:1;56642:16;:23;;;;:27;56634:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;56705:14;56722;:26;56738:8;56722:26;;;;;;;;;;;;;;;;56705:43;;56780:16;56798:6;56780:26;;;;;;;;;;;;;;;;;;;;;;;;;;:41;;;;;;;;;;;;56768:53;;:8;:53;;;56759:108;;;;;;;;;;;;:::i;:::-;;;;;;;;;56927:16;56945:6;56927:26;;;;;;;;;;;;;;;;;;;;;;;;;;:43;;;56903:20;;:68;;;;:::i;:::-;56880:20;:91;;;;57036:1;56984:16;57002:6;56984:26;;;;;;;;;;;;;;;;;;;;;;;;;;:41;;;:54;;;;;;;;;;;;;;;;;;57093:1;57049:16;57067:6;57049:26;;;;;;;;;;;;;;;;;;;;;;;;;;:41;;:45;;;;57151:1;57105:16;57123:6;57105:26;;;;;;;;;;;;;;;;;;;;;;;;;;:43;;:47;;;;57172:14;:24;57187:8;57172:24;;;;;;;;;;;;;;;57165:31;;;35910:1;56477:727:::0;:::o;59066:65::-;35850:12;:10;:12::i;:::-;35839:23;;:7;:5;:7::i;:::-;:23;;;35831:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59113:10:::1;:8;:10::i;:::-;59066:65::o:0;23755:185::-;23893:39;23910:4;23916:2;23920:7;23893:39;;;;;;;;;;;;:16;:39::i;:::-;23755:185;;;:::o;58694:114::-;35850:12;:10;:12::i;:::-;35839:23;;:7;:5;:7::i;:::-;:23;;;35831:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;58788:12:::1;58772:13;:28;;;;;;;;;;;;:::i;:::-;;58694:114:::0;:::o;33514:86::-;33561:4;33585:7;;;;;;;;;;;33578:14;;33514:86;:::o;20730:239::-;20802:7;20822:13;20838:7;:16;20846:7;20838:16;;;;;;;;;;;;;;;;;;;;;20822:32;;20890:1;20873:19;;:5;:19;;;;20865:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;20956:5;20949:12;;;20730:239;;;:::o;59271:463::-;40659:1;41257:7;;:19;;41249:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;40659:1;41390:7;:18;;;;33840:8:::1;:6;:8::i;:::-;33839:9;33831:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;55098:1:::2;55072:16;:23;;;;:27;55064:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;55151:14;55168;:28;55184:10;55168:28;;;;;;;;;;;;;;;;55151:45;;55230:16;55248:6;55230:26;;;;;;;;;;;;;;;;;;;;;;;;;;:41;;;;;;;;;;;;55216:55;;:10;:55;;;55207:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;59417:1:::3;59381:33;59403:10;59381:21;:33::i;:::-;:37;59372:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;54750:5;59477:25;:15;:23;:25::i;:::-;:38;59468:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;59573:27;:15;:25;:27::i;:::-;59613:15;59631:25;:15;:23;:25::i;:::-;59613:43;;59669:22;:20;:22::i;:::-;59704;59714:2;59718:7;59704:9;:22::i;:::-;55324:1;33880::::2;40615::::0;41569:7;:22;;;;59271:463;:::o;20460:208::-;20532:7;20577:1;20560:19;;:5;:19;;;;20552:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;20644:9;:16;20654:5;20644:16;;;;;;;;;;;;;;;;20637:23;;20460:208;;;:::o;59139:124::-;35850:12;:10;:12::i;:::-;35839:23;;:7;:5;:7::i;:::-;:23;;;35831:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59210:45:::1;;;;;;;;;;:::i;:::-;;;;;;;;57212:468:::0;57282:4;57327:1;57307:22;;:8;:22;;;;57299:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;57412:1;57386:16;:23;;;;:27;57378:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;57449:14;57466;:26;57482:8;57466:26;;;;;;;;;;;;;;;;57449:43;;57524:16;57542:6;57524:26;;;;;;;;;;;;;;;;;;;;;;;;;;:41;;;;;;;;;;;;57512:53;;:8;:53;;;57503:104;;;;;;;;;;;;:::i;:::-;;;;;;;;;57628:16;57646:6;57628:26;;;;;;;;;;;;;;;;;;;;;;;;;;:43;;;57620:52;;;57212:468;;;:::o;58997:61::-;35850:12;:10;:12::i;:::-;35839:23;;:7;:5;:7::i;:::-;:23;;;35831:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59042:8:::1;:6;:8::i;:::-;58997:61::o:0;35619:87::-;35665:7;35692:6;;;;;;;;;;;35685:13;;35619:87;:::o;21205:104::-;21261:13;21294:7;21287:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21205:104;:::o;55341:1128::-;35850:12;:10;:12::i;:::-;35839:23;;:7;:5;:7::i;:::-;:23;;;35831:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;55468:1:::1;55448:22;;:8;:22;;;;55439:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;55547:1;55528:16;:20;55519:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;55600:13;55616:14;:26;55632:8;55616:26;;;;;;;;;;;;;;;;55600:42;;55683:1;55657:16;:23;;;;:27;55653:336;;;55713:1;55705:5;:9;55701:277;;;55756:5;55748:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;55701:277;;;55900:16;55917:1;55900:19;;;;;;;;;;;;;;;;;;;;;;;;;;:34;;;;;;;;;;;;55888:46;;:8;:46;;;;55880:82;;;;;;;;;;;;:::i;:::-;;;;;;;;;55701:277;55653:336;54750:5;56027:20;;56008:16;:39;;;;:::i;:::-;:53;;55999:109;;;;;;;;;;;;:::i;:::-;;;;;;;;;56121:16;56144:176;;;;;;;;56188:8;56144:176;;;;;;56235:16;56144:176;;;;56292:16;56144:176;;::::0;56121:200:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56387:1;56361:16;:23;;;;:27;;;;:::i;:::-;56334:14;:24;56349:8;56334:24;;;;;;;;;;;;;;;:54;;;;56445:16;56422:20;;:39;;;;:::i;:::-;56399:20;:62;;;;35910:1;55341:1128:::0;;:::o;22888:155::-;22983:52;23002:12;:10;:12::i;:::-;23016:8;23026;22983:18;:52::i;:::-;22888:155;;:::o;57908:138::-;57983:11;;:::i;:::-;35850:12;:10;:12::i;:::-;35839:23;;:7;:5;:7::i;:::-;:23;;;35831:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;58014:16:::1;58031:6;58014:24;;;;;;;;;;;;;;;;;;;;;;;;;;58007:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;57908:138:::0;;;:::o;24011:328::-;24186:41;24205:12;:10;:12::i;:::-;24219:7;24186:18;:41::i;:::-;24178:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;24292:39;24306:4;24312:2;24316:7;24325:5;24292:13;:39::i;:::-;24011:328;;;;:::o;58816:173::-;58889:13;58947:23;58962:7;58947:14;:23::i;:::-;58930:49;;;;;;;;:::i;:::-;;;;;;;;;;;;;58915:66;;58816:173;;;:::o;23114:164::-;23211:4;23235:18;:25;23254:5;23235:25;;;;;;;;;;;;;;;:35;23261:8;23235:35;;;;;;;;;;;;;;;;;;;;;;;;;23228:42;;23114:164;;;;:::o;36528:201::-;35850:12;:10;:12::i;:::-;35839:23;;:7;:5;:7::i;:::-;:23;;;35831:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;36637:1:::1;36617:22;;:8;:22;;;;36609:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;36693:28;36712:8;36693:18;:28::i;:::-;36528:201:::0;:::o;18700:157::-;18785:4;18824:25;18809:40;;;:11;:40;;;;18802:47;;18700:157;;;:::o;25849:127::-;25914:4;25966:1;25938:30;;:7;:16;25946:7;25938:16;;;;;;;;;;;;;;;;;;;;;:30;;;;25931:37;;25849:127;;;:::o;599:98::-;652:7;679:10;672:17;;599:98;:::o;29831:174::-;29933:2;29906:15;:24;29922:7;29906:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;29989:7;29985:2;29951:46;;29960:23;29975:7;29960:14;:23::i;:::-;29951:46;;;;;;;;;;;;29831:174;;:::o;38415:114::-;38480:7;38507;:14;;;38500:21;;38415:114;;;:::o;26143:348::-;26236:4;26261:16;26269:7;26261;:16::i;:::-;26253:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;26337:13;26353:23;26368:7;26353:14;:23::i;:::-;26337:39;;26406:5;26395:16;;:7;:16;;;:51;;;;26439:7;26415:31;;:20;26427:7;26415:11;:20::i;:::-;:31;;;26395:51;:87;;;;26450:32;26467:5;26474:7;26450:16;:32::i;:::-;26395:87;26387:96;;;26143:348;;;;:::o;29135:578::-;29294:4;29267:31;;:23;29282:7;29267:14;:23::i;:::-;:31;;;29259:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;29377:1;29363:16;;:2;:16;;;;29355:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;29433:39;29454:4;29460:2;29464:7;29433:20;:39::i;:::-;29537:29;29554:1;29558:7;29537:8;:29::i;:::-;29598:1;29579:9;:15;29589:4;29579:15;;;;;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;;;;;;29627:1;29610:9;:13;29620:2;29610:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;29658:2;29639:7;:16;29647:7;29639:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;29697:7;29693:2;29678:27;;29687:4;29678:27;;;;;;;;;;;;29135:578;;;:::o;34573:120::-;34117:8;:6;:8::i;:::-;34109:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;34642:5:::1;34632:7;;:15;;;;;;;;;;;;;;;;;;34663:22;34672:12;:10;:12::i;:::-;34663:22;;;;;;:::i;:::-;;;;;;;;34573:120::o:0;38537:127::-;38644:1;38626:7;:14;;;:19;;;;;;;;;;;38537:127;:::o;57689:211::-;57741:14;57758;:28;57774:10;57758:28;;;;;;;;;;;;;;;;57741:45;;57891:1;57844:16;57862:6;57844:26;;;;;;;;;;;;;;;;;;;;;;;;;;:43;;;57843:49;;;;:::i;:::-;57797:16;57815:6;57797:26;;;;;;;;;;;;;;;;;;;;;;;;;;:43;;:95;;;;57689:211;:::o;26833:110::-;26909:26;26919:2;26923:7;26909:26;;;;;;;;;;;;:9;:26::i;:::-;26833:110;;:::o;34314:118::-;33840:8;:6;:8::i;:::-;33839:9;33831:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;34384:4:::1;34374:7;;:14;;;;;;;;;;;;;;;;;;34404:20;34411:12;:10;:12::i;:::-;34404:20;;;;;;:::i;:::-;;;;;;;;34314:118::o:0;30147:315::-;30302:8;30293:17;;:5;:17;;;;30285:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;30389:8;30351:18;:25;30370:5;30351:25;;;;;;;;;;;;;;;:35;30377:8;30351:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;30435:8;30413:41;;30428:5;30413:41;;;30445:8;30413:41;;;;;;:::i;:::-;;;;;;;;30147:315;;;:::o;25221:::-;25378:28;25388:4;25394:2;25398:7;25378:9;:28::i;:::-;25425:48;25448:4;25454:2;25458:7;25467:5;25425:22;:48::i;:::-;25417:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;25221:315;;;;:::o;21380:334::-;21453:13;21487:16;21495:7;21487;:16::i;:::-;21479:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;21568:21;21592:10;:8;:10::i;:::-;21568:34;;21644:1;21626:7;21620:21;:25;:86;;;;;;;;;;;;;;;;;21672:7;21681:18;:7;:16;:18::i;:::-;21655:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;21620:86;21613:93;;;21380:334;;;:::o;36889:191::-;36963:16;36982:6;;;;;;;;;;;36963:25;;37008:8;36999:6;;:17;;;;;;;;;;;;;;;;;;37063:8;37032:40;;37053:8;37032:40;;;;;;;;;;;;36889:191;;:::o;59976:169::-;33840:8;:6;:8::i;:::-;33839:9;33831:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;60092:45:::1;60119:4;60125:2;60129:7;60092:26;:45::i;:::-;59976:169:::0;;;:::o;27170:321::-;27300:18;27306:2;27310:7;27300:5;:18::i;:::-;27351:54;27382:1;27386:2;27390:7;27399:5;27351:22;:54::i;:::-;27329:154;;;;;;;;;;;;:::i;:::-;;;;;;;;;27170:321;;;:::o;31027:799::-;31182:4;31203:15;:2;:13;;;:15::i;:::-;31199:620;;;31255:2;31239:36;;;31276:12;:10;:12::i;:::-;31290:4;31296:7;31305:5;31239:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;31235:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31498:1;31481:6;:13;:18;31477:272;;;31524:60;;;;;;;;;;:::i;:::-;;;;;;;;31477:272;31699:6;31693:13;31684:6;31680:2;31676:15;31669:38;31235:529;31372:41;;;31362:51;;;:6;:51;;;;31355:58;;;;;31199:620;31803:4;31796:11;;31027:799;;;;;;;:::o;58572:114::-;58632:13;58665;58658:20;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58572:114;:::o;16243:723::-;16299:13;16529:1;16520:5;:10;16516:53;;;16547:10;;;;;;;;;;;;;;;;;;;;;16516:53;16579:12;16594:5;16579:20;;16610:14;16635:78;16650:1;16642:4;:9;16635:78;;16668:8;;;;;:::i;:::-;;;;16699:2;16691:10;;;;;:::i;:::-;;;16635:78;;;16723:19;16755:6;16745:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16723:39;;16773:154;16789:1;16780:5;:10;16773:154;;16817:1;16807:11;;;;;:::i;:::-;;;16884:2;16876:5;:10;;;;:::i;:::-;16863:2;:24;;;;:::i;:::-;16850:39;;16833:6;16840;16833:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;;16913:2;16904:11;;;;;:::i;:::-;;;16773:154;;;16951:6;16937:21;;;;;16243:723;;;;:::o;32398:126::-;;;;:::o;27827:382::-;27921:1;27907:16;;:2;:16;;;;27899:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;27980:16;27988:7;27980;:16::i;:::-;27979:17;27971:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;28042:45;28071:1;28075:2;28079:7;28042:20;:45::i;:::-;28117:1;28100:9;:13;28110:2;28100:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;28148:2;28129:7;:16;28137:7;28129:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;28193:7;28189:2;28168:33;;28185:1;28168:33;;;;;;;;;;;;27827:382;;:::o;8686:387::-;8746:4;8954:12;9021:7;9009:20;9001:28;;9064:1;9057:4;:8;9050:15;;;8686:387;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:343:1:-;84:5;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:2;;;290:1;287;280:12;249:2;303:41;337:6;332:3;327;303:41;:::i;:::-;90:260;;;;;;:::o;356:345::-;434:5;459:66;475:49;517:6;475:49;:::i;:::-;459:66;:::i;:::-;450:75;;548:6;541:5;534:21;586:4;579:5;575:16;624:3;615:6;610:3;606:16;603:25;600:2;;;641:1;638;631:12;600:2;654:41;688:6;683:3;678;654:41;:::i;:::-;440:261;;;;;;:::o;707:139::-;753:5;791:6;778:20;769:29;;807:33;834:5;807:33;:::i;:::-;759:87;;;;:::o;852:133::-;895:5;933:6;920:20;911:29;;949:30;973:5;949:30;:::i;:::-;901:84;;;;:::o;991:137::-;1036:5;1074:6;1061:20;1052:29;;1090:32;1116:5;1090:32;:::i;:::-;1042:86;;;;:::o;1134:141::-;1190:5;1221:6;1215:13;1206:22;;1237:32;1263:5;1237:32;:::i;:::-;1196:79;;;;:::o;1294:271::-;1349:5;1398:3;1391:4;1383:6;1379:17;1375:27;1365:2;;1416:1;1413;1406:12;1365:2;1456:6;1443:20;1481:78;1555:3;1547:6;1540:4;1532:6;1528:17;1481:78;:::i;:::-;1472:87;;1355:210;;;;;:::o;1585:273::-;1641:5;1690:3;1683:4;1675:6;1671:17;1667:27;1657:2;;1708:1;1705;1698:12;1657:2;1748:6;1735:20;1773:79;1848:3;1840:6;1833:4;1825:6;1821:17;1773:79;:::i;:::-;1764:88;;1647:211;;;;;:::o;1864:139::-;1910:5;1948:6;1935:20;1926:29;;1964:33;1991:5;1964:33;:::i;:::-;1916:87;;;;:::o;2009:262::-;2068:6;2117:2;2105:9;2096:7;2092:23;2088:32;2085:2;;;2133:1;2130;2123:12;2085:2;2176:1;2201:53;2246:7;2237:6;2226:9;2222:22;2201:53;:::i;:::-;2191:63;;2147:117;2075:196;;;;:::o;2277:407::-;2345:6;2353;2402:2;2390:9;2381:7;2377:23;2373:32;2370:2;;;2418:1;2415;2408:12;2370:2;2461:1;2486:53;2531:7;2522:6;2511:9;2507:22;2486:53;:::i;:::-;2476:63;;2432:117;2588:2;2614:53;2659:7;2650:6;2639:9;2635:22;2614:53;:::i;:::-;2604:63;;2559:118;2360:324;;;;;:::o;2690:552::-;2767:6;2775;2783;2832:2;2820:9;2811:7;2807:23;2803:32;2800:2;;;2848:1;2845;2838:12;2800:2;2891:1;2916:53;2961:7;2952:6;2941:9;2937:22;2916:53;:::i;:::-;2906:63;;2862:117;3018:2;3044:53;3089:7;3080:6;3069:9;3065:22;3044:53;:::i;:::-;3034:63;;2989:118;3146:2;3172:53;3217:7;3208:6;3197:9;3193:22;3172:53;:::i;:::-;3162:63;;3117:118;2790:452;;;;;:::o;3248:809::-;3343:6;3351;3359;3367;3416:3;3404:9;3395:7;3391:23;3387:33;3384:2;;;3433:1;3430;3423:12;3384:2;3476:1;3501:53;3546:7;3537:6;3526:9;3522:22;3501:53;:::i;:::-;3491:63;;3447:117;3603:2;3629:53;3674:7;3665:6;3654:9;3650:22;3629:53;:::i;:::-;3619:63;;3574:118;3731:2;3757:53;3802:7;3793:6;3782:9;3778:22;3757:53;:::i;:::-;3747:63;;3702:118;3887:2;3876:9;3872:18;3859:32;3918:18;3910:6;3907:30;3904:2;;;3950:1;3947;3940:12;3904:2;3978:62;4032:7;4023:6;4012:9;4008:22;3978:62;:::i;:::-;3968:72;;3830:220;3374:683;;;;;;;:::o;4063:401::-;4128:6;4136;4185:2;4173:9;4164:7;4160:23;4156:32;4153:2;;;4201:1;4198;4191:12;4153:2;4244:1;4269:53;4314:7;4305:6;4294:9;4290:22;4269:53;:::i;:::-;4259:63;;4215:117;4371:2;4397:50;4439:7;4430:6;4419:9;4415:22;4397:50;:::i;:::-;4387:60;;4342:115;4143:321;;;;;:::o;4470:407::-;4538:6;4546;4595:2;4583:9;4574:7;4570:23;4566:32;4563:2;;;4611:1;4608;4601:12;4563:2;4654:1;4679:53;4724:7;4715:6;4704:9;4700:22;4679:53;:::i;:::-;4669:63;;4625:117;4781:2;4807:53;4852:7;4843:6;4832:9;4828:22;4807:53;:::i;:::-;4797:63;;4752:118;4553:324;;;;;:::o;4883:260::-;4941:6;4990:2;4978:9;4969:7;4965:23;4961:32;4958:2;;;5006:1;5003;4996:12;4958:2;5049:1;5074:52;5118:7;5109:6;5098:9;5094:22;5074:52;:::i;:::-;5064:62;;5020:116;4948:195;;;;:::o;5149:282::-;5218:6;5267:2;5255:9;5246:7;5242:23;5238:32;5235:2;;;5283:1;5280;5273:12;5235:2;5326:1;5351:63;5406:7;5397:6;5386:9;5382:22;5351:63;:::i;:::-;5341:73;;5297:127;5225:206;;;;:::o;5437:375::-;5506:6;5555:2;5543:9;5534:7;5530:23;5526:32;5523:2;;;5571:1;5568;5561:12;5523:2;5642:1;5631:9;5627:17;5614:31;5672:18;5664:6;5661:30;5658:2;;;5704:1;5701;5694:12;5658:2;5732:63;5787:7;5778:6;5767:9;5763:22;5732:63;:::i;:::-;5722:73;;5585:220;5513:299;;;;:::o;5818:262::-;5877:6;5926:2;5914:9;5905:7;5901:23;5897:32;5894:2;;;5942:1;5939;5932:12;5894:2;5985:1;6010:53;6055:7;6046:6;6035:9;6031:22;6010:53;:::i;:::-;6000:63;;5956:117;5884:196;;;;:::o;6086:108::-;6163:24;6181:5;6163:24;:::i;:::-;6158:3;6151:37;6141:53;;:::o;6200:118::-;6287:24;6305:5;6287:24;:::i;:::-;6282:3;6275:37;6265:53;;:::o;6324:109::-;6405:21;6420:5;6405:21;:::i;:::-;6400:3;6393:34;6383:50;;:::o;6439:360::-;6525:3;6553:38;6585:5;6553:38;:::i;:::-;6607:70;6670:6;6665:3;6607:70;:::i;:::-;6600:77;;6686:52;6731:6;6726:3;6719:4;6712:5;6708:16;6686:52;:::i;:::-;6763:29;6785:6;6763:29;:::i;:::-;6758:3;6754:39;6747:46;;6529:270;;;;;:::o;6805:364::-;6893:3;6921:39;6954:5;6921:39;:::i;:::-;6976:71;7040:6;7035:3;6976:71;:::i;:::-;6969:78;;7056:52;7101:6;7096:3;7089:4;7082:5;7078:16;7056:52;:::i;:::-;7133:29;7155:6;7133:29;:::i;:::-;7128:3;7124:39;7117:46;;6897:272;;;;;:::o;7175:377::-;7281:3;7309:39;7342:5;7309:39;:::i;:::-;7364:89;7446:6;7441:3;7364:89;:::i;:::-;7357:96;;7462:52;7507:6;7502:3;7495:4;7488:5;7484:16;7462:52;:::i;:::-;7539:6;7534:3;7530:16;7523:23;;7285:267;;;;;:::o;7558:366::-;7700:3;7721:67;7785:2;7780:3;7721:67;:::i;:::-;7714:74;;7797:93;7886:3;7797:93;:::i;:::-;7915:2;7910:3;7906:12;7899:19;;7704:220;;;:::o;7930:366::-;8072:3;8093:67;8157:2;8152:3;8093:67;:::i;:::-;8086:74;;8169:93;8258:3;8169:93;:::i;:::-;8287:2;8282:3;8278:12;8271:19;;8076:220;;;:::o;8302:366::-;8444:3;8465:67;8529:2;8524:3;8465:67;:::i;:::-;8458:74;;8541:93;8630:3;8541:93;:::i;:::-;8659:2;8654:3;8650:12;8643:19;;8448:220;;;:::o;8674:366::-;8816:3;8837:67;8901:2;8896:3;8837:67;:::i;:::-;8830:74;;8913:93;9002:3;8913:93;:::i;:::-;9031:2;9026:3;9022:12;9015:19;;8820:220;;;:::o;9046:366::-;9188:3;9209:67;9273:2;9268:3;9209:67;:::i;:::-;9202:74;;9285:93;9374:3;9285:93;:::i;:::-;9403:2;9398:3;9394:12;9387:19;;9192:220;;;:::o;9418:366::-;9560:3;9581:67;9645:2;9640:3;9581:67;:::i;:::-;9574:74;;9657:93;9746:3;9657:93;:::i;:::-;9775:2;9770:3;9766:12;9759:19;;9564:220;;;:::o;9790:366::-;9932:3;9953:67;10017:2;10012:3;9953:67;:::i;:::-;9946:74;;10029:93;10118:3;10029:93;:::i;:::-;10147:2;10142:3;10138:12;10131:19;;9936:220;;;:::o;10162:366::-;10304:3;10325:67;10389:2;10384:3;10325:67;:::i;:::-;10318:74;;10401:93;10490:3;10401:93;:::i;:::-;10519:2;10514:3;10510:12;10503:19;;10308:220;;;:::o;10534:366::-;10676:3;10697:67;10761:2;10756:3;10697:67;:::i;:::-;10690:74;;10773:93;10862:3;10773:93;:::i;:::-;10891:2;10886:3;10882:12;10875:19;;10680:220;;;:::o;10906:366::-;11048:3;11069:67;11133:2;11128:3;11069:67;:::i;:::-;11062:74;;11145:93;11234:3;11145:93;:::i;:::-;11263:2;11258:3;11254:12;11247:19;;11052:220;;;:::o;11278:366::-;11420:3;11441:67;11505:2;11500:3;11441:67;:::i;:::-;11434:74;;11517:93;11606:3;11517:93;:::i;:::-;11635:2;11630:3;11626:12;11619:19;;11424:220;;;:::o;11650:366::-;11792:3;11813:67;11877:2;11872:3;11813:67;:::i;:::-;11806:74;;11889:93;11978:3;11889:93;:::i;:::-;12007:2;12002:3;11998:12;11991:19;;11796:220;;;:::o;12022:366::-;12164:3;12185:67;12249:2;12244:3;12185:67;:::i;:::-;12178:74;;12261:93;12350:3;12261:93;:::i;:::-;12379:2;12374:3;12370:12;12363:19;;12168:220;;;:::o;12394:366::-;12536:3;12557:67;12621:2;12616:3;12557:67;:::i;:::-;12550:74;;12633:93;12722:3;12633:93;:::i;:::-;12751:2;12746:3;12742:12;12735:19;;12540:220;;;:::o;12766:366::-;12908:3;12929:67;12993:2;12988:3;12929:67;:::i;:::-;12922:74;;13005:93;13094:3;13005:93;:::i;:::-;13123:2;13118:3;13114:12;13107:19;;12912:220;;;:::o;13138:366::-;13280:3;13301:67;13365:2;13360:3;13301:67;:::i;:::-;13294:74;;13377:93;13466:3;13377:93;:::i;:::-;13495:2;13490:3;13486:12;13479:19;;13284:220;;;:::o;13510:366::-;13652:3;13673:67;13737:2;13732:3;13673:67;:::i;:::-;13666:74;;13749:93;13838:3;13749:93;:::i;:::-;13867:2;13862:3;13858:12;13851:19;;13656:220;;;:::o;13882:366::-;14024:3;14045:67;14109:2;14104:3;14045:67;:::i;:::-;14038:74;;14121:93;14210:3;14121:93;:::i;:::-;14239:2;14234:3;14230:12;14223:19;;14028:220;;;:::o;14254:366::-;14396:3;14417:67;14481:2;14476:3;14417:67;:::i;:::-;14410:74;;14493:93;14582:3;14493:93;:::i;:::-;14611:2;14606:3;14602:12;14595:19;;14400:220;;;:::o;14626:366::-;14768:3;14789:67;14853:2;14848:3;14789:67;:::i;:::-;14782:74;;14865:93;14954:3;14865:93;:::i;:::-;14983:2;14978:3;14974:12;14967:19;;14772:220;;;:::o;14998:366::-;15140:3;15161:67;15225:2;15220:3;15161:67;:::i;:::-;15154:74;;15237:93;15326:3;15237:93;:::i;:::-;15355:2;15350:3;15346:12;15339:19;;15144:220;;;:::o;15370:366::-;15512:3;15533:67;15597:2;15592:3;15533:67;:::i;:::-;15526:74;;15609:93;15698:3;15609:93;:::i;:::-;15727:2;15722:3;15718:12;15711:19;;15516:220;;;:::o;15742:400::-;15902:3;15923:84;16005:1;16000:3;15923:84;:::i;:::-;15916:91;;16016:93;16105:3;16016:93;:::i;:::-;16134:1;16129:3;16125:11;16118:18;;15906:236;;;:::o;16148:366::-;16290:3;16311:67;16375:2;16370:3;16311:67;:::i;:::-;16304:74;;16387:93;16476:3;16387:93;:::i;:::-;16505:2;16500:3;16496:12;16489:19;;16294:220;;;:::o;16520:366::-;16662:3;16683:67;16747:2;16742:3;16683:67;:::i;:::-;16676:74;;16759:93;16848:3;16759:93;:::i;:::-;16877:2;16872:3;16868:12;16861:19;;16666:220;;;:::o;16892:366::-;17034:3;17055:67;17119:2;17114:3;17055:67;:::i;:::-;17048:74;;17131:93;17220:3;17131:93;:::i;:::-;17249:2;17244:3;17240:12;17233:19;;17038:220;;;:::o;17264:366::-;17406:3;17427:67;17491:2;17486:3;17427:67;:::i;:::-;17420:74;;17503:93;17592:3;17503:93;:::i;:::-;17621:2;17616:3;17612:12;17605:19;;17410:220;;;:::o;17636:366::-;17778:3;17799:67;17863:2;17858:3;17799:67;:::i;:::-;17792:74;;17875:93;17964:3;17875:93;:::i;:::-;17993:2;17988:3;17984:12;17977:19;;17782:220;;;:::o;18008:366::-;18150:3;18171:67;18235:2;18230:3;18171:67;:::i;:::-;18164:74;;18247:93;18336:3;18247:93;:::i;:::-;18365:2;18360:3;18356:12;18349:19;;18154:220;;;:::o;18380:366::-;18522:3;18543:67;18607:2;18602:3;18543:67;:::i;:::-;18536:74;;18619:93;18708:3;18619:93;:::i;:::-;18737:2;18732:3;18728:12;18721:19;;18526:220;;;:::o;18810:707::-;18951:4;18946:3;18942:14;19048:4;19041:5;19037:16;19031:23;19067:63;19124:4;19119:3;19115:14;19101:12;19067:63;:::i;:::-;18966:174;19232:4;19225:5;19221:16;19215:23;19251:63;19308:4;19303:3;19299:14;19285:12;19251:63;:::i;:::-;19150:174;19418:4;19411:5;19407:16;19401:23;19437:63;19494:4;19489:3;19485:14;19471:12;19437:63;:::i;:::-;19334:176;18920:597;;;:::o;19523:108::-;19600:24;19618:5;19600:24;:::i;:::-;19595:3;19588:37;19578:53;;:::o;19637:118::-;19724:24;19742:5;19724:24;:::i;:::-;19719:3;19712:37;19702:53;;:::o;19761:435::-;19941:3;19963:95;20054:3;20045:6;19963:95;:::i;:::-;19956:102;;20075:95;20166:3;20157:6;20075:95;:::i;:::-;20068:102;;20187:3;20180:10;;19945:251;;;;;:::o;20202:541::-;20435:3;20457:95;20548:3;20539:6;20457:95;:::i;:::-;20450:102;;20569:148;20713:3;20569:148;:::i;:::-;20562:155;;20734:3;20727:10;;20439:304;;;;:::o;20749:222::-;20842:4;20880:2;20869:9;20865:18;20857:26;;20893:71;20961:1;20950:9;20946:17;20937:6;20893:71;:::i;:::-;20847:124;;;;:::o;20977:640::-;21172:4;21210:3;21199:9;21195:19;21187:27;;21224:71;21292:1;21281:9;21277:17;21268:6;21224:71;:::i;:::-;21305:72;21373:2;21362:9;21358:18;21349:6;21305:72;:::i;:::-;21387;21455:2;21444:9;21440:18;21431:6;21387:72;:::i;:::-;21506:9;21500:4;21496:20;21491:2;21480:9;21476:18;21469:48;21534:76;21605:4;21596:6;21534:76;:::i;:::-;21526:84;;21177:440;;;;;;;:::o;21623:210::-;21710:4;21748:2;21737:9;21733:18;21725:26;;21761:65;21823:1;21812:9;21808:17;21799:6;21761:65;:::i;:::-;21715:118;;;;:::o;21839:313::-;21952:4;21990:2;21979:9;21975:18;21967:26;;22039:9;22033:4;22029:20;22025:1;22014:9;22010:17;22003:47;22067:78;22140:4;22131:6;22067:78;:::i;:::-;22059:86;;21957:195;;;;:::o;22158:419::-;22324:4;22362:2;22351:9;22347:18;22339:26;;22411:9;22405:4;22401:20;22397:1;22386:9;22382:17;22375:47;22439:131;22565:4;22439:131;:::i;:::-;22431:139;;22329:248;;;:::o;22583:419::-;22749:4;22787:2;22776:9;22772:18;22764:26;;22836:9;22830:4;22826:20;22822:1;22811:9;22807:17;22800:47;22864:131;22990:4;22864:131;:::i;:::-;22856:139;;22754:248;;;:::o;23008:419::-;23174:4;23212:2;23201:9;23197:18;23189:26;;23261:9;23255:4;23251:20;23247:1;23236:9;23232:17;23225:47;23289:131;23415:4;23289:131;:::i;:::-;23281:139;;23179:248;;;:::o;23433:419::-;23599:4;23637:2;23626:9;23622:18;23614:26;;23686:9;23680:4;23676:20;23672:1;23661:9;23657:17;23650:47;23714:131;23840:4;23714:131;:::i;:::-;23706:139;;23604:248;;;:::o;23858:419::-;24024:4;24062:2;24051:9;24047:18;24039:26;;24111:9;24105:4;24101:20;24097:1;24086:9;24082:17;24075:47;24139:131;24265:4;24139:131;:::i;:::-;24131:139;;24029:248;;;:::o;24283:419::-;24449:4;24487:2;24476:9;24472:18;24464:26;;24536:9;24530:4;24526:20;24522:1;24511:9;24507:17;24500:47;24564:131;24690:4;24564:131;:::i;:::-;24556:139;;24454:248;;;:::o;24708:419::-;24874:4;24912:2;24901:9;24897:18;24889:26;;24961:9;24955:4;24951:20;24947:1;24936:9;24932:17;24925:47;24989:131;25115:4;24989:131;:::i;:::-;24981:139;;24879:248;;;:::o;25133:419::-;25299:4;25337:2;25326:9;25322:18;25314:26;;25386:9;25380:4;25376:20;25372:1;25361:9;25357:17;25350:47;25414:131;25540:4;25414:131;:::i;:::-;25406:139;;25304:248;;;:::o;25558:419::-;25724:4;25762:2;25751:9;25747:18;25739:26;;25811:9;25805:4;25801:20;25797:1;25786:9;25782:17;25775:47;25839:131;25965:4;25839:131;:::i;:::-;25831:139;;25729:248;;;:::o;25983:419::-;26149:4;26187:2;26176:9;26172:18;26164:26;;26236:9;26230:4;26226:20;26222:1;26211:9;26207:17;26200:47;26264:131;26390:4;26264:131;:::i;:::-;26256:139;;26154:248;;;:::o;26408:419::-;26574:4;26612:2;26601:9;26597:18;26589:26;;26661:9;26655:4;26651:20;26647:1;26636:9;26632:17;26625:47;26689:131;26815:4;26689:131;:::i;:::-;26681:139;;26579:248;;;:::o;26833:419::-;26999:4;27037:2;27026:9;27022:18;27014:26;;27086:9;27080:4;27076:20;27072:1;27061:9;27057:17;27050:47;27114:131;27240:4;27114:131;:::i;:::-;27106:139;;27004:248;;;:::o;27258:419::-;27424:4;27462:2;27451:9;27447:18;27439:26;;27511:9;27505:4;27501:20;27497:1;27486:9;27482:17;27475:47;27539:131;27665:4;27539:131;:::i;:::-;27531:139;;27429:248;;;:::o;27683:419::-;27849:4;27887:2;27876:9;27872:18;27864:26;;27936:9;27930:4;27926:20;27922:1;27911:9;27907:17;27900:47;27964:131;28090:4;27964:131;:::i;:::-;27956:139;;27854:248;;;:::o;28108:419::-;28274:4;28312:2;28301:9;28297:18;28289:26;;28361:9;28355:4;28351:20;28347:1;28336:9;28332:17;28325:47;28389:131;28515:4;28389:131;:::i;:::-;28381:139;;28279:248;;;:::o;28533:419::-;28699:4;28737:2;28726:9;28722:18;28714:26;;28786:9;28780:4;28776:20;28772:1;28761:9;28757:17;28750:47;28814:131;28940:4;28814:131;:::i;:::-;28806:139;;28704:248;;;:::o;28958:419::-;29124:4;29162:2;29151:9;29147:18;29139:26;;29211:9;29205:4;29201:20;29197:1;29186:9;29182:17;29175:47;29239:131;29365:4;29239:131;:::i;:::-;29231:139;;29129:248;;;:::o;29383:419::-;29549:4;29587:2;29576:9;29572:18;29564:26;;29636:9;29630:4;29626:20;29622:1;29611:9;29607:17;29600:47;29664:131;29790:4;29664:131;:::i;:::-;29656:139;;29554:248;;;:::o;29808:419::-;29974:4;30012:2;30001:9;29997:18;29989:26;;30061:9;30055:4;30051:20;30047:1;30036:9;30032:17;30025:47;30089:131;30215:4;30089:131;:::i;:::-;30081:139;;29979:248;;;:::o;30233:419::-;30399:4;30437:2;30426:9;30422:18;30414:26;;30486:9;30480:4;30476:20;30472:1;30461:9;30457:17;30450:47;30514:131;30640:4;30514:131;:::i;:::-;30506:139;;30404:248;;;:::o;30658:419::-;30824:4;30862:2;30851:9;30847:18;30839:26;;30911:9;30905:4;30901:20;30897:1;30886:9;30882:17;30875:47;30939:131;31065:4;30939:131;:::i;:::-;30931:139;;30829:248;;;:::o;31083:419::-;31249:4;31287:2;31276:9;31272:18;31264:26;;31336:9;31330:4;31326:20;31322:1;31311:9;31307:17;31300:47;31364:131;31490:4;31364:131;:::i;:::-;31356:139;;31254:248;;;:::o;31508:419::-;31674:4;31712:2;31701:9;31697:18;31689:26;;31761:9;31755:4;31751:20;31747:1;31736:9;31732:17;31725:47;31789:131;31915:4;31789:131;:::i;:::-;31781:139;;31679:248;;;:::o;31933:419::-;32099:4;32137:2;32126:9;32122:18;32114:26;;32186:9;32180:4;32176:20;32172:1;32161:9;32157:17;32150:47;32214:131;32340:4;32214:131;:::i;:::-;32206:139;;32104:248;;;:::o;32358:419::-;32524:4;32562:2;32551:9;32547:18;32539:26;;32611:9;32605:4;32601:20;32597:1;32586:9;32582:17;32575:47;32639:131;32765:4;32639:131;:::i;:::-;32631:139;;32529:248;;;:::o;32783:419::-;32949:4;32987:2;32976:9;32972:18;32964:26;;33036:9;33030:4;33026:20;33022:1;33011:9;33007:17;33000:47;33064:131;33190:4;33064:131;:::i;:::-;33056:139;;32954:248;;;:::o;33208:419::-;33374:4;33412:2;33401:9;33397:18;33389:26;;33461:9;33455:4;33451:20;33447:1;33436:9;33432:17;33425:47;33489:131;33615:4;33489:131;:::i;:::-;33481:139;;33379:248;;;:::o;33633:419::-;33799:4;33837:2;33826:9;33822:18;33814:26;;33886:9;33880:4;33876:20;33872:1;33861:9;33857:17;33850:47;33914:131;34040:4;33914:131;:::i;:::-;33906:139;;33804:248;;;:::o;34058:419::-;34224:4;34262:2;34251:9;34247:18;34239:26;;34311:9;34305:4;34301:20;34297:1;34286:9;34282:17;34275:47;34339:131;34465:4;34339:131;:::i;:::-;34331:139;;34229:248;;;:::o;34483:310::-;34620:4;34658:2;34647:9;34643:18;34635:26;;34671:115;34783:1;34772:9;34768:17;34759:6;34671:115;:::i;:::-;34625:168;;;;:::o;34799:222::-;34892:4;34930:2;34919:9;34915:18;34907:26;;34943:71;35011:1;35000:9;34996:17;34987:6;34943:71;:::i;:::-;34897:124;;;;:::o;35027:129::-;35061:6;35088:20;;:::i;:::-;35078:30;;35117:33;35145:4;35137:6;35117:33;:::i;:::-;35068:88;;;:::o;35162:75::-;35195:6;35228:2;35222:9;35212:19;;35202:35;:::o;35243:307::-;35304:4;35394:18;35386:6;35383:30;35380:2;;;35416:18;;:::i;:::-;35380:2;35454:29;35476:6;35454:29;:::i;:::-;35446:37;;35538:4;35532;35528:15;35520:23;;35309:241;;;:::o;35556:308::-;35618:4;35708:18;35700:6;35697:30;35694:2;;;35730:18;;:::i;:::-;35694:2;35768:29;35790:6;35768:29;:::i;:::-;35760:37;;35852:4;35846;35842:15;35834:23;;35623:241;;;:::o;35870:98::-;35921:6;35955:5;35949:12;35939:22;;35928:40;;;:::o;35974:99::-;36026:6;36060:5;36054:12;36044:22;;36033:40;;;:::o;36079:168::-;36162:11;36196:6;36191:3;36184:19;36236:4;36231:3;36227:14;36212:29;;36174:73;;;;:::o;36253:169::-;36337:11;36371:6;36366:3;36359:19;36411:4;36406:3;36402:14;36387:29;;36349:73;;;;:::o;36428:148::-;36530:11;36567:3;36552:18;;36542:34;;;;:::o;36582:305::-;36622:3;36641:20;36659:1;36641:20;:::i;:::-;36636:25;;36675:20;36693:1;36675:20;:::i;:::-;36670:25;;36829:1;36761:66;36757:74;36754:1;36751:81;36748:2;;;36835:18;;:::i;:::-;36748:2;36879:1;36876;36872:9;36865:16;;36626:261;;;;:::o;36893:185::-;36933:1;36950:20;36968:1;36950:20;:::i;:::-;36945:25;;36984:20;37002:1;36984:20;:::i;:::-;36979:25;;37023:1;37013:2;;37028:18;;:::i;:::-;37013:2;37070:1;37067;37063:9;37058:14;;36935:143;;;;:::o;37084:191::-;37124:4;37144:20;37162:1;37144:20;:::i;:::-;37139:25;;37178:20;37196:1;37178:20;:::i;:::-;37173:25;;37217:1;37214;37211:8;37208:2;;;37222:18;;:::i;:::-;37208:2;37267:1;37264;37260:9;37252:17;;37129:146;;;;:::o;37281:96::-;37318:7;37347:24;37365:5;37347:24;:::i;:::-;37336:35;;37326:51;;;:::o;37383:90::-;37417:7;37460:5;37453:13;37446:21;37435:32;;37425:48;;;:::o;37479:149::-;37515:7;37555:66;37548:5;37544:78;37533:89;;37523:105;;;:::o;37634:126::-;37671:7;37711:42;37704:5;37700:54;37689:65;;37679:81;;;:::o;37766:77::-;37803:7;37832:5;37821:16;;37811:32;;;:::o;37849:154::-;37933:6;37928:3;37923;37910:30;37995:1;37986:6;37981:3;37977:16;37970:27;37900:103;;;:::o;38009:307::-;38077:1;38087:113;38101:6;38098:1;38095:13;38087:113;;;38186:1;38181:3;38177:11;38171:18;38167:1;38162:3;38158:11;38151:39;38123:2;38120:1;38116:10;38111:15;;38087:113;;;38218:6;38215:1;38212:13;38209:2;;;38298:1;38289:6;38284:3;38280:16;38273:27;38209:2;38058:258;;;;:::o;38322:320::-;38366:6;38403:1;38397:4;38393:12;38383:22;;38450:1;38444:4;38440:12;38471:18;38461:2;;38527:4;38519:6;38515:17;38505:27;;38461:2;38589;38581:6;38578:14;38558:18;38555:38;38552:2;;;38608:18;;:::i;:::-;38552:2;38373:269;;;;:::o;38648:281::-;38731:27;38753:4;38731:27;:::i;:::-;38723:6;38719:40;38861:6;38849:10;38846:22;38825:18;38813:10;38810:34;38807:62;38804:2;;;38872:18;;:::i;:::-;38804:2;38912:10;38908:2;38901:22;38691:238;;;:::o;38935:233::-;38974:3;38997:24;39015:5;38997:24;:::i;:::-;38988:33;;39043:66;39036:5;39033:77;39030:2;;;39113:18;;:::i;:::-;39030:2;39160:1;39153:5;39149:13;39142:20;;38978:190;;;:::o;39174:176::-;39206:1;39223:20;39241:1;39223:20;:::i;:::-;39218:25;;39257:20;39275:1;39257:20;:::i;:::-;39252:25;;39296:1;39286:2;;39301:18;;:::i;:::-;39286:2;39342:1;39339;39335:9;39330:14;;39208:142;;;;:::o;39356:180::-;39404:77;39401:1;39394:88;39501:4;39498:1;39491:15;39525:4;39522:1;39515:15;39542:180;39590:77;39587:1;39580:88;39687:4;39684:1;39677:15;39711:4;39708:1;39701:15;39728:180;39776:77;39773:1;39766:88;39873:4;39870:1;39863:15;39897:4;39894:1;39887:15;39914:180;39962:77;39959:1;39952:88;40059:4;40056:1;40049:15;40083:4;40080:1;40073:15;40100:102;40141:6;40192:2;40188:7;40183:2;40176:5;40172:14;40168:28;40158:38;;40148:54;;;:::o;40208:170::-;40348:22;40344:1;40336:6;40332:14;40325:46;40314:64;:::o;40384:168::-;40524:20;40520:1;40512:6;40508:14;40501:44;40490:62;:::o;40558:237::-;40698:34;40694:1;40686:6;40682:14;40675:58;40767:20;40762:2;40754:6;40750:15;40743:45;40664:131;:::o;40801:221::-;40941:34;40937:1;40929:6;40925:14;40918:58;41010:4;41005:2;40997:6;40993:15;40986:29;40907:115;:::o;41028:225::-;41168:34;41164:1;41156:6;41152:14;41145:58;41237:8;41232:2;41224:6;41220:15;41213:33;41134:119;:::o;41259:178::-;41399:30;41395:1;41387:6;41383:14;41376:54;41365:72;:::o;41443:220::-;41583:34;41579:1;41571:6;41567:14;41560:58;41652:3;41647:2;41639:6;41635:15;41628:28;41549:114;:::o;41669:223::-;41809:34;41805:1;41797:6;41793:14;41786:58;41878:6;41873:2;41865:6;41861:15;41854:31;41775:117;:::o;41898:175::-;42038:27;42034:1;42026:6;42022:14;42015:51;42004:69;:::o;42079:173::-;42219:25;42215:1;42207:6;42203:14;42196:49;42185:67;:::o;42258:174::-;42398:26;42394:1;42386:6;42382:14;42375:50;42364:68;:::o;42438:223::-;42578:34;42574:1;42566:6;42562:14;42555:58;42647:6;42642:2;42634:6;42630:15;42623:31;42544:117;:::o;42667:221::-;42807:34;42803:1;42795:6;42791:14;42784:58;42876:4;42871:2;42863:6;42859:15;42852:29;42773:115;:::o;42894:231::-;43034:34;43030:1;43022:6;43018:14;43011:58;43103:14;43098:2;43090:6;43086:15;43079:39;43000:125;:::o;43131:228::-;43271:34;43267:1;43259:6;43255:14;43248:58;43340:11;43335:2;43327:6;43323:15;43316:36;43237:122;:::o;43365:166::-;43505:18;43501:1;43493:6;43489:14;43482:42;43471:60;:::o;43537:243::-;43677:34;43673:1;43665:6;43661:14;43654:58;43746:26;43741:2;43733:6;43729:15;43722:51;43643:137;:::o;43786:229::-;43926:34;43922:1;43914:6;43910:14;43903:58;43995:12;43990:2;43982:6;43978:15;43971:37;43892:123;:::o;44021:228::-;44161:34;44157:1;44149:6;44145:14;44138:58;44230:11;44225:2;44217:6;44213:15;44206:36;44127:122;:::o;44255:182::-;44395:34;44391:1;44383:6;44379:14;44372:58;44361:76;:::o;44443:227::-;44583:34;44579:1;44571:6;44567:14;44560:58;44652:10;44647:2;44639:6;44635:15;44628:35;44549:121;:::o;44676:231::-;44816:34;44812:1;44804:6;44800:14;44793:58;44885:14;44880:2;44872:6;44868:15;44861:39;44782:125;:::o;44913:155::-;45053:7;45049:1;45041:6;45037:14;45030:31;45019:49;:::o;45074:182::-;45214:34;45210:1;45202:6;45198:14;45191:58;45180:76;:::o;45262:228::-;45402:34;45398:1;45390:6;45386:14;45379:58;45471:11;45466:2;45458:6;45454:15;45447:36;45368:122;:::o;45496:234::-;45636:34;45632:1;45624:6;45620:14;45613:58;45705:17;45700:2;45692:6;45688:15;45681:42;45602:128;:::o;45736:220::-;45876:34;45872:1;45864:6;45860:14;45853:58;45945:3;45940:2;45932:6;45928:15;45921:28;45842:114;:::o;45962:227::-;46102:34;46098:1;46090:6;46086:14;46079:58;46171:10;46166:2;46158:6;46154:15;46147:35;46068:121;:::o;46195:236::-;46335:34;46331:1;46323:6;46319:14;46312:58;46404:19;46399:2;46391:6;46387:15;46380:44;46301:130;:::o;46437:181::-;46577:33;46573:1;46565:6;46561:14;46554:57;46543:75;:::o;46624:122::-;46697:24;46715:5;46697:24;:::i;:::-;46690:5;46687:35;46677:2;;46736:1;46733;46726:12;46677:2;46667:79;:::o;46752:116::-;46822:21;46837:5;46822:21;:::i;:::-;46815:5;46812:32;46802:2;;46858:1;46855;46848:12;46802:2;46792:76;:::o;46874:120::-;46946:23;46963:5;46946:23;:::i;:::-;46939:5;46936:34;46926:2;;46984:1;46981;46974:12;46926:2;46916:78;:::o;47000:122::-;47073:24;47091:5;47073:24;:::i;:::-;47066:5;47063:35;47053:2;;47112:1;47109;47102:12;47053:2;47043:79;:::o

ipfs://af2bdb3d1ffbebec7cc1ae0551160586c1050fc4471db66012a893cbf12ac711