Token Ko Digital Collectible

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

// File: Ko-blockchain/Counters.sol

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

/**
 * @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;
    }
}
// File: Ko-blockchain/ChildMintableERC721.sol

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 payable sender) {
        return payable(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);
}

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


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transfered 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;
}

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


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

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

/**
 * @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) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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

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

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

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

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

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

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

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

        assembly {
            result := store
        }

        return result;
    }
}

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    using EnumerableSet for EnumerableSet.Bytes32Set;

    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct Map {
        // Storage of keys
        EnumerableSet.Bytes32Set _keys;
        mapping(bytes32 => bytes32) _values;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(
        Map storage map,
        bytes32 key,
        bytes32 value
    ) private returns (bool) {
        map._values[key] = value;
        return map._keys.add(key);
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function _remove(Map storage map, bytes32 key) private returns (bool) {
        delete map._values[key];
        return map._keys.remove(key);
    }

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

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

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

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        bytes32 value = map._values[key];
        if (value == bytes32(0)) {
            return (_contains(map, key), bytes32(0));
        } else {
            return (true, value);
        }
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        bytes32 value = map._values[key];
        require(value != 0 || _contains(map, key), "EnumerableMap: nonexistent key");
        return value;
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(
        Map storage map,
        bytes32 key,
        string memory errorMessage
    ) private view returns (bytes32) {
        bytes32 value = map._values[key];
        require(value != 0 || _contains(map, key), errorMessage);
        return value;
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

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

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

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

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

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

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

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

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

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

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

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

    // Token name
    string private _name;

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

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

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

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

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

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

    // Base URI
    string private _baseURI;

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

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

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

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

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

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

        return _holderTokens[owner].length();
    }

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

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

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

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

        string memory _tokenURI = _tokenURIs[tokenId];

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

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

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

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

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

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = 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 override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view 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 mecanisms 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 returns (bool) {
        return _tokenOwners.contains(tokenId);
    }

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

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

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

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

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal virtual {
        require(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);

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

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

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

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

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

    function _approve(address to, uint256 tokenId) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context {
    using EnumerableSet for EnumerableSet.AddressSet;
    using Address for address;

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

    mapping (bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view returns (bool) {
        return _roles[role].members.contains(account);
    }

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

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

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant");

        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual {
        require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke");

        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
        _roles[role].adminRole = adminRole;
    }

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

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

contract AccessControlMixin is AccessControl {
    string private _revertMsg;
    function _setupContractId(string memory contractId) internal {
        _revertMsg = string(abi.encodePacked(contractId, ": INSUFFICIENT_PERMISSIONS"));
    }

    modifier only(bytes32 role) {
        require(
            hasRole(role, _msgSender()),
            _revertMsg
        );
        _;
    }
}

interface IChildToken {
    function deposit(address user, bytes calldata depositData) external;
}

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        _;
        inited = true;
    }
}

contract EIP712Base is Initializable {
    struct EIP712Domain {
        string name;
        string version;
        address verifyingContract;
        bytes32 salt;
    }

    string constant public ERC712_VERSION = "1";

    bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(
        bytes(
            "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
        )
    );
    bytes32 internal domainSeperator;

    // supposed to be called once while initializing.
    // one of the contractsa that inherits this contract follows proxy pattern
    // so it is not possible to do this in a constructor
    function _initializeEIP712(
        string memory name
    )
        internal
        initializer
    {
        _setDomainSeperator(name);
    }

    function _setDomainSeperator(string memory name) internal {
        domainSeperator = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                keccak256(bytes(ERC712_VERSION)),
                address(this),
                bytes32(getChainId())
            )
        );
    }

    function getDomainSeperator() public view returns (bytes32) {
        return domainSeperator;
    }

    function getChainId() public view returns (uint256) {
        uint256 id;
        assembly {
            id := chainid()
        }

        return id;
    }

    /**
     * Accept message hash and returns hash message in EIP712 compatible form
     * So that it can be used to recover signer from signature signed using EIP712 formatted data
     * https://eips.ethereum.org/EIPS/eip-712
     * "\\x19" makes the encoding deterministic
     * "\\x01" is the version byte to make it compatible to EIP-191
     */
    function toTypedMessageHash(bytes32 messageHash)
        internal
        view
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
            );
    }
}

contract NativeMetaTransaction is EIP712Base {
    using SafeMath for uint256;
    bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(
        bytes(
            "MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
        )
    );
    event MetaTransactionExecuted(
        address userAddress,
        address payable relayerAddress,
        bytes functionSignature
    );
    mapping(address => uint256) nonces;

    /*
     * Meta transaction structure.
     * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
     * He should call the desired function directly in that case.
     */
    struct MetaTransaction {
        uint256 nonce;
        address from;
        bytes functionSignature;
    }

    function executeMetaTransaction(
        address userAddress,
        bytes memory functionSignature,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) public payable returns (bytes memory) {
        MetaTransaction memory metaTx = MetaTransaction({
            nonce: nonces[userAddress],
            from: userAddress,
            functionSignature: functionSignature
        });

        require(
            verify(userAddress, metaTx, sigR, sigS, sigV),
            "Signer and signature do not match"
        );

        // increase nonce for user (to avoid re-use)
        nonces[userAddress] = nonces[userAddress].add(1);

        emit MetaTransactionExecuted(
            userAddress,
            payable(msg.sender),
            functionSignature
        );

        // Append userAddress and relayer address at the end to extract it from calling context
        (bool success, bytes memory returnData) = address(this).call(
            abi.encodePacked(functionSignature, userAddress)
        );
        require(success, "Function call not successful");

        return returnData;
    }

    function hashMetaTransaction(MetaTransaction memory metaTx)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encode(
                    META_TRANSACTION_TYPEHASH,
                    metaTx.nonce,
                    metaTx.from,
                    keccak256(metaTx.functionSignature)
                )
            );
    }

    function getNonce(address user) public view returns (uint256 nonce) {
        nonce = nonces[user];
    }

    function verify(
        address signer,
        MetaTransaction memory metaTx,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) internal view returns (bool) {
        require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
        return
            signer ==
            ecrecover(
                toTypedMessageHash(hashMetaTransaction(metaTx)),
                sigV,
                sigR,
                sigS
            );
    }
}

abstract contract ContextMixin {
    function msgSender()
        internal
        view
        returns (address payable sender)
    {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
                // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
                sender := and(
                    mload(add(array, index)),
                    0xffffffffffffffffffffffffffffffffffffffff
                )
            }
        } else {
            sender = payable(msg.sender);
        }
        return sender;
    }
}

contract ChildMintableERC721 is
    ERC721,
    IChildToken,
    AccessControlMixin,
    NativeMetaTransaction,
    ContextMixin
{
    bytes32 public constant DEPOSITOR_ROLE = keccak256("DEPOSITOR_ROLE");
    mapping (uint256 => bool) public withdrawnTokens;
    using Strings for uint256;

    // limit batching of tokens due to gas limit restrictions
    uint256 public constant BATCH_LIMIT = 20;

    event WithdrawnBatch(address indexed user, uint256[] tokenIds);
    event TransferWithMetadata(address indexed from, address indexed to, uint256 indexed tokenId, bytes metaData);

    constructor(
        string memory name_,
        string memory symbol_,
        address childChainManager
     ) ERC721(name_, symbol_) {
        _setupContractId("test2KO");
        _setupRole(DEPOSITOR_ROLE, childChainManager);
        _initializeEIP712(name_);
    }

    // This is to support Native meta transactions
    // never use msg.sender directly, use _msgSender() instead
    function _msgSender()
        internal
        override
        view
        virtual
        returns (address payable sender)
    {
        return ContextMixin.msgSender();
    }

    /**
     * @notice called when token is deposited on root chain
     * @dev Should be callable only by ChildChainManager
     * Should handle deposit by minting the required tokenId(s) for user
     * Should set `withdrawnTokens` mapping to `false` for the tokenId being deposited
     * Minting can also be done by other functions
     * @param user user address for whom deposit is being done
     * @param depositData abi encoded tokenIds. Batch deposit also supported.
     */
    function deposit(address user, bytes calldata depositData)
        external
        override
        only(DEPOSITOR_ROLE)
    {
        // deposit single
        if (depositData.length == 32) {
            uint256 tokenId = abi.decode(depositData, (uint256));
            withdrawnTokens[tokenId] = false;
            _mint(user, tokenId);

        // deposit batch
        } else {
            uint256[] memory tokenIds = abi.decode(depositData, (uint256[]));
            uint256 length = tokenIds.length;
            for (uint256 i; i < length; i++) {
                withdrawnTokens[tokenIds[i]] = false;
                _mint(user, tokenIds[i]);
            }
        }

    }

    /**
     * @notice called when user wants to withdraw token back to root chain
     * @dev Should handle withraw by burning user's token.
     * Should set `withdrawnTokens` mapping to `true` for the tokenId being withdrawn
     * This transaction will be verified when exiting on root chain
     * @param tokenId tokenId to withdraw
     */
    function withdraw(uint256 tokenId) external {
        require(_msgSender() == ownerOf(tokenId), "ChildMintableERC721: INVALID_TOKEN_OWNER");
        withdrawnTokens[tokenId] = true;
        _burn(tokenId);
    }

    /**
     * @notice called when user wants to withdraw multiple tokens back to root chain
     * @dev Should burn user's tokens. This transaction will be verified when exiting on root chain
     * @param tokenIds tokenId list to withdraw
     */
    function withdrawBatch(uint256[] calldata tokenIds) external {

        uint256 length = tokenIds.length;
        require(length <= BATCH_LIMIT, "ChildMintableERC721: EXCEEDS_BATCH_LIMIT");

        // Iteratively burn ERC721 tokens, for performing
        // batch withdraw
        for (uint256 i; i < length; i++) {

            uint256 tokenId = tokenIds[i];

            require(_msgSender() == ownerOf(tokenId), string(abi.encodePacked("ChildMintableERC721: INVALID_TOKEN_OWNER ", tokenId)));
            withdrawnTokens[tokenId] = true;
            _burn(tokenId);

        }

        // At last emit this event, which will be used
        // in MintableERC721 predicate contract on L1
        // while verifying burn proof
        emit WithdrawnBatch(_msgSender(), tokenIds);

    }

    /**
     * @notice called when user wants to withdraw token back to root chain with token URI
     * @dev Should handle withraw by burning user's token.
     * Should set `withdrawnTokens` mapping to `true` for the tokenId being withdrawn
     * This transaction will be verified when exiting on root chain
     *
     * @param tokenId tokenId to withdraw
     */
    function withdrawWithMetadata(uint256 tokenId) external {

        require(_msgSender() == ownerOf(tokenId), "ChildMintableERC721: INVALID_TOKEN_OWNER");
        withdrawnTokens[tokenId] = true;

        // Encoding metadata associated with tokenId & emitting event
        emit TransferWithMetadata(ownerOf(tokenId), address(0), tokenId, this.encodeTokenMetadata(tokenId));

        _burn(tokenId);

    }

    /**
     * @notice This method is supposed to be called by client when withdrawing token with metadata
     * and pass return value of this function as second paramter of `withdrawWithMetadata` method
     *
     * It can be overridden by clients to encode data in a different form, which needs to
     * be decoded back by them correctly during exiting
     *
     * @param tokenId Token for which URI to be fetched
     */
    function encodeTokenMetadata(uint256 tokenId) external view virtual returns (bytes memory) {

        // You're always free to change this default implementation
        // and pack more data in byte array which can be decoded back
        // in L1
        return abi.encode(tokenURI(tokenId));

    }

    /**
     * @notice Example function to handle minting tokens on matic chain
     * @dev Minting can be done as per requirement,
     * This implementation allows only admin to mint tokens but it can be changed as per requirement
     * Should verify if token is withdrawn by checking `withdrawnTokens` mapping
     * @param user user for whom tokens are being minted
     * @param tokenId tokenId to mint
     */

    function mint(address user, uint256 tokenId) public only(DEFAULT_ADMIN_ROLE) {
        require(!withdrawnTokens[tokenId], "ChildMintableERC721: TOKEN_EXISTS_ON_ROOT_CHAIN");
        _mint(user, tokenId);
    }

}
// File: Ko-blockchain/tokenNFT.sol

pragma solidity 0.8.4;



contract tokenNFT is ChildMintableERC721 {
  using Counters for Counters.Counter;
  Counters.Counter private _tokenIds;
  mapping (uint256 => string) private _tokenURIs;
  
  constructor() ChildMintableERC721("Ko Digital Collectible", "KODC", 0xb5505a6d998549090530911180f38aC5130101c6) {}

  function mintable(address recipient, string memory uri) public returns (uint256) {
    _tokenIds.increment();
    uint256 newItemId = _tokenIds.current();
    _mint(recipient, newItemId);
    _setTokenURI(newItemId, uri);

    return newItemId;
  }
}

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"metaData","type":"bytes"}],"name":"TransferWithMetadata","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"WithdrawnBatch","type":"event"},{"inputs":[],"name":"BATCH_LIMIT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPOSITOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"bytes","name":"depositData","type":"bytes"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"encodeTokenMetadata","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"string","name":"uri","type":"string"}],"name":"mintable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"withdrawBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"withdrawWithMetadata","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"withdrawnTokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

81219:558:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10900:142;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48319:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75114:48;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51038:213;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50582:390;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72017:1151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69279:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;80188:308;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50076:203;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70289:101;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81519:255;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51912:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65187:114;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73594:107;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77654:215;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65563:227;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49846:154;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70398:163;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66772:209;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;80931:212;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52288:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50356:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48075:177;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49665:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47790:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64860:138;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63821:139;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75266:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48488:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;78131:811;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62566:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51323:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75039:68;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79326:416;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52510:285;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48663:763;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64134:127;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;76592:701;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66035:230;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51689:156;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10900:142;10977:4;11001:20;:33;11022:11;11001:33;;;;;;;;;;;;;;;;;;;;;;;;;;;10994:40;;10900:142;;;:::o;48319:100::-;48373:13;48406:5;48399:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48319:100;:::o;75114:48::-;;;;;;;;;;;;;;;;;;;;;;:::o;51038:213::-;51106:7;51134:16;51142:7;51134;:16::i;:::-;51126:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;51219:15;:24;51235:7;51219:24;;;;;;;;;;;;;;;;;;;;;51212:31;;51038:213;;;:::o;50582:390::-;50663:13;50679:16;50687:7;50679;:16::i;:::-;50663:32;;50720:5;50714:11;;:2;:11;;;;50706:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;50800:5;50784:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;50809:37;50826:5;50833:12;:10;:12::i;:::-;50809:16;:37::i;:::-;50784:62;50776:154;;;;;;;;;;;;:::i;:::-;;;;;;;;;50943:21;50952:2;50956:7;50943:8;:21::i;:::-;50582:390;;;:::o;72017:1151::-;72218:12;72243:29;72275:152;;;;;;;;72313:6;:19;72320:11;72313:19;;;;;;;;;;;;;;;;72275:152;;;;72353:11;72275:152;;;;;;72398:17;72275:152;;;72243:184;;72462:45;72469:11;72482:6;72490:4;72496;72502;72462:6;:45::i;:::-;72440:128;;;;;;;;;;;;:::i;:::-;;;;;;;;;72657:26;72681:1;72657:6;:19;72664:11;72657:19;;;;;;;;;;;;;;;;:23;;:26;;;;:::i;:::-;72635:6;:19;72642:11;72635:19;;;;;;;;;;;;;;;:48;;;;72701:126;72739:11;72773:10;72799:17;72701:126;;;;;;;;:::i;:::-;;;;;;;;72938:12;72952:23;72987:4;72979:18;;73029:17;73048:11;73012:48;;;;;;;;;:::i;:::-;;;;;;;;;;;;;72979:92;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72937:134;;;;73090:7;73082:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;73150:10;73143:17;;;;;72017:1151;;;;;;;:::o;69279:43::-;;;;;;;;;;;;;;;;;;;:::o;80188:308::-;80265:12;80468:17;80477:7;80468:8;:17::i;:::-;80457:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;80450:36;;80188:308;;;:::o;50076:203::-;50129:7;50250:21;:12;:19;:21::i;:::-;50243:28;;50076:203;:::o;70289:101::-;70340:7;70367:15;;70360:22;;70289:101;:::o;81519:255::-;81591:7;81607:21;:9;:19;:21::i;:::-;81635:17;81655:19;:9;:17;:19::i;:::-;81635:39;;81681:27;81687:9;81698;81681:5;:27::i;:::-;81715:28;81728:9;81739:3;81715:12;:28::i;:::-;81759:9;81752:16;;;81519:255;;;;:::o;51912:305::-;52073:41;52092:12;:10;:12::i;:::-;52106:7;52073:18;:41::i;:::-;52065:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;52181:28;52191:4;52197:2;52201:7;52181:9;:28::i;:::-;51912:305;;;:::o;65187:114::-;65244:7;65271:6;:12;65278:4;65271:12;;;;;;;;;;;:22;;;65264:29;;65187:114;;;:::o;73594:107::-;73647:13;73681:6;:12;73688:4;73681:12;;;;;;;;;;;;;;;;73673:20;;73594:107;;;:::o;77654:215::-;77733:16;77741:7;77733;:16::i;:::-;77717:32;;:12;:10;:12::i;:::-;:32;;;77709:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;77832:4;77805:15;:24;77821:7;77805:24;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;77847:14;77853:7;77847:5;:14::i;:::-;77654:215;:::o;65563:227::-;65647:45;65655:6;:12;65662:4;65655:12;;;;;;;;;;;:22;;;65679:12;:10;:12::i;:::-;65647:7;:45::i;:::-;65639:105;;;;;;;;;;;;:::i;:::-;;;;;;;;;65757:25;65768:4;65774:7;65757:10;:25::i;:::-;65563:227;;:::o;49846:154::-;49935:7;49962:30;49986:5;49962:13;:20;49976:5;49962:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;49955:37;;49846:154;;;;:::o;70398:163::-;70441:7;70461:10;70512:9;70506:15;;70551:2;70544:9;;;70398:163;:::o;66772:209::-;66870:12;:10;:12::i;:::-;66859:23;;:7;:23;;;66851:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;66947:26;66959:4;66965:7;66947:11;:26::i;:::-;66772:209;;:::o;80931:212::-;62611:4;80988:18;;68722:27;68730:4;68736:12;:10;:12::i;:::-;68722:7;:27::i;:::-;68764:10;68700:85;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;81028:15:::1;:24;81044:7;81028:24;;;;;;;;;;;;;;;;;;;;;81027:25;81019:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;81115:20;81121:4;81127:7;81115:5;:20::i;:::-;80931:212:::0;;;:::o;52288:151::-;52392:39;52409:4;52415:2;52419:7;52392:39;;;;;;;;;;;;:16;:39::i;:::-;52288:151;;;:::o;50356:164::-;50423:7;50444:15;50465:22;50481:5;50465:12;:15;;:22;;;;:::i;:::-;50443:44;;;50505:7;50498:14;;;50356:164;;;:::o;48075:177::-;48147:7;48174:70;48191:7;48174:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;48167:77;;48075:177;;;:::o;49665:97::-;49713:13;49746:8;49739:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49665:97;:::o;47790:223::-;47862:7;47907:1;47890:19;;:5;:19;;;;47882:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;47976:29;:13;:20;47990:5;47976:20;;;;;;;;;;;;;;;:27;:29::i;:::-;47969:36;;47790:223;;;:::o;64860:138::-;64933:7;64960:30;64984:5;64960:6;:12;64967:4;64960:12;;;;;;;;;;;:20;;:23;;:30;;;;:::i;:::-;64953:37;;64860:138;;;;:::o;63821:139::-;63890:4;63914:38;63944:7;63914:6;:12;63921:4;63914:12;;;;;;;;;;;:20;;:29;;:38;;;;:::i;:::-;63907:45;;63821:139;;;;:::o;75266:40::-;75304:2;75266:40;:::o;48488:104::-;48544:13;48577:7;48570:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48488:104;:::o;78131:811::-;78205:14;78222:8;;:15;;78205:32;;75304:2;78256:6;:21;;78248:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;78426:9;78421:306;78441:6;78437:1;:10;78421:306;;;78471:15;78489:8;;78498:1;78489:11;;;;;;;;;;;;;;;;;;;;;78471:29;;78541:16;78549:7;78541;:16::i;:::-;78525:32;;:12;:10;:12::i;:::-;:32;;;78628:7;78566:70;;;;;;;;:::i;:::-;;;;;;;;;;;;;78517:121;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;78680:4;78653:15;:24;78669:7;78653:24;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;78699:14;78705:7;78699:5;:14::i;:::-;78421:306;78449:3;;;;;:::i;:::-;;;;78421:306;;;;78909:12;:10;:12::i;:::-;78894:38;;;78923:8;;78894:38;;;;;;;:::i;:::-;;;;;;;;78131:811;;;:::o;62566:49::-;62611:4;62566:49;;;:::o;51323:295::-;51438:12;:10;:12::i;:::-;51426:24;;:8;:24;;;;51418:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;51538:8;51493:18;:32;51512:12;:10;:12::i;:::-;51493:32;;;;;;;;;;;;;;;:42;51526:8;51493:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;51591:8;51562:48;;51577:12;:10;:12::i;:::-;51562:48;;;51601:8;51562:48;;;;;;:::i;:::-;;;;;;;;51323:295;;:::o;75039:68::-;75080:27;75039:68;:::o;79326:416::-;79419:16;79427:7;79419;:16::i;:::-;79403:32;;:12;:10;:12::i;:::-;:32;;;79395:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;79518:4;79491:15;:24;79507:7;79491:24;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;79662:7;79658:1;79611:94;;79632:16;79640:7;79632;:16::i;:::-;79611:94;;;79671:4;:24;;;79696:7;79671:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79611:94;;;;;;:::i;:::-;;;;;;;;79718:14;79724:7;79718:5;:14::i;:::-;79326:416;:::o;52510:285::-;52642:41;52661:12;:10;:12::i;:::-;52675:7;52642:18;:41::i;:::-;52634:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;52748:39;52762:4;52768:2;52772:7;52781:5;52748:13;:39::i;:::-;52510:285;;;;:::o;48663:763::-;48736:13;48770:16;48778:7;48770;:16::i;:::-;48762:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;48851:23;48877:10;:19;48888:7;48877:19;;;;;;;;;;;48851:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48998:1;48978:8;48972:22;;;;;:::i;:::-;;;:27;48968:76;;;49023:9;49016:16;;;;;48968:76;49174:1;49154:9;49148:23;:27;49144:112;;;49223:8;49233:9;49206:37;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49192:52;;;;;49144:112;49388:8;49398:18;:7;:16;:18::i;:::-;49371:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49357:61;;;48663:763;;;;:::o;64134:127::-;64197:7;64224:29;:6;:12;64231:4;64224:12;;;;;;;;;;;:20;;:27;:29::i;:::-;64217:36;;64134:127;;;:::o;76592:701::-;75080:27;68722;68730:4;68736:12;:10;:12::i;:::-;68722:7;:27::i;:::-;68764:10;68700:85;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;76786:2:::1;76764:11;;:18;;:24;76760:524;;;76805:15;76834:11;;76823:34;;;;;;;:::i;:::-;76805:52;;76899:5;76872:15;:24;76888:7;76872:24;;;;;;;;;;;;:32;;;;;;;;;;;;;;;;;;76919:20;76925:4;76931:7;76919:5;:20::i;:::-;76760:524;;;;77000:25;77039:11;;77028:36;;;;;;;:::i;:::-;77000:64;;77079:14;77096:8;:15;77079:32;;77131:9;77126:147;77146:6;77142:1;:10;77126:147;;;77209:5;77178:15;:28;77194:8;77203:1;77194:11;;;;;;;;;;;;;;;;;;;;;;77178:28;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;77233:24;77239:4;77245:8;77254:1;77245:11;;;;;;;;;;;;;;;;;;;;;;77233:5;:24::i;:::-;77154:3;;;;;:::i;:::-;;;;77126:147;;;;76760:524;;;76592:701:::0;;;;:::o;66035:230::-;66120:45;66128:6;:12;66135:4;66128:12;;;;;;;;;;;:22;;;66152:12;:10;:12::i;:::-;66120:7;:45::i;:::-;66112:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;66231:26;66243:4;66249:7;66231:11;:26::i;:::-;66035:230;;:::o;51689:156::-;51778:4;51802:18;:25;51821:5;51802:25;;;;;;;;;;;;;;;:35;51828:8;51802:35;;;;;;;;;;;;;;;;;;;;;;;;;51795:42;;51689:156;;;;:::o;30821:152::-;30891:4;30915:50;30920:3;:10;;30956:5;30940:23;;30932:32;;30915:4;:50::i;:::-;30908:57;;30821:152;;;;:::o;74240:650::-;74311:22;74377:4;74355:27;;:10;:27;;;74351:508;;;74399:18;74420:8;;74399:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74443:13;74459:8;;:15;;74443:31;;74711:42;74681:5;74674;74670:17;74664:24;74638:134;74628:144;;74498:289;;;;;74836:10;74819:28;;74351:508;74240:650;:::o;54261:119::-;54318:4;54342:30;54364:7;54342:12;:21;;:30;;;;:::i;:::-;54335:37;;54261:119;;;:::o;75904:186::-;76011:22;76058:24;:22;:24::i;:::-;76051:31;;75904:186;:::o;60088:158::-;60181:2;60154:15;:24;60170:7;60154:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;60230:7;60226:2;60199:39;;60208:16;60216:7;60208;:16::i;:::-;60199:39;;;;;;;;;;;;60088:158;;:::o;73709:486::-;73887:4;73930:1;73912:20;;:6;:20;;;;73904:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;74028:159;74056:47;74075:27;74095:6;74075:19;:27::i;:::-;74056:18;:47::i;:::-;74122:4;74145;74168;74028:159;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74005:182;;:6;:182;;;73985:202;;73709:486;;;;;;;:::o;12497:181::-;12555:7;12575:9;12591:1;12587;:5;;;;:::i;:::-;12575:17;;12616:1;12611;:6;;12603:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;12669:1;12662:8;;;12497:181;;;;:::o;41234:123::-;41303:7;41330:19;41338:3;:10;;41330:7;:19::i;:::-;41323:26;;41234:123;;;:::o;949:127::-;1056:1;1038:7;:14;;;:19;;;;;;;;;;;949:127;:::o;827:114::-;892:7;919;:14;;;912:21;;827:114;;;:::o;56146:404::-;56240:1;56226:16;;:2;:16;;;;56218:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;56299:16;56307:7;56299;:16::i;:::-;56298:17;56290:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;56361:45;56390:1;56394:2;56398:7;56361:20;:45::i;:::-;56419:30;56441:7;56419:13;:17;56433:2;56419:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;56462:29;56479:7;56488:2;56462:12;:16;;:29;;;;;:::i;:::-;;56534:7;56530:2;56509:33;;56526:1;56509:33;;;;;;;;;;;;56146:404;;:::o;58366:215::-;58466:16;58474:7;58466;:16::i;:::-;58458:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;58564:9;58542:10;:19;58553:7;58542:19;;;;;;;;;;;:31;;;;;;;;;;;;:::i;:::-;;58366:215;;:::o;54547:333::-;54632:4;54657:16;54665:7;54657;:16::i;:::-;54649:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;54733:13;54749:16;54757:7;54749;:16::i;:::-;54733:32;;54795:5;54784:16;;:7;:16;;;:51;;;;54828:7;54804:31;;:20;54816:7;54804:11;:20::i;:::-;:31;;;54784:51;:87;;;;54839:32;54856:5;54863:7;54839:16;:32::i;:::-;54784:87;54776:96;;;54547:333;;;;:::o;57636:574::-;57754:4;57734:24;;:16;57742:7;57734;:16::i;:::-;:24;;;57726:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;57837:1;57823:16;;:2;:16;;;;57815:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;57893:39;57914:4;57920:2;57924:7;57893:20;:39::i;:::-;57997:29;58014:1;58018:7;57997:8;:29::i;:::-;58039:35;58066:7;58039:13;:19;58053:4;58039:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;58085:30;58107:7;58085:13;:17;58099:2;58085:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;58128:29;58145:7;58154:2;58128:12;:16;;:29;;;;;:::i;:::-;;58194:7;58190:2;58175:27;;58184:4;58175:27;;;;;;;;;;;;57636:574;;;:::o;56779:520::-;56839:13;56855:16;56863:7;56855;:16::i;:::-;56839:32;;56884:48;56905:5;56920:1;56924:7;56884:20;:48::i;:::-;56973:29;56990:1;56994:7;56973:8;:29::i;:::-;57092:1;57061:10;:19;57072:7;57061:19;;;;;;;;;;;57055:33;;;;;:::i;:::-;;;:38;57051:97;;57117:10;:19;57128:7;57117:19;;;;;;;;;;;;57110:26;;;;:::i;:::-;57051:97;57160:36;57188:7;57160:13;:20;57174:5;57160:20;;;;;;;;;;;;;;;:27;;:36;;;;:::i;:::-;;57209:28;57229:7;57209:12;:19;;:28;;;;:::i;:::-;;57283:7;57279:1;57255:36;;57264:5;57255:36;;;;;;;;;;;;56779:520;;:::o;68015:188::-;68089:33;68114:7;68089:6;:12;68096:4;68089:12;;;;;;;;;;;:20;;:24;;:33;;;;:::i;:::-;68085:111;;;68171:12;:10;:12::i;:::-;68144:40;;68162:7;68144:40;;68156:4;68144:40;;;;;;;;;;68085:111;68015:188;;:::o;34569:137::-;34640:7;34675:22;34679:3;:10;;34691:5;34675:3;:22::i;:::-;34667:31;;34660:38;;34569:137;;;;:::o;68211:192::-;68286:36;68314:7;68286:6;:12;68293:4;68286:12;;;;;;;;;;;:20;;:27;;:36;;;;:::i;:::-;68282:114;;;68371:12;:10;:12::i;:::-;68344:40;;68362:7;68344:40;;68356:4;68344:40;;;;;;;;;;68282:114;68211:192;;:::o;41705:236::-;41785:7;41794;41815:11;41828:13;41845:22;41849:3;:10;;41861:5;41845:3;:22::i;:::-;41814:53;;;;41894:3;41886:12;;41924:5;41916:14;;41878:55;;;;;;41705:236;;;;;:::o;42991:247::-;43132:7;43183:44;43188:3;:10;;43208:3;43200:12;;43214;43183:4;:44::i;:::-;43175:53;;43152:78;;42991:247;;;;;:::o;34101:114::-;34161:7;34188:19;34196:3;:10;;34188:7;:19::i;:::-;34181:26;;34101:114;;;:::o;32117:158::-;32191:7;32242:22;32246:3;:10;;32258:5;32242:3;:22::i;:::-;32234:31;;32211:56;;32117:158;;;;:::o;31393:167::-;31473:4;31497:55;31507:3;:10;;31543:5;31527:23;;31519:32;;31497:9;:55::i;:::-;31490:62;;31393:167;;;;:::o;53676:272::-;53790:28;53800:4;53806:2;53810:7;53790:9;:28::i;:::-;53837:48;53860:4;53866:2;53870:7;53879:5;53837:22;:48::i;:::-;53829:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;53676:272;;;;:::o;43396:746::-;43452:13;43682:1;43673:5;:10;43669:53;;;43700:10;;;;;;;;;;;;;;;;;;;;;43669:53;43732:12;43747:5;43732:20;;43763:14;43788:78;43803:1;43795:4;:9;43788:78;;43821:8;;;;;:::i;:::-;;;;43852:2;43844:10;;;;;:::i;:::-;;;43788:78;;;43876:19;43908:6;43898:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43876:39;;43926:13;43951:1;43942:6;:10;;;;:::i;:::-;43926:26;;43970:5;43963:12;;43986:117;44001:1;43993:4;:9;43986:117;;44062:2;44055:4;:9;;;;:::i;:::-;44050:2;:14;;;;:::i;:::-;44037:29;;44019:6;44026:7;;;;;:::i;:::-;;;44019:15;;;;;;;;;;;;;;;;;;;:47;;;;;;;;;;;44089:2;44081:10;;;;;:::i;:::-;;;43986:117;;;44127:6;44113:21;;;;;;43396:746;;;;:::o;31646:117::-;31709:7;31736:19;31744:3;:10;;31736:7;:19::i;:::-;31729:26;;31646:117;;;:::o;24736:414::-;24799:4;24821:21;24831:3;24836:5;24821:9;:21::i;:::-;24816:327;;24859:3;:11;;24876:5;24859:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25042:3;:11;;:18;;;;25020:3;:12;;:19;25033:5;25020:19;;;;;;;;;;;:40;;;;25082:4;25075:11;;;;24816:327;25126:5;25119:12;;24736:414;;;;;:::o;40995:151::-;41079:4;41103:35;41113:3;:10;;41133:3;41125:12;;41103:9;:35::i;:::-;41096:42;;40995:151;;;;:::o;73176:410::-;73286:7;71353:100;;;;;;;;;;;;;;;;;71333:127;;;;;;73440:6;:12;;;73475:6;:11;;;73519:6;:24;;;73509:35;;;;;;73359:204;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;73331:247;;;;;;73311:267;;73176:410;;;:::o;70930:258::-;71029:7;71131:20;:18;:20::i;:::-;71153:11;71102:63;;;;;;;;;:::i;:::-;;;;;;;;;;;;;71074:106;;;;;;71054:126;;70930:258;;;:::o;38005:109::-;38061:7;38088:18;:3;:9;;:16;:18::i;:::-;38081:25;;38005:109;;;:::o;60859:93::-;;;;:::o;33339:131::-;33406:4;33430:32;33435:3;:10;;33455:5;33447:14;;33430:4;:32::i;:::-;33423:39;;33339:131;;;;:::o;40384:219::-;40507:4;40531:64;40536:3;:10;;40556:3;40548:12;;40586:5;40570:23;;40562:32;;40531:4;:64::i;:::-;40524:71;;40384:219;;;;;:::o;33646:137::-;33716:4;33740:35;33748:3;:10;;33768:5;33760:14;;33740:7;:35::i;:::-;33733:42;;33646:137;;;;:::o;40769:142::-;40846:4;40870:33;40878:3;:10;;40898:3;40890:12;;40870:7;:33::i;:::-;40863:40;;40769:142;;;;:::o;27510:120::-;27577:7;27604:3;:11;;27616:5;27604:18;;;;;;;;;;;;;;;;;;;;;;;;27597:25;;27510:120;;;;:::o;31149:158::-;31222:4;31246:53;31254:3;:10;;31290:5;31274:23;;31266:32;;31246:7;:53::i;:::-;31239:60;;31149:158;;;;:::o;38479:178::-;38546:7;38555;38575:11;38589:19;38602:5;38589:3;:9;;:12;;:19;;;;:::i;:::-;38575:33;;38627:3;38632;:11;;:16;38644:3;38632:16;;;;;;;;;;;;38619:30;;;;;38479:178;;;;;:::o;39782:278::-;39910:7;39930:13;39946:3;:11;;:16;39958:3;39946:16;;;;;;;;;;;;39930:32;;39990:1;39981:10;;:5;:10;;:33;;;;39995:19;40005:3;40010;39995:9;:19::i;:::-;39981:33;40016:12;39973:56;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;40047:5;40040:12;;;39782:278;;;;;:::o;27047:109::-;27103:7;27130:3;:11;;:18;;;;27123:25;;27047:109;;;:::o;26832:129::-;26905:4;26952:1;26929:3;:12;;:19;26942:5;26929:19;;;;;;;;;;;;:24;;26922:31;;26832:129;;;;:::o;59476:604::-;59597:4;59624:15;:2;:13;;;:15::i;:::-;59619:60;;59663:4;59656:11;;;;59619:60;59689:23;59715:252;59768:45;;;59828:12;:10;:12::i;:::-;59855:4;59874:7;59896:5;59731:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59715:252;;;;;;;;;;;;;;;;;:2;:15;;;;:252;;;;;:::i;:::-;59689:278;;59978:13;60005:10;59994:32;;;;;;;;;;;;:::i;:::-;59978:48;;44896:10;60055:16;;60045:26;;;:6;:26;;;;60037:35;;;;59476:604;;;;;;;:::o;37784:126::-;37855:4;37879:23;37898:3;37879;:9;;:18;;:23;;;;:::i;:::-;37872:30;;37784:126;;;;:::o;29289:117::-;29352:7;29379:19;29387:3;:10;;29379:7;:19::i;:::-;29372:26;;29289:117;;;:::o;37179:195::-;37289:4;37325:5;37306:3;:11;;:16;37318:3;37306:16;;;;;;;;;;;:24;;;;37348:18;37362:3;37348;:9;;:13;;:18;;;;:::i;:::-;37341:25;;37179:195;;;;;:::o;25326:1420::-;25392:4;25510:18;25531:3;:12;;:19;25544:5;25531:19;;;;;;;;;;;;25510:40;;25581:1;25567:10;:15;25563:1176;;25942:21;25979:1;25966:10;:14;;;;:::i;:::-;25942:38;;25995:17;26036:1;26015:3;:11;;:18;;;;:22;;;;:::i;:::-;25995:42;;26071:13;26058:9;:26;26054:405;;26105:17;26125:3;:11;;26137:9;26125:22;;;;;;;;;;;;;;;;;;;;;;;;26105:42;;26279:9;26250:3;:11;;26262:13;26250:26;;;;;;;;;;;;;;;;;;;;;;;:38;;;;26390:10;26364:3;:12;;:23;26377:9;26364:23;;;;;;;;;;;:36;;;;26054:405;;26540:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26635:3;:12;;:19;26648:5;26635:19;;;;;;;;;;;26628:26;;;26678:4;26671:11;;;;;;;25563:1176;26722:5;26715:12;;;25326:1420;;;;;:::o;37549:151::-;37613:4;37637:3;:11;;:16;37649:3;37637:16;;;;;;;;;;;37630:23;;;37671:21;37688:3;37671;:9;;:16;;:21;;;;:::i;:::-;37664:28;;37549:151;;;;:::o;29760:131::-;29834:7;29861:22;29865:3;:10;;29877:5;29861:3;:22::i;:::-;29854:29;;29760:131;;;;:::o;17638:619::-;17698:4;17960:16;17987:19;18009:66;17987:88;;;;18178:7;18166:20;18154:32;;18218:11;18206:8;:23;;:42;;;;;18245:3;18233:15;;:8;:15;;18206:42;18198:51;;;;17638:619;;;:::o;20753:196::-;20856:12;20888:53;20911:6;20919:4;20925:1;20928:12;20888:22;:53::i;:::-;20881:60;;20753:196;;;;;:::o;29063:140::-;29143:4;29167:28;29177:3;:10;;29189:5;29167:9;:28::i;:::-;29160:35;;29063:140;;;;:::o;28545:125::-;28615:4;28639:23;28644:3;:10;;28656:5;28639:4;:23::i;:::-;28632:30;;28545:125;;;;:::o;28846:131::-;28919:4;28943:26;28951:3;:10;;28963:5;28943:7;:26::i;:::-;28936:33;;28846:131;;;;:::o;22130:979::-;22260:12;22293:18;22304:6;22293:10;:18::i;:::-;22285:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;22419:12;22433:23;22460:6;:11;;22480:8;22491:4;22460:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22418:78;;;;22511:7;22507:595;;;22542:10;22535:17;;;;;;22507:595;22676:1;22656:10;:17;:21;22652:439;;;22919:10;22913:17;22980:15;22967:10;22963:2;22959:19;22952:44;22867:148;23062:12;23055:20;;;;;;;;;;;:::i;:::-;;;;;;;;22130:979;;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;24:655:1:-;120:5;145:81;161:64;218:6;161:64;:::i;:::-;145:81;:::i;:::-;136:90;;246:5;275:6;268:5;261:21;309:4;302:5;298:16;291:23;;335:6;385:3;377:4;369:6;365:17;360:3;356:27;353:36;350:2;;;414:1;411;404:12;350:2;450:1;435:238;460:6;457:1;454:13;435:238;;;528:3;557:37;590:3;578:10;557:37;:::i;:::-;552:3;545:50;624:4;619:3;615:14;608:21;;658:4;653:3;649:14;642:21;;495:178;482:1;479;475:9;470:14;;435:238;;;439:14;126:553;;;;;;;:::o;685:343::-;762:5;787:65;803:48;844:6;803:48;:::i;:::-;787:65;:::i;:::-;778:74;;875:6;868:5;861:21;913:4;906:5;902:16;951:3;942:6;937:3;933:16;930:25;927:2;;;968:1;965;958:12;927:2;981:41;1015:6;1010:3;1005;981:41;:::i;:::-;768:260;;;;;;:::o;1034:352::-;1122:5;1147:65;1163:48;1204:6;1163:48;:::i;:::-;1147:65;:::i;:::-;1138:74;;1235:6;1228:5;1221:21;1273:4;1266:5;1262:16;1311:3;1302:6;1297:3;1293:16;1290:25;1287:2;;;1328:1;1325;1318:12;1287:2;1341:39;1373:6;1368:3;1363;1341:39;:::i;:::-;1128:258;;;;;;:::o;1392:345::-;1470:5;1495:66;1511:49;1553:6;1511:49;:::i;:::-;1495:66;:::i;:::-;1486:75;;1584:6;1577:5;1570:21;1622:4;1615:5;1611:16;1660:3;1651:6;1646:3;1642:16;1639:25;1636:2;;;1677:1;1674;1667:12;1636:2;1690:41;1724:6;1719:3;1714;1690:41;:::i;:::-;1476:261;;;;;;:::o;1743:139::-;1789:5;1827:6;1814:20;1805:29;;1843:33;1870:5;1843:33;:::i;:::-;1795:87;;;;:::o;1905:367::-;1978:8;1988:6;2038:3;2031:4;2023:6;2019:17;2015:27;2005:2;;2056:1;2053;2046:12;2005:2;2092:6;2079:20;2069:30;;2122:18;2114:6;2111:30;2108:2;;;2154:1;2151;2144:12;2108:2;2191:4;2183:6;2179:17;2167:29;;2245:3;2237:4;2229:6;2225:17;2215:8;2211:32;2208:41;2205:2;;;2262:1;2259;2252:12;2205:2;1995:277;;;;;:::o;2295:303::-;2366:5;2415:3;2408:4;2400:6;2396:17;2392:27;2382:2;;2433:1;2430;2423:12;2382:2;2473:6;2460:20;2498:94;2588:3;2580:6;2573:4;2565:6;2561:17;2498:94;:::i;:::-;2489:103;;2372:226;;;;;:::o;2604:133::-;2647:5;2685:6;2672:20;2663:29;;2701:30;2725:5;2701:30;:::i;:::-;2653:84;;;;:::o;2743:139::-;2789:5;2827:6;2814:20;2805:29;;2843:33;2870:5;2843:33;:::i;:::-;2795:87;;;;:::o;2888:137::-;2933:5;2971:6;2958:20;2949:29;;2987:32;3013:5;2987:32;:::i;:::-;2939:86;;;;:::o;3031:141::-;3087:5;3118:6;3112:13;3103:22;;3134:32;3160:5;3134:32;:::i;:::-;3093:79;;;;:::o;3191:351::-;3248:8;3258:6;3308:3;3301:4;3293:6;3289:17;3285:27;3275:2;;3326:1;3323;3316:12;3275:2;3362:6;3349:20;3339:30;;3392:18;3384:6;3381:30;3378:2;;;3424:1;3421;3414:12;3378:2;3461:4;3453:6;3449:17;3437:29;;3515:3;3507:4;3499:6;3495:17;3485:8;3481:32;3478:41;3475:2;;;3532:1;3529;3522:12;3475:2;3265:277;;;;;:::o;3561:271::-;3616:5;3665:3;3658:4;3650:6;3646:17;3642:27;3632:2;;3683:1;3680;3673:12;3632:2;3723:6;3710:20;3748:78;3822:3;3814:6;3807:4;3799:6;3795:17;3748:78;:::i;:::-;3739:87;;3622:210;;;;;:::o;3851:286::-;3917:5;3966:3;3959:4;3951:6;3947:17;3943:27;3933:2;;3984:1;3981;3974:12;3933:2;4017:6;4011:13;4042:89;4127:3;4119:6;4112:4;4104:6;4100:17;4042:89;:::i;:::-;4033:98;;3923:214;;;;;:::o;4157:273::-;4213:5;4262:3;4255:4;4247:6;4243:17;4239:27;4229:2;;4280:1;4277;4270:12;4229:2;4320:6;4307:20;4345:79;4420:3;4412:6;4405:4;4397:6;4393:17;4345:79;:::i;:::-;4336:88;;4219:211;;;;;:::o;4436:139::-;4482:5;4520:6;4507:20;4498:29;;4536:33;4563:5;4536:33;:::i;:::-;4488:87;;;;:::o;4581:135::-;4625:5;4663:6;4650:20;4641:29;;4679:31;4704:5;4679:31;:::i;:::-;4631:85;;;;:::o;4722:262::-;4781:6;4830:2;4818:9;4809:7;4805:23;4801:32;4798:2;;;4846:1;4843;4836:12;4798:2;4889:1;4914:53;4959:7;4950:6;4939:9;4935:22;4914:53;:::i;:::-;4904:63;;4860:117;4788:196;;;;:::o;4990:407::-;5058:6;5066;5115:2;5103:9;5094:7;5090:23;5086:32;5083:2;;;5131:1;5128;5121:12;5083:2;5174:1;5199:53;5244:7;5235:6;5224:9;5220:22;5199:53;:::i;:::-;5189:63;;5145:117;5301:2;5327:53;5372:7;5363:6;5352:9;5348:22;5327:53;:::i;:::-;5317:63;;5272:118;5073:324;;;;;:::o;5403:552::-;5480:6;5488;5496;5545:2;5533:9;5524:7;5520:23;5516:32;5513:2;;;5561:1;5558;5551:12;5513:2;5604:1;5629:53;5674:7;5665:6;5654:9;5650:22;5629:53;:::i;:::-;5619:63;;5575:117;5731:2;5757:53;5802:7;5793:6;5782:9;5778:22;5757:53;:::i;:::-;5747:63;;5702:118;5859:2;5885:53;5930:7;5921:6;5910:9;5906:22;5885:53;:::i;:::-;5875:63;;5830:118;5503:452;;;;;:::o;5961:809::-;6056:6;6064;6072;6080;6129:3;6117:9;6108:7;6104:23;6100:33;6097:2;;;6146:1;6143;6136:12;6097:2;6189:1;6214:53;6259:7;6250:6;6239:9;6235:22;6214:53;:::i;:::-;6204:63;;6160:117;6316:2;6342:53;6387:7;6378:6;6367:9;6363:22;6342:53;:::i;:::-;6332:63;;6287:118;6444:2;6470:53;6515:7;6506:6;6495:9;6491:22;6470:53;:::i;:::-;6460:63;;6415:118;6600:2;6589:9;6585:18;6572:32;6631:18;6623:6;6620:30;6617:2;;;6663:1;6660;6653:12;6617:2;6691:62;6745:7;6736:6;6725:9;6721:22;6691:62;:::i;:::-;6681:72;;6543:220;6087:683;;;;;;;:::o;6776:401::-;6841:6;6849;6898:2;6886:9;6877:7;6873:23;6869:32;6866:2;;;6914:1;6911;6904:12;6866:2;6957:1;6982:53;7027:7;7018:6;7007:9;7003:22;6982:53;:::i;:::-;6972:63;;6928:117;7084:2;7110:50;7152:7;7143:6;7132:9;7128:22;7110:50;:::i;:::-;7100:60;;7055:115;6856:321;;;;;:::o;7183:538::-;7262:6;7270;7278;7327:2;7315:9;7306:7;7302:23;7298:32;7295:2;;;7343:1;7340;7333:12;7295:2;7386:1;7411:53;7456:7;7447:6;7436:9;7432:22;7411:53;:::i;:::-;7401:63;;7357:117;7541:2;7530:9;7526:18;7513:32;7572:18;7564:6;7561:30;7558:2;;;7604:1;7601;7594:12;7558:2;7640:64;7696:7;7687:6;7676:9;7672:22;7640:64;:::i;:::-;7622:82;;;;7484:230;7285:436;;;;;:::o;7727:951::-;7829:6;7837;7845;7853;7861;7910:3;7898:9;7889:7;7885:23;7881:33;7878:2;;;7927:1;7924;7917:12;7878:2;7970:1;7995:53;8040:7;8031:6;8020:9;8016:22;7995:53;:::i;:::-;7985:63;;7941:117;8125:2;8114:9;8110:18;8097:32;8156:18;8148:6;8145:30;8142:2;;;8188:1;8185;8178:12;8142:2;8216:62;8270:7;8261:6;8250:9;8246:22;8216:62;:::i;:::-;8206:72;;8068:220;8327:2;8353:53;8398:7;8389:6;8378:9;8374:22;8353:53;:::i;:::-;8343:63;;8298:118;8455:2;8481:53;8526:7;8517:6;8506:9;8502:22;8481:53;:::i;:::-;8471:63;;8426:118;8583:3;8610:51;8653:7;8644:6;8633:9;8629:22;8610:51;:::i;:::-;8600:61;;8554:117;7868:810;;;;;;;;:::o;8684:520::-;8762:6;8770;8819:2;8807:9;8798:7;8794:23;8790:32;8787:2;;;8835:1;8832;8825:12;8787:2;8878:1;8903:53;8948:7;8939:6;8928:9;8924:22;8903:53;:::i;:::-;8893:63;;8849:117;9033:2;9022:9;9018:18;9005:32;9064:18;9056:6;9053:30;9050:2;;;9096:1;9093;9086:12;9050:2;9124:63;9179:7;9170:6;9159:9;9155:22;9124:63;:::i;:::-;9114:73;;8976:221;8777:427;;;;;:::o;9210:407::-;9278:6;9286;9335:2;9323:9;9314:7;9310:23;9306:32;9303:2;;;9351:1;9348;9341:12;9303:2;9394:1;9419:53;9464:7;9455:6;9444:9;9440:22;9419:53;:::i;:::-;9409:63;;9365:117;9521:2;9547:53;9592:7;9583:6;9572:9;9568:22;9547:53;:::i;:::-;9537:63;;9492:118;9293:324;;;;;:::o;9623:425::-;9709:6;9717;9766:2;9754:9;9745:7;9741:23;9737:32;9734:2;;;9782:1;9779;9772:12;9734:2;9853:1;9842:9;9838:17;9825:31;9883:18;9875:6;9872:30;9869:2;;;9915:1;9912;9905:12;9869:2;9951:80;10023:7;10014:6;10003:9;9999:22;9951:80;:::i;:::-;9933:98;;;;9796:245;9724:324;;;;;:::o;10054:405::-;10138:6;10187:2;10175:9;10166:7;10162:23;10158:32;10155:2;;;10203:1;10200;10193:12;10155:2;10274:1;10263:9;10259:17;10246:31;10304:18;10296:6;10293:30;10290:2;;;10336:1;10333;10326:12;10290:2;10364:78;10434:7;10425:6;10414:9;10410:22;10364:78;:::i;:::-;10354:88;;10217:235;10145:314;;;;:::o;10465:262::-;10524:6;10573:2;10561:9;10552:7;10548:23;10544:32;10541:2;;;10589:1;10586;10579:12;10541:2;10632:1;10657:53;10702:7;10693:6;10682:9;10678:22;10657:53;:::i;:::-;10647:63;;10603:117;10531:196;;;;:::o;10733:407::-;10801:6;10809;10858:2;10846:9;10837:7;10833:23;10829:32;10826:2;;;10874:1;10871;10864:12;10826:2;10917:1;10942:53;10987:7;10978:6;10967:9;10963:22;10942:53;:::i;:::-;10932:63;;10888:117;11044:2;11070:53;11115:7;11106:6;11095:9;11091:22;11070:53;:::i;:::-;11060:63;;11015:118;10816:324;;;;;:::o;11146:407::-;11214:6;11222;11271:2;11259:9;11250:7;11246:23;11242:32;11239:2;;;11287:1;11284;11277:12;11239:2;11330:1;11355:53;11400:7;11391:6;11380:9;11376:22;11355:53;:::i;:::-;11345:63;;11301:117;11457:2;11483:53;11528:7;11519:6;11508:9;11504:22;11483:53;:::i;:::-;11473:63;;11428:118;11229:324;;;;;:::o;11559:260::-;11617:6;11666:2;11654:9;11645:7;11641:23;11637:32;11634:2;;;11682:1;11679;11672:12;11634:2;11725:1;11750:52;11794:7;11785:6;11774:9;11770:22;11750:52;:::i;:::-;11740:62;;11696:116;11624:195;;;;:::o;11825:282::-;11894:6;11943:2;11931:9;11922:7;11918:23;11914:32;11911:2;;;11959:1;11956;11949:12;11911:2;12002:1;12027:63;12082:7;12073:6;12062:9;12058:22;12027:63;:::i;:::-;12017:73;;11973:127;11901:206;;;;:::o;12113:388::-;12192:6;12241:2;12229:9;12220:7;12216:23;12212:32;12209:2;;;12257:1;12254;12247:12;12209:2;12321:1;12310:9;12306:17;12300:24;12351:18;12343:6;12340:30;12337:2;;;12383:1;12380;12373:12;12337:2;12411:73;12476:7;12467:6;12456:9;12452:22;12411:73;:::i;:::-;12401:83;;12271:223;12199:302;;;;:::o;12507:262::-;12566:6;12615:2;12603:9;12594:7;12590:23;12586:32;12583:2;;;12631:1;12628;12621:12;12583:2;12674:1;12699:53;12744:7;12735:6;12724:9;12720:22;12699:53;:::i;:::-;12689:63;;12645:117;12573:196;;;;:::o;12775:142::-;12878:32;12904:5;12878:32;:::i;:::-;12873:3;12866:45;12856:61;;:::o;12923:118::-;13010:24;13028:5;13010:24;:::i;:::-;13005:3;12998:37;12988:53;;:::o;13047:157::-;13152:45;13172:24;13190:5;13172:24;:::i;:::-;13152:45;:::i;:::-;13147:3;13140:58;13130:74;;:::o;13240:470::-;13368:3;13389:86;13468:6;13463:3;13389:86;:::i;:::-;13382:93;;13499:66;13491:6;13488:78;13485:2;;;13579:1;13576;13569:12;13485:2;13614:4;13606:6;13602:17;13592:27;;13629:43;13665:6;13660:3;13653:5;13629:43;:::i;:::-;13697:6;13692:3;13688:16;13681:23;;13372:338;;;;;:::o;13716:109::-;13797:21;13812:5;13797:21;:::i;:::-;13792:3;13785:34;13775:50;;:::o;13831:118::-;13918:24;13936:5;13918:24;:::i;:::-;13913:3;13906:37;13896:53;;:::o;13955:157::-;14060:45;14080:24;14098:5;14080:24;:::i;:::-;14060:45;:::i;:::-;14055:3;14048:58;14038:74;;:::o;14118:360::-;14204:3;14232:38;14264:5;14232:38;:::i;:::-;14286:70;14349:6;14344:3;14286:70;:::i;:::-;14279:77;;14365:52;14410:6;14405:3;14398:4;14391:5;14387:16;14365:52;:::i;:::-;14442:29;14464:6;14442:29;:::i;:::-;14437:3;14433:39;14426:46;;14208:270;;;;;:::o;14484:373::-;14588:3;14616:38;14648:5;14616:38;:::i;:::-;14670:88;14751:6;14746:3;14670:88;:::i;:::-;14663:95;;14767:52;14812:6;14807:3;14800:4;14793:5;14789:16;14767:52;:::i;:::-;14844:6;14839:3;14835:16;14828:23;;14592:265;;;;;:::o;14863:364::-;14951:3;14979:39;15012:5;14979:39;:::i;:::-;15034:71;15098:6;15093:3;15034:71;:::i;:::-;15027:78;;15114:52;15159:6;15154:3;15147:4;15140:5;15136:16;15114:52;:::i;:::-;15191:29;15213:6;15191:29;:::i;:::-;15186:3;15182:39;15175:46;;14955:272;;;;;:::o;15233:377::-;15339:3;15367:39;15400:5;15367:39;:::i;:::-;15422:89;15504:6;15499:3;15422:89;:::i;:::-;15415:96;;15520:52;15565:6;15560:3;15553:4;15546:5;15542:16;15520:52;:::i;:::-;15597:6;15592:3;15588:16;15581:23;;15343:267;;;;;:::o;15640:802::-;15725:3;15762:5;15756:12;15791:36;15817:9;15791:36;:::i;:::-;15843:71;15907:6;15902:3;15843:71;:::i;:::-;15836:78;;15945:1;15934:9;15930:17;15961:1;15956:135;;;;16105:1;16100:336;;;;15923:513;;15956:135;16040:4;16036:9;16025;16021:25;16016:3;16009:38;16076:4;16071:3;16067:14;16060:21;;15956:135;;16100:336;16167:38;16199:5;16167:38;:::i;:::-;16227:1;16241:154;16255:6;16252:1;16249:13;16241:154;;;16329:7;16323:14;16319:1;16314:3;16310:11;16303:35;16379:1;16370:7;16366:15;16355:26;;16277:4;16274:1;16270:12;16265:17;;16241:154;;;16424:1;16419:3;16415:11;16408:18;;16107:329;;15923:513;;15729:713;;;;;;:::o;16472:845::-;16575:3;16612:5;16606:12;16641:36;16667:9;16641:36;:::i;:::-;16693:89;16775:6;16770:3;16693:89;:::i;:::-;16686:96;;16813:1;16802:9;16798:17;16829:1;16824:137;;;;16975:1;16970:341;;;;16791:520;;16824:137;16908:4;16904:9;16893;16889:25;16884:3;16877:38;16944:6;16939:3;16935:16;16928:23;;16824:137;;16970:341;17037:38;17069:5;17037:38;:::i;:::-;17097:1;17111:154;17125:6;17122:1;17119:13;17111:154;;;17199:7;17193:14;17189:1;17184:3;17180:11;17173:35;17249:1;17240:7;17236:15;17225:26;;17147:4;17144:1;17140:12;17135:17;;17111:154;;;17294:6;17289:3;17285:16;17278:23;;16977:334;;16791:520;;16579:738;;;;;;:::o;17323:366::-;17465:3;17486:67;17550:2;17545:3;17486:67;:::i;:::-;17479:74;;17562:93;17651:3;17562:93;:::i;:::-;17680:2;17675:3;17671:12;17664:19;;17469:220;;;:::o;17695:366::-;17837:3;17858:67;17922:2;17917:3;17858:67;:::i;:::-;17851:74;;17934:93;18023:3;17934:93;:::i;:::-;18052:2;18047:3;18043:12;18036:19;;17841:220;;;:::o;18067:366::-;18209:3;18230:67;18294:2;18289:3;18230:67;:::i;:::-;18223:74;;18306:93;18395:3;18306:93;:::i;:::-;18424:2;18419:3;18415:12;18408:19;;18213:220;;;:::o;18439:366::-;18581:3;18602:67;18666:2;18661:3;18602:67;:::i;:::-;18595:74;;18678:93;18767:3;18678:93;:::i;:::-;18796:2;18791:3;18787:12;18780:19;;18585:220;;;:::o;18811:366::-;18953:3;18974:67;19038:2;19033:3;18974:67;:::i;:::-;18967:74;;19050:93;19139:3;19050:93;:::i;:::-;19168:2;19163:3;19159:12;19152:19;;18957:220;;;:::o;19183:400::-;19343:3;19364:84;19446:1;19441:3;19364:84;:::i;:::-;19357:91;;19457:93;19546:3;19457:93;:::i;:::-;19575:1;19570:3;19566:11;19559:18;;19347:236;;;:::o;19589:366::-;19731:3;19752:67;19816:2;19811:3;19752:67;:::i;:::-;19745:74;;19828:93;19917:3;19828:93;:::i;:::-;19946:2;19941:3;19937:12;19930:19;;19735:220;;;:::o;19961:402::-;20121:3;20142:85;20224:2;20219:3;20142:85;:::i;:::-;20135:92;;20236:93;20325:3;20236:93;:::i;:::-;20354:2;20349:3;20345:12;20338:19;;20125:238;;;:::o;20369:366::-;20511:3;20532:67;20596:2;20591:3;20532:67;:::i;:::-;20525:74;;20608:93;20697:3;20608:93;:::i;:::-;20726:2;20721:3;20717:12;20710:19;;20515:220;;;:::o;20741:366::-;20883:3;20904:67;20968:2;20963:3;20904:67;:::i;:::-;20897:74;;20980:93;21069:3;20980:93;:::i;:::-;21098:2;21093:3;21089:12;21082:19;;20887:220;;;:::o;21113:366::-;21255:3;21276:67;21340:2;21335:3;21276:67;:::i;:::-;21269:74;;21352:93;21441:3;21352:93;:::i;:::-;21470:2;21465:3;21461:12;21454:19;;21259:220;;;:::o;21485:366::-;21627:3;21648:67;21712:2;21707:3;21648:67;:::i;:::-;21641:74;;21724:93;21813:3;21724:93;:::i;:::-;21842:2;21837:3;21833:12;21826:19;;21631:220;;;:::o;21857:366::-;21999:3;22020:67;22084:2;22079:3;22020:67;:::i;:::-;22013:74;;22096:93;22185:3;22096:93;:::i;:::-;22214:2;22209:3;22205:12;22198:19;;22003:220;;;:::o;22229:366::-;22371:3;22392:67;22456:2;22451:3;22392:67;:::i;:::-;22385:74;;22468:93;22557:3;22468:93;:::i;:::-;22586:2;22581:3;22577:12;22570:19;;22375:220;;;:::o;22601:366::-;22743:3;22764:67;22828:2;22823:3;22764:67;:::i;:::-;22757:74;;22840:93;22929:3;22840:93;:::i;:::-;22958:2;22953:3;22949:12;22942:19;;22747:220;;;:::o;22973:366::-;23115:3;23136:67;23200:2;23195:3;23136:67;:::i;:::-;23129:74;;23212:93;23301:3;23212:93;:::i;:::-;23330:2;23325:3;23321:12;23314:19;;23119:220;;;:::o;23345:366::-;23487:3;23508:67;23572:2;23567:3;23508:67;:::i;:::-;23501:74;;23584:93;23673:3;23584:93;:::i;:::-;23702:2;23697:3;23693:12;23686:19;;23491:220;;;:::o;23717:366::-;23859:3;23880:67;23944:2;23939:3;23880:67;:::i;:::-;23873:74;;23956:93;24045:3;23956:93;:::i;:::-;24074:2;24069:3;24065:12;24058:19;;23863:220;;;:::o;24089:366::-;24231:3;24252:67;24316:2;24311:3;24252:67;:::i;:::-;24245:74;;24328:93;24417:3;24328:93;:::i;:::-;24446:2;24441:3;24437:12;24430:19;;24235:220;;;:::o;24461:366::-;24603:3;24624:67;24688:2;24683:3;24624:67;:::i;:::-;24617:74;;24700:93;24789:3;24700:93;:::i;:::-;24818:2;24813:3;24809:12;24802:19;;24607:220;;;:::o;24833:366::-;24975:3;24996:67;25060:2;25055:3;24996:67;:::i;:::-;24989:74;;25072:93;25161:3;25072:93;:::i;:::-;25190:2;25185:3;25181:12;25174:19;;24979:220;;;:::o;25205:366::-;25347:3;25368:67;25432:2;25427:3;25368:67;:::i;:::-;25361:74;;25444:93;25533:3;25444:93;:::i;:::-;25562:2;25557:3;25553:12;25546:19;;25351:220;;;:::o;25577:366::-;25719:3;25740:67;25804:2;25799:3;25740:67;:::i;:::-;25733:74;;25816:93;25905:3;25816:93;:::i;:::-;25934:2;25929:3;25925:12;25918:19;;25723:220;;;:::o;25949:366::-;26091:3;26112:67;26176:2;26171:3;26112:67;:::i;:::-;26105:74;;26188:93;26277:3;26188:93;:::i;:::-;26306:2;26301:3;26297:12;26290:19;;26095:220;;;:::o;26321:366::-;26463:3;26484:67;26548:2;26543:3;26484:67;:::i;:::-;26477:74;;26560:93;26649:3;26560:93;:::i;:::-;26678:2;26673:3;26669:12;26662:19;;26467:220;;;:::o;26693:366::-;26835:3;26856:67;26920:2;26915:3;26856:67;:::i;:::-;26849:74;;26932:93;27021:3;26932:93;:::i;:::-;27050:2;27045:3;27041:12;27034:19;;26839:220;;;:::o;27065:366::-;27207:3;27228:67;27292:2;27287:3;27228:67;:::i;:::-;27221:74;;27304:93;27393:3;27304:93;:::i;:::-;27422:2;27417:3;27413:12;27406:19;;27211:220;;;:::o;27437:118::-;27524:24;27542:5;27524:24;:::i;:::-;27519:3;27512:37;27502:53;;:::o;27561:157::-;27666:45;27686:24;27704:5;27686:24;:::i;:::-;27666:45;:::i;:::-;27661:3;27654:58;27644:74;;:::o;27724:112::-;27807:22;27823:5;27807:22;:::i;:::-;27802:3;27795:35;27785:51;;:::o;27842:271::-;27972:3;27994:93;28083:3;28074:6;27994:93;:::i;:::-;27987:100;;28104:3;28097:10;;27976:137;;;;:::o;28119:412::-;28277:3;28299:93;28388:3;28379:6;28299:93;:::i;:::-;28292:100;;28402:75;28473:3;28464:6;28402:75;:::i;:::-;28502:2;28497:3;28493:12;28486:19;;28522:3;28515:10;;28281:250;;;;;:::o;28537:429::-;28714:3;28736:92;28824:3;28815:6;28736:92;:::i;:::-;28729:99;;28845:95;28936:3;28927:6;28845:95;:::i;:::-;28838:102;;28957:3;28950:10;;28718:248;;;;;:::o;28972:663::-;29213:3;29235:148;29379:3;29235:148;:::i;:::-;29228:155;;29393:75;29464:3;29455:6;29393:75;:::i;:::-;29493:2;29488:3;29484:12;29477:19;;29506:75;29577:3;29568:6;29506:75;:::i;:::-;29606:2;29601:3;29597:12;29590:19;;29626:3;29619:10;;29217:418;;;;;:::o;29641:522::-;29854:3;29876:148;30020:3;29876:148;:::i;:::-;29869:155;;30034:75;30105:3;30096:6;30034:75;:::i;:::-;30134:2;30129:3;30125:12;30118:19;;30154:3;30147:10;;29858:305;;;;:::o;30169:222::-;30262:4;30300:2;30289:9;30285:18;30277:26;;30313:71;30381:1;30370:9;30366:17;30357:6;30313:71;:::i;:::-;30267:124;;;;:::o;30397:672::-;30608:4;30646:3;30635:9;30631:19;30623:27;;30660:87;30744:1;30733:9;30729:17;30720:6;30660:87;:::i;:::-;30757:72;30825:2;30814:9;30810:18;30801:6;30757:72;:::i;:::-;30839;30907:2;30896:9;30892:18;30883:6;30839:72;:::i;:::-;30958:9;30952:4;30948:20;30943:2;30932:9;30928:18;30921:48;30986:76;31057:4;31048:6;30986:76;:::i;:::-;30978:84;;30613:456;;;;;;;:::o;31075:561::-;31258:4;31296:2;31285:9;31281:18;31273:26;;31309:71;31377:1;31366:9;31362:17;31353:6;31309:71;:::i;:::-;31390:88;31474:2;31463:9;31459:18;31450:6;31390:88;:::i;:::-;31525:9;31519:4;31515:20;31510:2;31499:9;31495:18;31488:48;31553:76;31624:4;31615:6;31553:76;:::i;:::-;31545:84;;31263:373;;;;;;:::o;31642:393::-;31795:4;31833:2;31822:9;31818:18;31810:26;;31882:9;31876:4;31872:20;31868:1;31857:9;31853:17;31846:47;31910:118;32023:4;32014:6;32006;31910:118;:::i;:::-;31902:126;;31800:235;;;;;:::o;32041:210::-;32128:4;32166:2;32155:9;32151:18;32143:26;;32179:65;32241:1;32230:9;32226:17;32217:6;32179:65;:::i;:::-;32133:118;;;;:::o;32257:222::-;32350:4;32388:2;32377:9;32373:18;32365:26;;32401:71;32469:1;32458:9;32454:17;32445:6;32401:71;:::i;:::-;32355:124;;;;:::o;32485:553::-;32662:4;32700:3;32689:9;32685:19;32677:27;;32714:71;32782:1;32771:9;32767:17;32758:6;32714:71;:::i;:::-;32795:72;32863:2;32852:9;32848:18;32839:6;32795:72;:::i;:::-;32877;32945:2;32934:9;32930:18;32921:6;32877:72;:::i;:::-;32959;33027:2;33016:9;33012:18;33003:6;32959:72;:::i;:::-;32667:371;;;;;;;:::o;33044:545::-;33217:4;33255:3;33244:9;33240:19;33232:27;;33269:71;33337:1;33326:9;33322:17;33313:6;33269:71;:::i;:::-;33350:68;33414:2;33403:9;33399:18;33390:6;33350:68;:::i;:::-;33428:72;33496:2;33485:9;33481:18;33472:6;33428:72;:::i;:::-;33510;33578:2;33567:9;33563:18;33554:6;33510:72;:::i;:::-;33222:367;;;;;;;:::o;33595:309::-;33706:4;33744:2;33733:9;33729:18;33721:26;;33793:9;33787:4;33783:20;33779:1;33768:9;33764:17;33757:47;33821:76;33892:4;33883:6;33821:76;:::i;:::-;33813:84;;33711:193;;;;:::o;33910:313::-;34023:4;34061:2;34050:9;34046:18;34038:26;;34110:9;34104:4;34100:20;34096:1;34085:9;34081:17;34074:47;34138:78;34211:4;34202:6;34138:78;:::i;:::-;34130:86;;34028:195;;;;:::o;34229:307::-;34339:4;34377:2;34366:9;34362:18;34354:26;;34426:9;34420:4;34416:20;34412:1;34401:9;34397:17;34390:47;34454:75;34524:4;34515:6;34454:75;:::i;:::-;34446:83;;34344:192;;;;:::o;34542:419::-;34708:4;34746:2;34735:9;34731:18;34723:26;;34795:9;34789:4;34785:20;34781:1;34770:9;34766:17;34759:47;34823:131;34949:4;34823:131;:::i;:::-;34815:139;;34713:248;;;:::o;34967:419::-;35133:4;35171:2;35160:9;35156:18;35148:26;;35220:9;35214:4;35210:20;35206:1;35195:9;35191:17;35184:47;35248:131;35374:4;35248:131;:::i;:::-;35240:139;;35138:248;;;:::o;35392:419::-;35558:4;35596:2;35585:9;35581:18;35573:26;;35645:9;35639:4;35635:20;35631:1;35620:9;35616:17;35609:47;35673:131;35799:4;35673:131;:::i;:::-;35665:139;;35563:248;;;:::o;35817:419::-;35983:4;36021:2;36010:9;36006:18;35998:26;;36070:9;36064:4;36060:20;36056:1;36045:9;36041:17;36034:47;36098:131;36224:4;36098:131;:::i;:::-;36090:139;;35988:248;;;:::o;36242:419::-;36408:4;36446:2;36435:9;36431:18;36423:26;;36495:9;36489:4;36485:20;36481:1;36470:9;36466:17;36459:47;36523:131;36649:4;36523:131;:::i;:::-;36515:139;;36413:248;;;:::o;36667:419::-;36833:4;36871:2;36860:9;36856:18;36848:26;;36920:9;36914:4;36910:20;36906:1;36895:9;36891:17;36884:47;36948:131;37074:4;36948:131;:::i;:::-;36940:139;;36838:248;;;:::o;37092:419::-;37258:4;37296:2;37285:9;37281:18;37273:26;;37345:9;37339:4;37335:20;37331:1;37320:9;37316:17;37309:47;37373:131;37499:4;37373:131;:::i;:::-;37365:139;;37263:248;;;:::o;37517:419::-;37683:4;37721:2;37710:9;37706:18;37698:26;;37770:9;37764:4;37760:20;37756:1;37745:9;37741:17;37734:47;37798:131;37924:4;37798:131;:::i;:::-;37790:139;;37688:248;;;:::o;37942:419::-;38108:4;38146:2;38135:9;38131:18;38123:26;;38195:9;38189:4;38185:20;38181:1;38170:9;38166:17;38159:47;38223:131;38349:4;38223:131;:::i;:::-;38215:139;;38113:248;;;:::o;38367:419::-;38533:4;38571:2;38560:9;38556:18;38548:26;;38620:9;38614:4;38610:20;38606:1;38595:9;38591:17;38584:47;38648:131;38774:4;38648:131;:::i;:::-;38640:139;;38538:248;;;:::o;38792:419::-;38958:4;38996:2;38985:9;38981:18;38973:26;;39045:9;39039:4;39035:20;39031:1;39020:9;39016:17;39009:47;39073:131;39199:4;39073:131;:::i;:::-;39065:139;;38963:248;;;:::o;39217:419::-;39383:4;39421:2;39410:9;39406:18;39398:26;;39470:9;39464:4;39460:20;39456:1;39445:9;39441:17;39434:47;39498:131;39624:4;39498:131;:::i;:::-;39490:139;;39388:248;;;:::o;39642:419::-;39808:4;39846:2;39835:9;39831:18;39823:26;;39895:9;39889:4;39885:20;39881:1;39870:9;39866:17;39859:47;39923:131;40049:4;39923:131;:::i;:::-;39915:139;;39813:248;;;:::o;40067:419::-;40233:4;40271:2;40260:9;40256:18;40248:26;;40320:9;40314:4;40310:20;40306:1;40295:9;40291:17;40284:47;40348:131;40474:4;40348:131;:::i;:::-;40340:139;;40238:248;;;:::o;40492:419::-;40658:4;40696:2;40685:9;40681:18;40673:26;;40745:9;40739:4;40735:20;40731:1;40720:9;40716:17;40709:47;40773:131;40899:4;40773:131;:::i;:::-;40765:139;;40663:248;;;:::o;40917:419::-;41083:4;41121:2;41110:9;41106:18;41098:26;;41170:9;41164:4;41160:20;41156:1;41145:9;41141:17;41134:47;41198:131;41324:4;41198:131;:::i;:::-;41190:139;;41088:248;;;:::o;41342:419::-;41508:4;41546:2;41535:9;41531:18;41523:26;;41595:9;41589:4;41585:20;41581:1;41570:9;41566:17;41559:47;41623:131;41749:4;41623:131;:::i;:::-;41615:139;;41513:248;;;:::o;41767:419::-;41933:4;41971:2;41960:9;41956:18;41948:26;;42020:9;42014:4;42010:20;42006:1;41995:9;41991:17;41984:47;42048:131;42174:4;42048:131;:::i;:::-;42040:139;;41938:248;;;:::o;42192:419::-;42358:4;42396:2;42385:9;42381:18;42373:26;;42445:9;42439:4;42435:20;42431:1;42420:9;42416:17;42409:47;42473:131;42599:4;42473:131;:::i;:::-;42465:139;;42363:248;;;:::o;42617:419::-;42783:4;42821:2;42810:9;42806:18;42798:26;;42870:9;42864:4;42860:20;42856:1;42845:9;42841:17;42834:47;42898:131;43024:4;42898:131;:::i;:::-;42890:139;;42788:248;;;:::o;43042:419::-;43208:4;43246:2;43235:9;43231:18;43223:26;;43295:9;43289:4;43285:20;43281:1;43270:9;43266:17;43259:47;43323:131;43449:4;43323:131;:::i;:::-;43315:139;;43213:248;;;:::o;43467:419::-;43633:4;43671:2;43660:9;43656:18;43648:26;;43720:9;43714:4;43710:20;43706:1;43695:9;43691:17;43684:47;43748:131;43874:4;43748:131;:::i;:::-;43740:139;;43638:248;;;:::o;43892:419::-;44058:4;44096:2;44085:9;44081:18;44073:26;;44145:9;44139:4;44135:20;44131:1;44120:9;44116:17;44109:47;44173:131;44299:4;44173:131;:::i;:::-;44165:139;;44063:248;;;:::o;44317:419::-;44483:4;44521:2;44510:9;44506:18;44498:26;;44570:9;44564:4;44560:20;44556:1;44545:9;44541:17;44534:47;44598:131;44724:4;44598:131;:::i;:::-;44590:139;;44488:248;;;:::o;44742:419::-;44908:4;44946:2;44935:9;44931:18;44923:26;;44995:9;44989:4;44985:20;44981:1;44970:9;44966:17;44959:47;45023:131;45149:4;45023:131;:::i;:::-;45015:139;;44913:248;;;:::o;45167:222::-;45260:4;45298:2;45287:9;45283:18;45275:26;;45311:71;45379:1;45368:9;45364:17;45355:6;45311:71;:::i;:::-;45265:124;;;;:::o;45395:129::-;45429:6;45456:20;;:::i;:::-;45446:30;;45485:33;45513:4;45505:6;45485:33;:::i;:::-;45436:88;;;:::o;45530:75::-;45563:6;45596:2;45590:9;45580:19;;45570:35;:::o;45611:311::-;45688:4;45778:18;45770:6;45767:30;45764:2;;;45800:18;;:::i;:::-;45764:2;45850:4;45842:6;45838:17;45830:25;;45910:4;45904;45900:15;45892:23;;45693:229;;;:::o;45928:307::-;45989:4;46079:18;46071:6;46068:30;46065:2;;;46101:18;;:::i;:::-;46065:2;46139:29;46161:6;46139:29;:::i;:::-;46131:37;;46223:4;46217;46213:15;46205:23;;45994:241;;;:::o;46241:308::-;46303:4;46393:18;46385:6;46382:30;46379:2;;;46415:18;;:::i;:::-;46379:2;46453:29;46475:6;46453:29;:::i;:::-;46445:37;;46537:4;46531;46527:15;46519:23;;46308:241;;;:::o;46555:141::-;46604:4;46627:3;46619:11;;46650:3;46647:1;46640:14;46684:4;46681:1;46671:18;46663:26;;46609:87;;;:::o;46702:98::-;46753:6;46787:5;46781:12;46771:22;;46760:40;;;:::o;46806:99::-;46858:6;46892:5;46886:12;46876:22;;46865:40;;;:::o;46911:184::-;47010:11;47044:6;47039:3;47032:19;47084:4;47079:3;47075:14;47060:29;;47022:73;;;;:::o;47101:168::-;47184:11;47218:6;47213:3;47206:19;47258:4;47253:3;47249:14;47234:29;;47196:73;;;;:::o;47275:147::-;47376:11;47413:3;47398:18;;47388:34;;;;:::o;47428:169::-;47512:11;47546:6;47541:3;47534:19;47586:4;47581:3;47577:14;47562:29;;47524:73;;;;:::o;47603:148::-;47705:11;47742:3;47727:18;;47717:34;;;;:::o;47757:305::-;47797:3;47816:20;47834:1;47816:20;:::i;:::-;47811:25;;47850:20;47868:1;47850:20;:::i;:::-;47845:25;;48004:1;47936:66;47932:74;47929:1;47926:81;47923:2;;;48010:18;;:::i;:::-;47923:2;48054:1;48051;48047:9;48040:16;;47801:261;;;;:::o;48068:185::-;48108:1;48125:20;48143:1;48125:20;:::i;:::-;48120:25;;48159:20;48177:1;48159:20;:::i;:::-;48154:25;;48198:1;48188:2;;48203:18;;:::i;:::-;48188:2;48245:1;48242;48238:9;48233:14;;48110:143;;;;:::o;48259:191::-;48299:4;48319:20;48337:1;48319:20;:::i;:::-;48314:25;;48353:20;48371:1;48353:20;:::i;:::-;48348:25;;48392:1;48389;48386:8;48383:2;;;48397:18;;:::i;:::-;48383:2;48442:1;48439;48435:9;48427:17;;48304:146;;;;:::o;48456:96::-;48493:7;48522:24;48540:5;48522:24;:::i;:::-;48511:35;;48501:51;;;:::o;48558:104::-;48603:7;48632:24;48650:5;48632:24;:::i;:::-;48621:35;;48611:51;;;:::o;48668:90::-;48702:7;48745:5;48738:13;48731:21;48720:32;;48710:48;;;:::o;48764:77::-;48801:7;48830:5;48819:16;;48809:32;;;:::o;48847:149::-;48883:7;48923:66;48916:5;48912:78;48901:89;;48891:105;;;:::o;49002:126::-;49039:7;49079:42;49072:5;49068:54;49057:65;;49047:81;;;:::o;49134:77::-;49171:7;49200:5;49189:16;;49179:32;;;:::o;49217:86::-;49252:7;49292:4;49285:5;49281:16;49270:27;;49260:43;;;:::o;49309:154::-;49393:6;49388:3;49383;49370:30;49455:1;49446:6;49441:3;49437:16;49430:27;49360:103;;;:::o;49469:307::-;49537:1;49547:113;49561:6;49558:1;49555:13;49547:113;;;49646:1;49641:3;49637:11;49631:18;49627:1;49622:3;49618:11;49611:39;49583:2;49580:1;49576:10;49571:15;;49547:113;;;49678:6;49675:1;49672:13;49669:2;;;49758:1;49749:6;49744:3;49740:16;49733:27;49669:2;49518:258;;;;:::o;49782:171::-;49821:3;49844:24;49862:5;49844:24;:::i;:::-;49835:33;;49890:4;49883:5;49880:15;49877:2;;;49898:18;;:::i;:::-;49877:2;49945:1;49938:5;49934:13;49927:20;;49825:128;;;:::o;49959:320::-;50003:6;50040:1;50034:4;50030:12;50020:22;;50087:1;50081:4;50077:12;50108:18;50098:2;;50164:4;50156:6;50152:17;50142:27;;50098:2;50226;50218:6;50215:14;50195:18;50192:38;50189:2;;;50245:18;;:::i;:::-;50189:2;50010:269;;;;:::o;50285:281::-;50368:27;50390:4;50368:27;:::i;:::-;50360:6;50356:40;50498:6;50486:10;50483:22;50462:18;50450:10;50447:34;50444:62;50441:2;;;50509:18;;:::i;:::-;50441:2;50549:10;50545:2;50538:22;50328:238;;;:::o;50572:233::-;50611:3;50634:24;50652:5;50634:24;:::i;:::-;50625:33;;50680:66;50673:5;50670:77;50667:2;;;50750:18;;:::i;:::-;50667:2;50797:1;50790:5;50786:13;50779:20;;50615:190;;;:::o;50811:100::-;50850:7;50879:26;50899:5;50879:26;:::i;:::-;50868:37;;50858:53;;;:::o;50917:79::-;50956:7;50985:5;50974:16;;50964:32;;;:::o;51002:94::-;51041:7;51070:20;51084:5;51070:20;:::i;:::-;51059:31;;51049:47;;;:::o;51102:79::-;51141:7;51170:5;51159:16;;51149:32;;;:::o;51187:176::-;51219:1;51236:20;51254:1;51236:20;:::i;:::-;51231:25;;51270:20;51288:1;51270:20;:::i;:::-;51265:25;;51309:1;51299:2;;51314:18;;:::i;:::-;51299:2;51355:1;51352;51348:9;51343:14;;51221:142;;;;:::o;51369:180::-;51417:77;51414:1;51407:88;51514:4;51511:1;51504:15;51538:4;51535:1;51528:15;51555:180;51603:77;51600:1;51593:88;51700:4;51697:1;51690:15;51724:4;51721:1;51714:15;51741:180;51789:77;51786:1;51779:88;51886:4;51883:1;51876:15;51910:4;51907:1;51900:15;51927:180;51975:77;51972:1;51965:88;52072:4;52069:1;52062:15;52096:4;52093:1;52086:15;52113:102;52154:6;52205:2;52201:7;52196:2;52189:5;52185:14;52181:28;52171:38;;52161:54;;;:::o;52221:94::-;52254:8;52302:5;52298:2;52294:14;52273:35;;52263:52;;;:::o;52321:234::-;52461:34;52457:1;52449:6;52445:14;52438:58;52530:17;52525:2;52517:6;52513:15;52506:42;52427:128;:::o;52561:237::-;52701:34;52697:1;52689:6;52685:14;52678:58;52770:20;52765:2;52757:6;52753:15;52746:45;52667:131;:::o;52804:234::-;52944:34;52940:1;52932:6;52928:14;52921:58;53013:17;53008:2;53000:6;52996:15;52989:42;52910:128;:::o;53044:178::-;53184:30;53180:1;53172:6;53168:14;53161:54;53150:72;:::o;53228:178::-;53368:30;53364:1;53356:6;53352:14;53345:54;53334:72;:::o;53412:214::-;53552:66;53548:1;53540:6;53536:14;53529:90;53518:108;:::o;53632:177::-;53772:29;53768:1;53760:6;53756:14;53749:53;53738:71;:::o;53815:228::-;53955:34;53951:1;53943:6;53939:14;53932:58;54024:11;54019:2;54011:6;54007:15;54000:36;53921:122;:::o;54049:223::-;54189:34;54185:1;54177:6;54173:14;54166:58;54258:6;54253:2;54245:6;54241:15;54234:31;54155:117;:::o;54278:175::-;54418:27;54414:1;54406:6;54402:14;54395:51;54384:69;:::o;54459:231::-;54599:34;54595:1;54587:6;54583:14;54576:58;54668:14;54663:2;54655:6;54651:15;54644:39;54565:125;:::o;54696:235::-;54836:34;54832:1;54824:6;54820:14;54813:58;54905:18;54900:2;54892:6;54888:15;54881:43;54802:129;:::o;54937:224::-;55077:34;55073:1;55065:6;55061:14;55054:58;55146:7;55141:2;55133:6;55129:15;55122:32;55043:118;:::o;55167:243::-;55307:34;55303:1;55295:6;55291:14;55284:58;55376:26;55371:2;55363:6;55359:15;55352:51;55273:137;:::o;55416:227::-;55556:34;55552:1;55544:6;55540:14;55533:58;55625:10;55620:2;55612:6;55608:15;55601:35;55522:121;:::o;55649:229::-;55789:34;55785:1;55777:6;55773:14;55766:58;55858:12;55853:2;55845:6;55841:15;55834:37;55755:123;:::o;55884:227::-;56024:34;56020:1;56012:6;56008:14;56001:58;56093:10;56088:2;56080:6;56076:15;56069:35;55990:121;:::o;56117:182::-;56257:34;56253:1;56245:6;56241:14;56234:58;56223:76;:::o;56305:231::-;56445:34;56441:1;56433:6;56429:14;56422:58;56514:14;56509:2;56501:6;56497:15;56490:39;56411:125;:::o;56542:231::-;56682:34;56678:1;56670:6;56666:14;56659:58;56751:14;56746:2;56738:6;56734:15;56727:39;56648:125;:::o;56779:228::-;56919:34;56915:1;56907:6;56903:14;56896:58;56988:11;56983:2;56975:6;56971:15;56964:36;56885:122;:::o;57013:220::-;57153:34;57149:1;57141:6;57137:14;57130:58;57222:3;57217:2;57209:6;57205:15;57198:28;57119:114;:::o;57239:234::-;57379:34;57375:1;57367:6;57363:14;57356:58;57448:17;57443:2;57435:6;57431:15;57424:42;57345:128;:::o;57479:220::-;57619:34;57615:1;57607:6;57603:14;57596:58;57688:3;57683:2;57675:6;57671:15;57664:28;57585:114;:::o;57705:236::-;57845:34;57841:1;57833:6;57829:14;57822:58;57914:19;57909:2;57901:6;57897:15;57890:44;57811:130;:::o;57947:179::-;58087:31;58083:1;58075:6;58071:14;58064:55;58053:73;:::o;58132:234::-;58272:34;58268:1;58260:6;58256:14;58249:58;58341:17;58336:2;58328:6;58324:15;58317:42;58238:128;:::o;58372:122::-;58445:24;58463:5;58445:24;:::i;:::-;58438:5;58435:35;58425:2;;58484:1;58481;58474:12;58425:2;58415:79;:::o;58500:116::-;58570:21;58585:5;58570:21;:::i;:::-;58563:5;58560:32;58550:2;;58606:1;58603;58596:12;58550:2;58540:76;:::o;58622:122::-;58695:24;58713:5;58695:24;:::i;:::-;58688:5;58685:35;58675:2;;58734:1;58731;58724:12;58675:2;58665:79;:::o;58750:120::-;58822:23;58839:5;58822:23;:::i;:::-;58815:5;58812:34;58802:2;;58860:1;58857;58850:12;58802:2;58792:78;:::o;58876:122::-;58949:24;58967:5;58949:24;:::i;:::-;58942:5;58939:35;58929:2;;58988:1;58985;58978:12;58929:2;58919:79;:::o;59004:118::-;59075:22;59091:5;59075:22;:::i;:::-;59068:5;59065:33;59055:2;;59112:1;59109;59102:12;59055:2;59045:77;:::o

ipfs://affe00e75681bc0cc85bfd3a043a3daae8b581c4a5042c68e805166384fc848f