Token

/**
 *Submitted for verification at Etherscan.io on 2022-05-19
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

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

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

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

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

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

}


/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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


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

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

/**
 * @dev Interface for the NFT Royalty Standard
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Called with the sale price to determine how much royalty is owed and to whom.
     * @param tokenId - the NFT asset queried for royalty information
     * @param salePrice - the sale price of the NFT asset specified by `tokenId`
     * @return receiver - address of who should be sent the royalty payment
     * @return royaltyAmount - the royalty payment amount for `salePrice`
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

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

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

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

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


/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. 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;
        }
    }
}


/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}


/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
        @dev Handles the receipt of a single ERC1155 token type. This function is
        called at the end of a `safeTransferFrom` after the balance has been updated.
        To accept the transfer, this must return
        `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
        (i.e. 0xf23a6e61, or its own function selector).
        @param operator The address which initiated the transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param id The ID of the token being transferred
        @param value The amount of tokens being transferred
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
    */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
        @dev Handles the receipt of a multiple ERC1155 token types. This function
        is called at the end of a `safeBatchTransferFrom` after the balances have
        been updated. To accept the transfer(s), this must return
        `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
        (i.e. 0xbc197c81, or its own function selector).
        @param operator The address which initiated the batch transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param ids An array containing ids of each token being transferred (order and length must match values array)
        @param values An array containing amounts of each token being transferred (order and length must match ids array)
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
    */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}


/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}


/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    // Mapping from token ID to account balances
    mapping(uint256 => mapping(address => uint256)) private _balances;

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

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_) {
        _setURI(uri_);
    }

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

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: balance query for the zero address");
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: transfer caller is not owner nor approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }
        _balances[id][to] += amount;

        emit TransferSingle(operator, from, to, id, amount);

        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
            _balances[id][to] += amount;
        }

        emit TransferBatch(operator, from, to, ids, amounts);

        _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);

        _balances[id][to] += amount;
        emit TransferSingle(operator, address(0), to, id, amount);

        _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `amount` tokens of token type `id`.
     */
    function _burn(
        address from,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }

        emit TransferSingle(operator, from, address(0), id, amount);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        for (uint256 i = 0; i < ids.length; i++) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
        }

        emit TransferBatch(operator, from, address(0), ids, amounts);
    }

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

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }
}


/**
 * @dev Extension of ERC1155 that adds tracking of total supply per id.
 *
 * Useful for scenarios where Fungible and Non-fungible tokens have to be
 * clearly identified. Note: While a totalSupply of 1 might mean the
 * corresponding is an NFT, there is no guarantees that no other token with the
 * same id are not going to be minted.
 */
abstract contract ERC1155Supply is ERC1155 {
    mapping(uint256 => uint256) private _totalSupply;

    /**
     * @dev Total amount of tokens in with a given id.
     */
    function totalSupply(uint256 id) public view virtual returns (uint256) {
        return _totalSupply[id];
    }

    /**
     * @dev Indicates weither any token exist with a given id, or not.
     */
    function exists(uint256 id) public view virtual returns (bool) {
        return ERC1155Supply.totalSupply(id) > 0;
    }

    /**
     * @dev See {ERC1155-_mint}.
     */
    function _mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual override {
        super._mint(account, id, amount, data);
        _totalSupply[id] += amount;
    }

    /**
     * @dev See {ERC1155-_mintBatch}.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override {
        super._mintBatch(to, ids, amounts, data);
        for (uint256 i = 0; i < ids.length; ++i) {
            _totalSupply[ids[i]] += amounts[i];
        }
    }

    /**
     * @dev See {ERC1155-_burn}.
     */
    function _burn(
        address account,
        uint256 id,
        uint256 amount
    ) internal virtual override {
        super._burn(account, id, amount);
        _totalSupply[id] -= amount;
    }

    /**
     * @dev See {ERC1155-_burnBatch}.
     */
    function _burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual override {
        super._burnBatch(account, ids, amounts);
        for (uint256 i = 0; i < ids.length; ++i) {
            _totalSupply[ids[i]] -= amounts[i];
        }
    }
}


contract ERC1155Mintable is ERC1155, ERC1155Supply, IERC2981, Ownable {

    uint256 constant PERCENTAGE_DIVISOR = 100000;  // 1000 * 100, 1000 to get percentage and 100 to get fraction

    uint256 public royaltyPercentage; // decimal 3 digits

    address public royaltyRecipient;

    string public contractURI;

    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdTracker;

    // Mapping for token URIs
    mapping (uint256 => string) private _customTokenURIs;

    // Mapping from token ID to file hash
    mapping (uint256 => bytes32) private _fileHash;

    // Mapping for minters
    mapping(address => bool) private _minters;

    bool private mintingFrozen = false;

    constructor(
        string memory commonURI,
        string memory contractURIValue,
        uint256 royaltyPercent,
        address royaltyReceiver
    ) ERC1155(commonURI) {
        contractURI = contractURIValue;
        royaltyPercentage = royaltyPercent;
        royaltyRecipient = royaltyReceiver;
        _tokenIdTracker.increment(); // start with 1
    }

    function version() external virtual view returns (uint256) {
        return 5;
    }

    /**
     * @dev Throws if called by any account other than the owner or minter.
     */
    modifier onlyMinter() virtual {
        require(_minters[_msgSender()] || owner() == _msgSender(), "ERC1155Mintable: caller is not minter or owner");
        _;
    }

    function getFileHash(uint256 tokenId) public view virtual returns (bytes32) {
        return _fileHash[tokenId];
    }

    function isMinter(address minter) public view virtual returns (bool) {
        return _minters[minter];
    }

    function setMinter(address minter, bool canMint) public virtual onlyOwner {
        _minters[minter] = canMint;
    }

    function isMintingFrozen() public view virtual returns (bool) {
        return mintingFrozen;
    }

    function freezeMinting() public virtual onlyOwner {
        mintingFrozen = true;
    }

    function uri(uint256 tokenId) public view virtual override returns (string memory) {

        if (bytes(_customTokenURIs[tokenId]).length > 0) {
            return _customTokenURIs[tokenId];
        }
        else {
            return super.uri(tokenId);
        }
    }

    function _getCurrentTokenId() internal view virtual returns (uint256) {
        return _tokenIdTracker.current();
    }

    function _incrementTokenId() internal virtual {
        _tokenIdTracker.increment();
    }

    function _setFileHash(uint256 tokenId,  bytes32 fileHash) internal virtual {
       _fileHash[tokenId] = fileHash;
    }

    /**
     * @dev Creates `amount` new tokens for `to`, of token type `id`.
     *
     * See {ERC1155-_mint}.
     */
    function mint(
        address to,
        uint256 amount,
        string memory tokenURI
    ) public virtual onlyMinter {
        _mintInternal(to, amount, tokenURI, bytes32(0));
    }

    /**	
     * @dev Creates `amount` new tokens for `to`, of token type `id` with file hash	
     *	
     * See {ERC1155-_mint}.	
     */
    function mintWithHash(
        address to,
        uint256 amount,
        string memory tokenURI,
        bytes32 fileHash
    ) public virtual onlyMinter {
        _mintInternal(to, amount, tokenURI, fileHash);
    }

    function _mintInternal(
        address to,
        uint256 amount,
        string memory tokenURI,
        bytes32 fileHash
    ) internal virtual {
        require(mintingFrozen == false, 'ERC1155Mintable: No more minting allowed.');
        
        _mint(to, _tokenIdTracker.current(), amount, '');

        _setTokenURI(_tokenIdTracker.current(), tokenURI);

        _fileHash[_tokenIdTracker.current()] = fileHash;

        _tokenIdTracker.increment();
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] variant of {mint}.
     */
    function mintBatch(
        address to,
        uint256[] memory amounts,
        string[] memory tokenURIs,
        bytes32[] memory fileHashes
    ) public virtual onlyMinter {
        require(mintingFrozen == false, 'ERC1155Mintable: No more minting allowed.');

        require(tokenURIs.length == amounts.length, "ERC1155Mintable: tokenURIs and amounts length mismatch");

        uint startingId = _tokenIdTracker.current();
      
        //ids array
        uint256[] memory ids = new uint256[](amounts.length);

        for(uint i = 0; _tokenIdTracker.current() < startingId + amounts.length; _tokenIdTracker.increment()) {
            ids[i++] = _tokenIdTracker.current();
        }

        _mintBatch(to, ids, amounts, '');

        for (uint j = 0; j < ids.length; j++) {
            _setTokenURI(ids[j], tokenURIs[j]);

            bytes32 fileHash = j < fileHashes.length? fileHashes[j]: bytes32(0);

           _fileHash[ids[j]] = fileHash;
        }
    }

    function _setTokenURI(uint256 tokenId, string memory tokenURI) internal virtual {
        require(exists(tokenId), "ERC1155Mintable: cannot set URI of nonexistent token");

        _customTokenURIs[tokenId] = tokenURI;

        emit URI(tokenURI, tokenId);
    }

    function _mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual override(ERC1155, ERC1155Supply) {
        super._mint(account, id, amount, data);
    }

    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override(ERC1155, ERC1155Supply) {
        super._mintBatch(to, ids, amounts, data);
    }

    function burn(address account, uint256 id, uint256 value) public virtual {
        require(account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155Mintable: caller is not owner nor approved");

        _burn(account, id, value);
    }

    // function burnBatch(address account, uint256[] memory ids, uint256[] memory values) public virtual {
    //     require(account == _msgSender() || isApprovedForAll(account, _msgSender()),
    //         "ERC1155Mintable: caller is not owner nor approved");

    //     _burnBatch(account, ids, values);
    // }

    function _burn(
        address account,
        uint256 id,
        uint256 amount
    ) internal virtual override(ERC1155, ERC1155Supply) {
        super._burn(account, id, amount);
    }

    /**
     * @dev See {ERC1155-_burnBatch}.
     */
    function _burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual override(ERC1155, ERC1155Supply) {
        super._burnBatch(account, ids, amounts);
        for (uint256 i = 0; i < ids.length; ++i) {
        }
    }


    /**
     * @dev See {IERC2981-royaltyInfo}.
     */
    function royaltyInfo(
        uint256 tokenId, 
        uint256 salePrice
    ) external view override returns (address receiver, uint256 royaltyAmount) {
        royaltyAmount = (salePrice * royaltyPercentage) / PERCENTAGE_DIVISOR;

        return(royaltyRecipient, royaltyAmount);
    }

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


contract Executable is Ownable {

    // Mapping for NFTically Executors
    mapping(address => bool) private _executors;

    // array with all Executors
    address[] private _allExecutors;

    // ability to disable all Executors per token owner
    mapping(address => bool) private _disableAllExecutors;

    event ExecutorUpdated(address indexed executor, bool canExecute);

    constructor(address executor) {

        _executors[executor] = true;

        _allExecutors.push(executor);

        emit ExecutorUpdated(executor, true);
    }


    function isExecutor(address executor) public view virtual returns (bool) {
        return _executors[executor];
    }


    function getAllExecutors() public view virtual returns (address[] memory) {
        return _allExecutors;
    }


    function areExecutorsDisabled(address owner) public view virtual returns (bool) {
        return _disableAllExecutors[owner];
    }


    function setExecutor(address executor, bool canExecute) public virtual {

        require(_executors[_msgSender()], "Executable: caller is not executor");

        _setExecutor(executor, canExecute);
    }


    function _setExecutor(address executor, bool canExecute) internal virtual {

        _executors[executor] = canExecute;

        // push executor in _allExecutors only if it does not exists already
        uint i;
	
        for(i = 0; i < _allExecutors.length; i++) {
            if(_allExecutors[i] == executor) break;
        }
            
        if (i >= _allExecutors.length) {
            _allExecutors.push(executor);
        }

        emit ExecutorUpdated(executor, canExecute);
    }
    

    // enable/disble all Executors for the caller tokens
    function disableAllExecutorsForMe(bool disableAll) public virtual {
        _disableAllExecutors[_msgSender()] = disableAll;
    }

}

contract ERC1155MintableTradeable is ERC1155Mintable, Executable {

    constructor(
        string memory commonURI,
        string memory contractURIValue,
        uint256 royaltyPercent,
        address royaltyReceiver,
        address executor
    ) ERC1155Mintable(commonURI, contractURIValue, royaltyPercent, royaltyReceiver) Executable(executor) {}


    // executors, owner or minter can mint.
    modifier onlyMinter() virtual override {
        require(isExecutor(_msgSender()) || isMinter(_msgSender()) || owner() == _msgSender(), "ERC1155MintableTradeable: caller is not executor/minter/owner");
        _;
    }


    // check if given address can mint (for external use)
    function canMint(address addressToCheck) external view virtual returns (bool) {
        return isExecutor(addressToCheck) || isMinter(addressToCheck) || owner() == addressToCheck;
    }


    // override to make few functionality executable through Executors to allow meta transactions
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {

        if ( ! areExecutorsDisabled(owner) && isExecutor(operator)) {

            return true;
        }

        return super.isApprovedForAll(owner, operator);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"commonURI","type":"string"},{"internalType":"string","name":"contractURIValue","type":"string"},{"internalType":"uint256","name":"royaltyPercent","type":"uint256"},{"internalType":"address","name":"royaltyReceiver","type":"address"},{"internalType":"address","name":"executor","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"executor","type":"address"},{"indexed":false,"internalType":"bool","name":"canExecute","type":"bool"}],"name":"ExecutorUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"areExecutorsDisabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addressToCheck","type":"address"}],"name":"canMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"disableAll","type":"bool"}],"name":"disableAllExecutorsForMe","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freezeMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAllExecutors","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getFileHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":"executor","type":"address"}],"name":"isExecutor","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isMintingFrozen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"string","name":"tokenURI","type":"string"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"string[]","name":"tokenURIs","type":"string[]"},{"internalType":"bytes32[]","name":"fileHashes","type":"bytes32[]"}],"name":"mintBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"string","name":"tokenURI","type":"string"},{"internalType":"bytes32","name":"fileHash","type":"bytes32"}],"name":"mintWithHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"royaltyPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"royaltyRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","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":"address","name":"executor","type":"address"},{"internalType":"bool","name":"canExecute","type":"bool"}],"name":"setExecutor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"},{"internalType":"bool","name":"canMint","type":"bool"}],"name":"setMinter","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":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

50646:1289:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25357:231;;;;;;:::i;:::-;;:::i;:::-;;;15072:25:1;;;15060:2;15045:18;25357:231:0;;;;;;;;48458:266;;;;;;:::i;:::-;;:::i;:::-;;;14899:14:1;;14892:22;14874:41;;14862:2;14847:18;48458:266:0;14734:187:1;43153:278:0;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;49703:210::-;;;;;;:::i;:::-;;:::i;:::-;;48091:295;;;;;;:::i;:::-;;:::i;:::-;;;;13214:42:1;13202:55;;;13184:74;;13289:2;13274:18;;13267:34;;;;13157:18;48091:295:0;13010:297:1;27296:442:0;;;;;;:::i;:::-;;:::i;44268:225::-;;;;;;:::i;:::-;;:::i;41348:31::-;;;;;;;;;;;;11513:42:1;11501:55;;;11483:74;;11471:2;11456:18;41348:31:0;11337:226:1;25754:524:0;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;39607:122::-;;;;;;:::i;:::-;39664:4;39485:16;;;:12;:16;;;;;;-1:-1:-1;;;39607:122:0;42207:86;42284:1;42207:86;;14809:148;;;:::i;41287:32::-;;;;;;42947:101;43027:13;;;;42947:101;;14158:87;14231:6;;;;14158:87;;26351:155;;;;;;:::i;:::-;;:::i;42701:111::-;;;;;;:::i;:::-;42788:16;;42764:4;42788:16;;;:8;:16;;;;;;;;;42701:111;39396:113;;;;;;:::i;:::-;39458:7;39485:16;;;:12;:16;;;;;;;39396:113;43056:89;;;:::i;51354:187::-;;;;;;:::i;:::-;;:::i;42820:119::-;;;;;;:::i;:::-;;:::i;49560:133::-;;;;;;:::i;:::-;49658:27;;49634:4;49658:27;;;:20;:27;;;;;;;;;49560:133;43924:192;;;;;;:::i;:::-;;:::i;45087:1000::-;;;;;;:::i;:::-;;:::i;49308:119::-;;;;;;:::i;:::-;49399:20;;49375:4;49399:20;;;:10;:20;;;;;;;;;49308:119;41388:25;;;:::i;51650:282::-;;;;;;:::i;:::-;;:::i;42573:120::-;;;;;;:::i;:::-;42640:7;42667:18;;;:9;:18;;;;;;;42573:120;50505:132;;;;;;:::i;:::-;12880:10;50582:34;;;;:20;:34;;;;;:47;;;;;;;;;;;;;50505:132;26818:401;;;;;;:::i;:::-;;:::i;15112:244::-;;;;;;:::i;:::-;;:::i;46867:271::-;;;;;;:::i;:::-;;:::i;49437:113::-;;;:::i;:::-;;;;;;;:::i;25357:231::-;25443:7;25471:21;;;25463:77;;;;-1:-1:-1;;;25463:77:0;;16774:2:1;25463:77:0;;;16756:21:1;16813:2;16793:18;;;16786:30;16852:34;16832:18;;;16825:62;16923:13;16903:18;;;16896:41;16954:19;;25463:77:0;;;;;;;;;-1:-1:-1;25558:9:0;:13;;;;;;;;;;;:22;;;;;;;;;;;25357:231;;;;;:::o;48458:266::-;48606:4;48635:41;;;48650:26;48635:41;;:81;;;48680:36;48704:11;48680:23;:36::i;43153:278::-;43295:1;43259:25;;;:16;:25;;;;;43253:39;;43221:13;;43295:1;43259:25;43253:39;;;:::i;:::-;;;:43;43249:175;;;43320:25;;;;:16;:25;;;;;43313:32;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43153:278;;;:::o;43249:175::-;43394:18;43404:7;43394:9;:18::i;43249:175::-;43153:278;;;:::o;49703:210::-;12880:10;49795:24;;;;:10;:24;;;;;;;;49787:71;;;;-1:-1:-1;;;49787:71:0;;22101:2:1;49787:71:0;;;22083:21:1;22140:2;22120:18;;;22113:30;22179:34;22159:18;;;22152:62;22250:4;22230:18;;;22223:32;22272:19;;49787:71:0;21899:398:1;49787:71:0;49871:34;49884:8;49894:10;49871:12;:34::i;:::-;49703:210;;:::o;48091:295::-;48206:16;48224:21;41209:6;48287:17;;48275:9;:29;;;;:::i;:::-;48274:52;;;;:::i;:::-;48346:16;;;;;48258:68;;-1:-1:-1;48091:295:0;-1:-1:-1;;;48091:295:0:o;27296:442::-;27529:20;;;12880:10;27529:20;;:60;;-1:-1:-1;27553:36:0;27570:4;12880:10;51650:282;:::i;27553:36::-;27507:160;;;;-1:-1:-1;;;27507:160:0;;19237:2:1;27507:160:0;;;19219:21:1;19276:2;19256:18;;;19249:30;19315:34;19295:18;;;19288:62;19386:20;19366:18;;;19359:48;19424:19;;27507:160:0;19035:414:1;27507:160:0;27678:52;27701:4;27707:2;27711:3;27716:7;27725:4;27678:22;:52::i;:::-;27296:442;;;;;:::o;44268:225::-;51122:24;12880:10;51133:12;12800:98;51122:24;:50;;;-1:-1:-1;51150:22:0;12880:10;51159:12;12800:98;51150:22;51122:77;;;-1:-1:-1;14231:6:0;;51176:23;14231:6;12880:10;51176:23;51122:77;51114:151;;;;-1:-1:-1;;;51114:151:0;;20471:2:1;51114:151:0;;;20453:21:1;20510:2;20490:18;;;20483:30;20549:34;20529:18;;;20522:62;20620:31;20600:18;;;20593:59;20669:19;;51114:151:0;20269:425:1;51114:151:0;44440:45:::1;44454:2;44458:6;44466:8;44476;44440:13;:45::i;:::-;44268:225:::0;;;;:::o;25754:524::-;25910:16;25971:3;:10;25952:8;:15;:29;25944:83;;;;-1:-1:-1;;;25944:83:0;;22914:2:1;25944:83:0;;;22896:21:1;22953:2;22933:18;;;22926:30;22992:34;22972:18;;;22965:62;23063:11;23043:18;;;23036:39;23092:19;;25944:83:0;22712:405:1;25944:83:0;26040:30;26087:8;:15;26073:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26073:30:0;;26040:63;;26121:9;26116:122;26140:8;:15;26136:1;:19;26116:122;;;26196:30;26206:8;26215:1;26206:11;;;;;;;;:::i;:::-;;;;;;;26219:3;26223:1;26219:6;;;;;;;;:::i;:::-;;;;;;;26196:9;:30::i;:::-;26177:13;26191:1;26177:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;26157:3;;;:::i;:::-;;;26116:122;;;-1:-1:-1;26257:13:0;25754:524;-1:-1:-1;;;25754:524:0:o;14809:148::-;14231:6;;14378:23;14231:6;12880:10;14378:23;14370:68;;;;-1:-1:-1;;;14370:68:0;;20901:2:1;14370:68:0;;;20883:21:1;;;20920:18;;;20913:30;20979:34;20959:18;;;20952:62;21031:18;;14370:68:0;20699:356:1;14370:68:0;14900:6:::1;::::0;14879:40:::1;::::0;14916:1:::1;::::0;14879:40:::1;14900:6;::::0;14879:40:::1;::::0;14916:1;;14879:40:::1;14930:6;:19:::0;;;::::1;::::0;;14809:148::o;26351:155::-;26446:52;12880:10;26479:8;26489;26446:18;:52::i;43056:89::-;14231:6;;14378:23;14231:6;12880:10;14378:23;14370:68;;;;-1:-1:-1;;;14370:68:0;;20901:2:1;14370:68:0;;;20883:21:1;;;20920:18;;;20913:30;20979:34;20959:18;;;20952:62;21031:18;;14370:68:0;20699:356:1;14370:68:0;43117:13:::1;:20:::0;;;::::1;43133:4;43117:20;::::0;;43056:89::o;51354:187::-;49399:20;;;51426:4;49399:20;;;:10;:20;;;;;;;;51450:54;;;-1:-1:-1;42788:16:0;;;42764:4;42788:16;;;:8;:16;;;;;;;;51480:24;51450:83;;;;51519:14;51508:25;;:7;14231:6;;;;;14158:87;51508:7;:25;;;51443:90;51354:187;-1:-1:-1;;51354:187:0:o;42820:119::-;14231:6;;14378:23;14231:6;12880:10;14378:23;14370:68;;;;-1:-1:-1;;;14370:68:0;;20901:2:1;14370:68:0;;;20883:21:1;;;20920:18;;;20913:30;20979:34;20959:18;;;20952:62;21031:18;;14370:68:0;20699:356:1;14370:68:0;42905:16:::1;::::0;;;::::1;;::::0;;;:8:::1;:16;::::0;;;;:26;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;42820:119::o;43924:192::-;51122:24;12880:10;51133:12;12800:98;51122:24;:50;;;-1:-1:-1;51150:22:0;12880:10;51159:12;12800:98;51150:22;51122:77;;;-1:-1:-1;14231:6:0;;51176:23;14231:6;12880:10;51176:23;51122:77;51114:151;;;;-1:-1:-1;;;51114:151:0;;20471:2:1;51114:151:0;;;20453:21:1;20510:2;20490:18;;;20483:30;20549:34;20529:18;;;20522:62;20620:31;20600:18;;;20593:59;20669:19;;51114:151:0;20269:425:1;51114:151:0;44061:47:::1;44075:2:::0;44079:6;44087:8;44105:1:::1;44061:13;:47::i;:::-;43924:192:::0;;;:::o;45087:1000::-;51122:24;12880:10;51133:12;12800:98;51122:24;:50;;;-1:-1:-1;51150:22:0;12880:10;51159:12;12800:98;51150:22;51122:77;;;-1:-1:-1;14231:6:0;;51176:23;14231:6;12880:10;51176:23;51122:77;51114:151;;;;-1:-1:-1;;;51114:151:0;;20471:2:1;51114:151:0;;;20453:21:1;20510:2;20490:18;;;20483:30;20549:34;20529:18;;;20522:62;20620:31;20600:18;;;20593:59;20669:19;;51114:151:0;20269:425:1;51114:151:0;45288:13:::1;::::0;::::1;;:22;45280:76;;;::::0;-1:-1:-1;;;45280:76:0;;15955:2:1;45280:76:0::1;::::0;::::1;15937:21:1::0;15994:2;15974:18;;;15967:30;16033:34;16013:18;;;16006:62;16104:11;16084:18;;;16077:39;16133:19;;45280:76:0::1;15753:405:1::0;45280:76:0::1;45397:7;:14;45377:9;:16;:34;45369:101;;;::::0;-1:-1:-1;;;45369:101:0;;18408:2:1;45369:101:0::1;::::0;::::1;18390:21:1::0;18447:2;18427:18;;;18420:30;18486:34;18466:18;;;18459:62;18557:24;18537:18;;;18530:52;18599:19;;45369:101:0::1;18206:418:1::0;45369:101:0::1;45483:15;45501:25;:15;16188:14:::0;;16096:114;45501:25:::1;45483:43;;45566:20;45603:7;:14;45589:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;45589:29:0::1;;45566:52;;45635:6;45631:165;45688:14:::0;;45675:27:::1;::::0;:10;:27:::1;:::i;:::-;45647:15;16188:14:::0;45647:55:::1;45631:165;;;45759:15;16188:14:::0;45748:3;45752;::::1;::::0;::::1;:::i;:::-;;;45748:8;;;;;;;;:::i;:::-;;;;;;:36;;;::::0;::::1;45704:27;:15;16307:19:::0;;16325:1;16307:19;;;16218:127;45704:27:::1;45631:165;;;;45808:32;45819:2;45823:3;45828:7;45808:32;;;;;;;;;;;::::0;:10:::1;:32::i;:::-;45858:6;45853:227;45874:3;:10;45870:1;:14;45853:227;;;45906:34;45919:3;45923:1;45919:6;;;;;;;;:::i;:::-;;;;;;;45927:9;45937:1;45927:12;;;;;;;;:::i;:::-;;;;;;;45906;:34::i;:::-;45957:16;45980:10;:17;45976:1;:21;:48;;46022:1;45976:48;;;45999:10;46010:1;45999:13;;;;;;;;:::i;:::-;;;;;;;45976:48;45957:67;;46060:8;46040:9;:17;46050:3;46054:1;46050:6;;;;;;;;:::i;:::-;;;;;;;46040:17;;;;;;;;;;;:28;;;;45891:189;45886:3;;;;;:::i;:::-;;;;45853:227;;;;45269:818;;45087:1000:::0;;;;:::o;41388:25::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;51650:282::-;49658:27;;;51747:4;49658:27;;;:20;:27;;;;;;;;51771:29;:53;;;;-1:-1:-1;49399:20:0;;;49375:4;49399:20;;;:10;:20;;;;;;;;51804;51766:100;;;-1:-1:-1;51850:4:0;51843:11;;51766:100;26701:27;;;;26677:4;26701:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;51885:39;51878:46;51650:282;-1:-1:-1;;;51650:282:0:o;26818:401::-;27026:20;;;12880:10;27026:20;;:60;;-1:-1:-1;27050:36:0;27067:4;12880:10;51650:282;:::i;27050:36::-;27004:151;;;;-1:-1:-1;;;27004:151:0;;17998:2:1;27004:151:0;;;17980:21:1;18037:2;18017:18;;;18010:30;18076:34;18056:18;;;18049:62;18147:11;18127:18;;;18120:39;18176:19;;27004:151:0;17796:405:1;27004:151:0;27166:45;27184:4;27190:2;27194;27198:6;27206:4;27166:17;:45::i;15112:244::-;14231:6;;14378:23;14231:6;12880:10;14378:23;14370:68;;;;-1:-1:-1;;;14370:68:0;;20901:2:1;14370:68:0;;;20883:21:1;;;20920:18;;;20913:30;20979:34;20959:18;;;20952:62;21031:18;;14370:68:0;20699:356:1;14370:68:0;15201:22:::1;::::0;::::1;15193:73;;;::::0;-1:-1:-1;;;15193:73:0;;17186:2:1;15193:73:0::1;::::0;::::1;17168:21:1::0;17225:2;17205:18;;;17198:30;17264:34;17244:18;;;17237:62;17335:8;17315:18;;;17308:36;17361:19;;15193:73:0::1;16984:402:1::0;15193:73:0::1;15303:6;::::0;15282:38:::1;::::0;::::1;::::0;;::::1;::::0;15303:6:::1;::::0;15282:38:::1;::::0;15303:6:::1;::::0;15282:38:::1;15331:6;:17:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;15112:244::o;46867:271::-;46959:23;;;12880:10;46959:23;;:66;;-1:-1:-1;46986:39:0;47003:7;12880:10;51650:282;:::i;46986:39::-;46951:141;;;;-1:-1:-1;;;46951:141:0;;21683:2:1;46951:141:0;;;21665:21:1;21722:2;21702:18;;;21695:30;21761:34;21741:18;;;21734:62;21832:19;21812:18;;;21805:47;21869:19;;46951:141:0;21481:413:1;46951:141:0;47105:25;47111:7;47120:2;47124:5;47105;:25::i;49437:113::-;49493:16;49529:13;49522:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49437:113;:::o;16218:127::-;16307:19;;16325:1;16307:19;;;16218:127::o;24380:310::-;24482:4;24519:41;;;24534:26;24519:41;;:110;;-1:-1:-1;24577:52:0;;;24592:37;24577:52;24519:110;:163;;;-1:-1:-1;11557:25:0;11542:40;;;;24646:36;11433:157;25101:105;25161:13;25194:4;25187:11;;;;;:::i;49923:510::-;50010:20;;;;;;;:10;:20;;;;;:33;;;;;;;;;;50154:107;50169:13;:20;50165:24;;50154:107;;;50234:8;50214:28;;:13;50228:1;50214:16;;;;;;;;:::i;:::-;;;;;;;;;;;;;:28;50211:38;;;50244:5;;50211:38;50191:3;;;;:::i;:::-;;;;50154:107;;;50294:13;:20;50289:25;;50285:86;;50331:13;:28;;;;;;;-1:-1:-1;50331:28:0;;;;;;;;;;;;;;;;50285:86;50404:8;50388:37;;;50414:10;50388:37;;;;14899:14:1;14892:22;14874:41;;14862:2;14847:18;;14734:187;50388:37:0;;;;;;;;49997:436;49923:510;;:::o;29380:1074::-;29607:7;:14;29593:3;:10;:28;29585:81;;;;-1:-1:-1;;;29585:81:0;;23324:2:1;29585:81:0;;;23306:21:1;23363:2;23343:18;;;23336:30;23402:34;23382:18;;;23375:62;23473:10;23453:18;;;23446:38;23501:19;;29585:81:0;23122:404:1;29585:81:0;29685:16;;;29677:66;;;;-1:-1:-1;;;29677:66:0;;18831:2:1;29677:66:0;;;18813:21:1;18870:2;18850:18;;;18843:30;18909:34;18889:18;;;18882:62;18980:7;18960:18;;;18953:35;19005:19;;29677:66:0;18629:401:1;29677:66:0;12880:10;29756:16;29873:421;29897:3;:10;29893:1;:14;29873:421;;;29929:10;29942:3;29946:1;29942:6;;;;;;;;:::i;:::-;;;;;;;29929:19;;29963:14;29980:7;29988:1;29980:10;;;;;;;;:::i;:::-;;;;;;;;;;;;30007:19;30029:13;;;;;;;;;;:19;;;;;;;;;;;;;29980:10;;-1:-1:-1;30071:21:0;;;;30063:76;;;;-1:-1:-1;;;30063:76:0;;20060:2:1;30063:76:0;;;20042:21:1;20099:2;20079:18;;;20072:30;20138:34;20118:18;;;20111:62;20209:12;20189:18;;;20182:40;20239:19;;30063:76:0;19858:406:1;30063:76:0;30183:9;:13;;;;;;;;;;;:19;;;;;;;;;;;30205:20;;;30183:42;;30255:17;;;;;;;:27;;30205:20;;30183:9;30255:27;;30205:20;;30255:27;:::i;:::-;;;;;;;;29914:380;;;29909:3;;;;:::i;:::-;;;29873:421;;;;30341:2;30311:47;;30335:4;30311:47;;30325:8;30311:47;;;30345:3;30350:7;30311:47;;;;;;;:::i;:::-;;;;;;;;30371:75;30407:8;30417:4;30423:2;30427:3;30432:7;30441:4;30371:35;:75::i;:::-;29574:880;29380:1074;;;;;:::o;44501:479::-;44673:13;;;;:22;44665:76;;;;-1:-1:-1;;;44665:76:0;;15955:2:1;44665:76:0;;;15937:21:1;15994:2;15974:18;;;15967:30;16033:34;16013:18;;;16006:62;16104:11;16084:18;;;16077:39;16133:19;;44665:76:0;15753:405:1;44665:76:0;44762:48;44768:2;44772:25;:15;16188:14;;16096:114;44772:25;44799:6;44762:48;;;;;;;;;;;;:5;:48::i;:::-;44823:49;44836:25;:15;16188:14;;16096:114;44836:25;44863:8;44823:12;:49::i;:::-;44924:8;44885:9;:36;44895:25;:15;16188:14;;16096:114;44895:25;44885:36;;;;;;;;;;;-1:-1:-1;44885:36:0;:47;44945:27;:15;16307:19;;16325:1;16307:19;;;16218:127;35566:331;35721:8;35712:17;;:5;:17;;;;35704:71;;;;-1:-1:-1;;;35704:71:0;;22504:2:1;35704:71:0;;;22486:21:1;22543:2;22523:18;;;22516:30;22582:34;22562:18;;;22555:62;22653:11;22633:18;;;22626:39;22682:19;;35704:71:0;22302:405:1;35704:71:0;35786:25;;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;;;;;;;;;;;;35848:41;;14874::1;;;35848::0;;14847:18:1;35848:41:0;;;;;;;35566:331;;;:::o;46608:251::-;46811:40;46828:2;46832:3;46837:7;46846:4;46811:16;:40::i;46095:268::-;39664:4;39485:16;;;:12;:16;;;;;;46186:80;;;;-1:-1:-1;;;46186:80:0;;21262:2:1;46186:80:0;;;21244:21:1;21301:2;21281:18;;;21274:30;21340:34;21320:18;;;21313:62;21411:22;21391:18;;;21384:50;21451:19;;46186:80:0;21060:416:1;46186:80:0;46279:25;;;;:16;:25;;;;;;;;:36;;;;;;;;:::i;:::-;;46347:7;46333:22;46337:8;46333:22;;;;;;:::i;:::-;;;;;;;;46095:268;;:::o;28202:820::-;28390:16;;;28382:66;;;;-1:-1:-1;;;28382:66:0;;18831:2:1;28382:66:0;;;18813:21:1;18870:2;18850:18;;;18843:30;18909:34;18889:18;;;18882:62;18980:7;18960:18;;;18953:35;19005:19;;28382:66:0;18629:401:1;28382:66:0;12880:10;28505:96;12880:10;28536:4;28542:2;28546:21;28564:2;28546:17;:21::i;:::-;28569:25;28587:6;28569:17;:25::i;28505:96::-;28614:19;28636:13;;;;;;;;;;;:19;;;;;;;;;;;28674:21;;;;28666:76;;;;-1:-1:-1;;;28666:76:0;;20060:2:1;28666:76:0;;;20042:21:1;20099:2;20079:18;;;20072:30;20138:34;20118:18;;;20111:62;20209:12;20189:18;;;20182:40;20239:19;;28666:76:0;19858:406:1;28666:76:0;28778:9;:13;;;;;;;;;;;:19;;;;;;;;;;;28800:20;;;28778:42;;28842:17;;;;;;;:27;;28800:20;;28778:9;28842:27;;28800:20;;28842:27;:::i;:::-;;;;-1:-1:-1;;28887:46:0;;;24289:25:1;;;24345:2;24330:18;;24323:34;;;28887:46:0;;;;;;;;;;;;;;;24262:18:1;28887:46:0;;;;;;;28946:68;28977:8;28987:4;28993:2;28997;29001:6;29009:4;28946:30;:68::i;47472:195::-;47627:32;47639:7;47648:2;47652:6;47627:11;:32::i;37834:813::-;38074:13;;;3091:20;3130:8;38070:570;;38110:79;;;;;:43;;;;;;:79;;38154:8;;38164:4;;38170:3;;38175:7;;38184:4;;38110:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38110:79:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;38106:523;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;38502:6;38495:14;;-1:-1:-1;;;38495:14:0;;;;;;;;:::i;38106:523::-;;;38551:62;;-1:-1:-1;;;38551:62:0;;15534:2:1;38551:62:0;;;15516:21:1;15573:2;15553:18;;;15546:30;15612:34;15592:18;;;15585:62;15683:22;15663:18;;;15656:50;15723:19;;38551:62:0;15332:416:1;38106:523:0;38271:60;;;38283:48;38271:60;38267:159;;38356:50;;-1:-1:-1;;;38356:50:0;;16365:2:1;38356:50:0;;;16347:21:1;16404:2;16384:18;;;16377:30;16443:34;16423:18;;;16416:62;16514:10;16494:18;;;16487:38;16542:19;;38356:50:0;16163:404:1;46371:229:0;46554:38;46566:7;46575:2;46579:6;46587:4;46554:11;:38::i;40096:339::-;40275:40;40292:2;40296:3;40301:7;40310:4;40275:16;:40::i;:::-;40331:9;40326:102;40350:3;:10;40346:1;:14;40326:102;;;40406:7;40414:1;40406:10;;;;;;;;:::i;:::-;;;;;;;40382:12;:20;40395:3;40399:1;40395:6;;;;;;;;:::i;:::-;;;;;;;40382:20;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;-1:-1:-1;40362:3:0;;-1:-1:-1;40362:3:0;;:::i;:::-;;;40326:102;;38655:198;38775:16;;;38789:1;38775:16;;;;;;;;;38721;;38750:22;;38775:16;;;;;;;;;;;;-1:-1:-1;38775:16:0;38750:41;;38813:7;38802:5;38808:1;38802:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;38840:5;38655:198;-1:-1:-1;;38655:198:0:o;37082:744::-;37297:13;;;3091:20;3130:8;37293:526;;37333:72;;;;;:38;;;;;;:72;;37372:8;;37382:4;;37388:2;;37392:6;;37400:4;;37333:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;37333:72:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;37329:479;;;;:::i;:::-;37455:55;;;37467:43;37455:55;37451:154;;37535:50;;-1:-1:-1;;;37535:50:0;;16365:2:1;37535:50:0;;;16347:21:1;16404:2;16384:18;;;16377:30;16443:34;16423:18;;;16416:62;16514:10;16494:18;;;16487:38;16542:19;;37535:50:0;16163:404:1;40495:208:0;40626:32;40638:7;40647:2;40651:6;40626:11;:32::i;:::-;40669:16;;;;:12;:16;;;;;:26;;40689:6;;40669:16;:26;;40689:6;;40669:26;:::i;:::-;;;;-1:-1:-1;;;;;40495:208:0:o;39789:242::-;39948:38;39960:7;39969:2;39973:6;39981:4;39948:11;:38::i;:::-;39997:16;;;;:12;:16;;;;;:26;;40017:6;;39997:16;:26;;40017:6;;39997:26;:::i;:::-;;;;-1:-1:-1;;;;;;39789:242:0:o;32697:735::-;32875:16;;;32867:62;;;;-1:-1:-1;;;32867:62:0;;23733:2:1;32867:62:0;;;23715:21:1;23772:2;23752:18;;;23745:30;23811:34;23791:18;;;23784:62;23882:3;23862:18;;;23855:31;23903:19;;32867:62:0;23531:397:1;32867:62:0;32962:7;:14;32948:3;:10;:28;32940:81;;;;-1:-1:-1;;;32940:81:0;;23324:2:1;32940:81:0;;;23306:21:1;23363:2;23343:18;;;23336:30;23402:34;23382:18;;;23375:62;23473:10;23453:18;;;23446:38;23501:19;;32940:81:0;23122:404:1;32940:81:0;12880:10;33034:16;33157:103;33181:3;:10;33177:1;:14;33157:103;;;33238:7;33246:1;33238:10;;;;;;;;:::i;:::-;;;;;;;33213:9;:17;33223:3;33227:1;33223:6;;;;;;;;:::i;:::-;;;;;;;33213:17;;;;;;;;;;;:21;33231:2;33213:21;;;;;;;;;;;;;;;;:35;;;;;;;:::i;:::-;;;;-1:-1:-1;33193:3:0;;-1:-1:-1;33193:3:0;;;:::i;:::-;;;;33157:103;;;;33313:2;33277:53;;33309:1;33277:53;;33291:8;33277:53;;;33317:3;33322:7;33277:53;;;;;;;:::i;:::-;;;;;;;;33343:81;33379:8;33397:1;33401:2;33405:3;33410:7;33419:4;33343:35;:81::i;33682:648::-;33809:18;;;33801:66;;;;-1:-1:-1;;;33801:66:0;;19656:2:1;33801:66:0;;;19638:21:1;19695:2;19675:18;;;19668:30;19734:34;19714:18;;;19707:62;19805:5;19785:18;;;19778:33;19828:19;;33801:66:0;19454:399:1;33801:66:0;12880:10;33924:102;12880:10;33955:4;33880:16;33973:21;33991:2;33973:17;:21::i;:::-;33996:25;34014:6;33996:17;:25::i;:::-;-1:-1:-1;;33924:102:0;;;;;;;;;-1:-1:-1;33924:102:0;;-1:-1:-1;;;29380:1074:0;33924:102;34039:19;34061:13;;;;;;;;;;;:19;;;;;;;;;;;34099:21;;;;34091:70;;;;-1:-1:-1;;;34091:70:0;;17593:2:1;34091:70:0;;;17575:21:1;17632:2;17612:18;;;17605:30;17671:34;17651:18;;;17644:62;17742:6;17722:18;;;17715:34;17766:19;;34091:70:0;17391:400:1;34091:70:0;34197:9;:13;;;;;;;;;;;:19;;;;;;;;;;;;;34219:20;;;34197:42;;34268:54;;24289:25:1;;;24330:18;;;24323:34;;;34197:19:0;;34268:54;;;;;;24262:18:1;34268:54:0;;;;;;;33790:540;;33682:648;;;:::o;31772:569::-;31925:16;;;31917:62;;;;-1:-1:-1;;;31917:62:0;;23733:2:1;31917:62:0;;;23715:21:1;23772:2;23752:18;;;23745:30;23811:34;23791:18;;;23784:62;23882:3;23862:18;;;23855:31;23903:19;;31917:62:0;23531:397:1;31917:62:0;12880:10;32036:102;12880:10;31992:16;32079:2;32083:21;32101:2;32083:17;:21::i;32036:102::-;32151:9;:13;;;;;;;;;;;:17;;;;;;;;;;:27;;32172:6;;32151:9;:27;;32172:6;;32151:27;:::i;:::-;;;;-1:-1:-1;;32194:52:0;;;24289:25:1;;;24345:2;24330:18;;24323:34;;;32194:52:0;;;;;32227:1;;32194:52;;;;;;24262:18:1;32194:52:0;;;;;;;32259:74;32290:8;32308:1;32312:2;32316;32320:6;32328:4;32259:30;:74::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:196:1;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;215:735;269:5;322:3;315:4;307:6;303:17;299:27;289:55;;340:1;337;330:12;289:55;376:6;363:20;402:4;425:43;465:2;425:43;:::i;:::-;497:2;491:9;509:31;537:2;529:6;509:31;:::i;:::-;575:18;;;609:15;;;;-1:-1:-1;644:15:1;;;694:1;690:10;;;678:23;;674:32;;671:41;-1:-1:-1;668:61:1;;;725:1;722;715:12;668:61;747:1;757:163;771:2;768:1;765:9;757:163;;;828:17;;816:30;;866:12;;;;898;;;;789:1;782:9;757:163;;;-1:-1:-1;938:6:1;;215:735;-1:-1:-1;;;;;;;215:735:1:o;1695:160::-;1760:20;;1816:13;;1809:21;1799:32;;1789:60;;1845:1;1842;1835:12;1860:614;1902:5;1955:3;1948:4;1940:6;1936:17;1932:27;1922:55;;1973:1;1970;1963:12;1922:55;2009:6;1996:20;2035:18;2031:2;2028:26;2025:52;;;2057:18;;:::i;:::-;2106:2;2100:9;2118:126;2238:4;2169:66;2162:4;2158:2;2154:13;2150:86;2146:97;2138:6;2118:126;:::i;:::-;2268:2;2260:6;2253:18;2314:3;2307:4;2302:2;2294:6;2290:15;2286:26;2283:35;2280:55;;;2331:1;2328;2321:12;2280:55;2395:2;2388:4;2380:6;2376:17;2369:4;2361:6;2357:17;2344:54;2442:1;2418:15;;;2435:4;2414:26;2407:37;;;;2422:6;1860:614;-1:-1:-1;;;1860:614:1:o;2479:186::-;2538:6;2591:2;2579:9;2570:7;2566:23;2562:32;2559:52;;;2607:1;2604;2597:12;2559:52;2630:29;2649:9;2630:29;:::i;2670:260::-;2738:6;2746;2799:2;2787:9;2778:7;2774:23;2770:32;2767:52;;;2815:1;2812;2805:12;2767:52;2838:29;2857:9;2838:29;:::i;:::-;2828:39;;2886:38;2920:2;2909:9;2905:18;2886:38;:::i;:::-;2876:48;;2670:260;;;;;:::o;2935:943::-;3089:6;3097;3105;3113;3121;3174:3;3162:9;3153:7;3149:23;3145:33;3142:53;;;3191:1;3188;3181:12;3142:53;3214:29;3233:9;3214:29;:::i;:::-;3204:39;;3262:38;3296:2;3285:9;3281:18;3262:38;:::i;:::-;3252:48;;3351:2;3340:9;3336:18;3323:32;3374:18;3415:2;3407:6;3404:14;3401:34;;;3431:1;3428;3421:12;3401:34;3454:61;3507:7;3498:6;3487:9;3483:22;3454:61;:::i;:::-;3444:71;;3568:2;3557:9;3553:18;3540:32;3524:48;;3597:2;3587:8;3584:16;3581:36;;;3613:1;3610;3603:12;3581:36;3636:63;3691:7;3680:8;3669:9;3665:24;3636:63;:::i;:::-;3626:73;;3752:3;3741:9;3737:19;3724:33;3708:49;;3782:2;3772:8;3769:16;3766:36;;;3798:1;3795;3788:12;3766:36;;3821:51;3864:7;3853:8;3842:9;3838:24;3821:51;:::i;:::-;3811:61;;;2935:943;;;;;;;;:::o;3883:606::-;3987:6;3995;4003;4011;4019;4072:3;4060:9;4051:7;4047:23;4043:33;4040:53;;;4089:1;4086;4079:12;4040:53;4112:29;4131:9;4112:29;:::i;:::-;4102:39;;4160:38;4194:2;4183:9;4179:18;4160:38;:::i;:::-;4150:48;;4245:2;4234:9;4230:18;4217:32;4207:42;;4296:2;4285:9;4281:18;4268:32;4258:42;;4351:3;4340:9;4336:19;4323:33;4379:18;4371:6;4368:30;4365:50;;;4411:1;4408;4401:12;4365:50;4434:49;4475:7;4466:6;4455:9;4451:22;4434:49;:::i;4494:1662::-;4665:6;4673;4681;4689;4742:3;4730:9;4721:7;4717:23;4713:33;4710:53;;;4759:1;4756;4749:12;4710:53;4782:29;4801:9;4782:29;:::i;:::-;4772:39;;4830:2;4883;4872:9;4868:18;4855:32;4906:18;4947:2;4939:6;4936:14;4933:34;;;4963:1;4960;4953:12;4933:34;4986:61;5039:7;5030:6;5019:9;5015:22;4986:61;:::i;:::-;4976:71;;5100:2;5089:9;5085:18;5072:32;5056:48;;5129:2;5119:8;5116:16;5113:36;;;5145:1;5142;5135:12;5113:36;5183:8;5172:9;5168:24;5158:34;;5230:7;5223:4;5219:2;5215:13;5211:27;5201:55;;5252:1;5249;5242:12;5201:55;5288:2;5275:16;5310:43;5350:2;5310:43;:::i;:::-;5382:2;5376:9;5394:31;5422:2;5414:6;5394:31;:::i;:::-;5460:18;;;5494:15;;;;-1:-1:-1;5529:11:1;;;5571:1;5567:10;;;5559:19;;5555:28;;5552:41;-1:-1:-1;5549:61:1;;;5606:1;5603;5596:12;5549:61;5628:1;5638:303;5652:2;5649:1;5646:9;5638:303;;;5729:3;5716:17;5765:2;5752:11;5749:19;5746:39;;;5781:1;5778;5771:12;5746:39;5810:56;5858:7;5853:2;5839:11;5835:2;5831:20;5827:29;5810:56;:::i;:::-;5798:69;;-1:-1:-1;5887:12:1;;;;5919;;;;5670:1;5663:9;5638:303;;;-1:-1:-1;5960:6:1;;-1:-1:-1;;;;6019:2:1;6004:18;;5991:32;;-1:-1:-1;6035:16:1;;;6032:36;;;6064:1;6061;6054:12;6032:36;;;6087:63;6142:7;6131:8;6120:9;6116:24;6087:63;:::i;:::-;6077:73;;;4494:1662;;;;;;;:::o;6161:254::-;6226:6;6234;6287:2;6275:9;6266:7;6262:23;6258:32;6255:52;;;6303:1;6300;6293:12;6255:52;6326:29;6345:9;6326:29;:::i;:::-;6316:39;;6374:35;6405:2;6394:9;6390:18;6374:35;:::i;6420:254::-;6488:6;6496;6549:2;6537:9;6528:7;6524:23;6520:32;6517:52;;;6565:1;6562;6555:12;6517:52;6588:29;6607:9;6588:29;:::i;:::-;6578:39;6664:2;6649:18;;;;6636:32;;-1:-1:-1;;;6420:254:1:o;6679:463::-;6766:6;6774;6782;6835:2;6823:9;6814:7;6810:23;6806:32;6803:52;;;6851:1;6848;6841:12;6803:52;6874:29;6893:9;6874:29;:::i;:::-;6864:39;;6950:2;6939:9;6935:18;6922:32;6912:42;;7005:2;6994:9;6990:18;6977:32;7032:18;7024:6;7021:30;7018:50;;;7064:1;7061;7054:12;7018:50;7087:49;7128:7;7119:6;7108:9;7104:22;7087:49;:::i;:::-;7077:59;;;6679:463;;;;;:::o;7147:532::-;7243:6;7251;7259;7267;7320:3;7308:9;7299:7;7295:23;7291:33;7288:53;;;7337:1;7334;7327:12;7288:53;7360:29;7379:9;7360:29;:::i;:::-;7350:39;;7436:2;7425:9;7421:18;7408:32;7398:42;;7491:2;7480:9;7476:18;7463:32;7518:18;7510:6;7507:30;7504:50;;;7550:1;7547;7540:12;7504:50;7573:49;7614:7;7605:6;7594:9;7590:22;7573:49;:::i;:::-;7147:532;;;;-1:-1:-1;7563:59:1;;7669:2;7654:18;7641:32;;-1:-1:-1;;;7147:532:1:o;7684:322::-;7761:6;7769;7777;7830:2;7818:9;7809:7;7805:23;7801:32;7798:52;;;7846:1;7843;7836:12;7798:52;7869:29;7888:9;7869:29;:::i;:::-;7859:39;7945:2;7930:18;;7917:32;;-1:-1:-1;7996:2:1;7981:18;;;7968:32;;7684:322;-1:-1:-1;;;7684:322:1:o;8011:1219::-;8129:6;8137;8190:2;8178:9;8169:7;8165:23;8161:32;8158:52;;;8206:1;8203;8196:12;8158:52;8246:9;8233:23;8275:18;8316:2;8308:6;8305:14;8302:34;;;8332:1;8329;8322:12;8302:34;8370:6;8359:9;8355:22;8345:32;;8415:7;8408:4;8404:2;8400:13;8396:27;8386:55;;8437:1;8434;8427:12;8386:55;8473:2;8460:16;8495:4;8518:43;8558:2;8518:43;:::i;:::-;8590:2;8584:9;8602:31;8630:2;8622:6;8602:31;:::i;:::-;8668:18;;;8702:15;;;;-1:-1:-1;8737:11:1;;;8779:1;8775:10;;;8767:19;;8763:28;;8760:41;-1:-1:-1;8757:61:1;;;8814:1;8811;8804:12;8757:61;8836:1;8827:10;;8846:169;8860:2;8857:1;8854:9;8846:169;;;8917:23;8936:3;8917:23;:::i;:::-;8905:36;;8878:1;8871:9;;;;;8961:12;;;;8993;;8846:169;;;-1:-1:-1;9034:6:1;-1:-1:-1;;9078:18:1;;9065:32;;-1:-1:-1;;9109:16:1;;;9106:36;;;9138:1;9135;9128:12;9106:36;;9161:63;9216:7;9205:8;9194:9;9190:24;9161:63;:::i;:::-;9151:73;;;8011:1219;;;;;:::o;9235:180::-;9291:6;9344:2;9332:9;9323:7;9319:23;9315:32;9312:52;;;9360:1;9357;9350:12;9312:52;9383:26;9399:9;9383:26;:::i;9420:245::-;9478:6;9531:2;9519:9;9510:7;9506:23;9502:32;9499:52;;;9547:1;9544;9537:12;9499:52;9586:9;9573:23;9605:30;9629:5;9605:30;:::i;9670:249::-;9739:6;9792:2;9780:9;9771:7;9767:23;9763:32;9760:52;;;9808:1;9805;9798:12;9760:52;9840:9;9834:16;9859:30;9883:5;9859:30;:::i;9924:180::-;9983:6;10036:2;10024:9;10015:7;10011:23;10007:32;10004:52;;;10052:1;10049;10042:12;10004:52;-1:-1:-1;10075:23:1;;9924:180;-1:-1:-1;9924:180:1:o;10109:248::-;10177:6;10185;10238:2;10226:9;10217:7;10213:23;10209:32;10206:52;;;10254:1;10251;10244:12;10206:52;-1:-1:-1;;10277:23:1;;;10347:2;10332:18;;;10319:32;;-1:-1:-1;10109:248:1:o;10362:435::-;10415:3;10453:5;10447:12;10480:6;10475:3;10468:19;10506:4;10535:2;10530:3;10526:12;10519:19;;10572:2;10565:5;10561:14;10593:1;10603:169;10617:6;10614:1;10611:13;10603:169;;;10678:13;;10666:26;;10712:12;;;;10747:15;;;;10639:1;10632:9;10603:169;;;-1:-1:-1;10788:3:1;;10362:435;-1:-1:-1;;;;;10362:435:1:o;10802:530::-;10843:3;10881:5;10875:12;10908:6;10903:3;10896:19;10933:1;10943:162;10957:6;10954:1;10951:13;10943:162;;;11019:4;11075:13;;;11071:22;;11065:29;11047:11;;;11043:20;;11036:59;10972:12;10943:162;;;11123:6;11120:1;11117:13;11114:87;;;11189:1;11182:4;11173:6;11168:3;11164:16;11160:27;11153:38;11114:87;-1:-1:-1;11246:2:1;11234:15;11251:66;11230:88;11221:98;;;;11321:4;11217:109;;10802:530;-1:-1:-1;;10802:530:1:o;11568:849::-;11890:4;11919:42;12000:2;11992:6;11988:15;11977:9;11970:34;12052:2;12044:6;12040:15;12035:2;12024:9;12020:18;12013:43;;12092:3;12087:2;12076:9;12072:18;12065:31;12119:57;12171:3;12160:9;12156:19;12148:6;12119:57;:::i;:::-;12224:9;12216:6;12212:22;12207:2;12196:9;12192:18;12185:50;12258:44;12295:6;12287;12258:44;:::i;:::-;12244:58;;12351:9;12343:6;12339:22;12333:3;12322:9;12318:19;12311:51;12379:32;12404:6;12396;12379:32;:::i;:::-;12371:40;11568:849;-1:-1:-1;;;;;;;;11568:849:1:o;12422:583::-;12644:4;12673:42;12754:2;12746:6;12742:15;12731:9;12724:34;12806:2;12798:6;12794:15;12789:2;12778:9;12774:18;12767:43;;12846:6;12841:2;12830:9;12826:18;12819:34;12889:6;12884:2;12873:9;12869:18;12862:34;12933:3;12927;12916:9;12912:19;12905:32;12954:45;12994:3;12983:9;12979:19;12971:6;12954:45;:::i;:::-;12946:53;12422:583;-1:-1:-1;;;;;;;12422:583:1:o;13312:681::-;13483:2;13535:21;;;13605:13;;13508:18;;;13627:22;;;13454:4;;13483:2;13706:15;;;;13680:2;13665:18;;;13454:4;13749:218;13763:6;13760:1;13757:13;13749:218;;;13828:13;;13843:42;13824:62;13812:75;;13942:15;;;;13907:12;;;;13785:1;13778:9;13749:218;;;-1:-1:-1;13984:3:1;;13312:681;-1:-1:-1;;;;;;13312:681:1:o;13998:261::-;14177:2;14166:9;14159:21;14140:4;14197:56;14249:2;14238:9;14234:18;14226:6;14197:56;:::i;14264:465::-;14521:2;14510:9;14503:21;14484:4;14547:56;14599:2;14588:9;14584:18;14576:6;14547:56;:::i;:::-;14651:9;14643:6;14639:22;14634:2;14623:9;14619:18;14612:50;14679:44;14716:6;14708;14679:44;:::i;:::-;14671:52;14264:465;-1:-1:-1;;;;;14264:465:1:o;15108:219::-;15257:2;15246:9;15239:21;15220:4;15277:44;15317:2;15306:9;15302:18;15294:6;15277:44;:::i;24368:183::-;24428:4;24461:18;24453:6;24450:30;24447:56;;;24483:18;;:::i;:::-;-1:-1:-1;24528:1:1;24524:14;24540:4;24520:25;;24368:183::o;24556:128::-;24596:3;24627:1;24623:6;24620:1;24617:13;24614:39;;;24633:18;;:::i;:::-;-1:-1:-1;24669:9:1;;24556:128::o;24689:274::-;24729:1;24755;24745:189;;24790:77;24787:1;24780:88;24891:4;24888:1;24881:15;24919:4;24916:1;24909:15;24745:189;-1:-1:-1;24948:9:1;;24689:274::o;24968:228::-;25008:7;25134:1;25066:66;25062:74;25059:1;25056:81;25051:1;25044:9;25037:17;25033:105;25030:131;;;25141:18;;:::i;:::-;-1:-1:-1;25181:9:1;;24968:228::o;25201:125::-;25241:4;25269:1;25266;25263:8;25260:34;;;25274:18;;:::i;:::-;-1:-1:-1;25311:9:1;;25201:125::o;25331:437::-;25410:1;25406:12;;;;25453;;;25474:61;;25528:4;25520:6;25516:17;25506:27;;25474:61;25581:2;25573:6;25570:14;25550:18;25547:38;25544:218;;;25618:77;25615:1;25608:88;25719:4;25716:1;25709:15;25747:4;25744:1;25737:15;25544:218;;25331:437;;;:::o;25773:308::-;25879:66;25874:2;25868:4;25864:13;25860:86;25852:6;25848:99;26013:6;26001:10;25998:22;25977:18;25965:10;25962:34;25959:62;25956:88;;;26024:18;;:::i;:::-;26060:2;26053:22;-1:-1:-1;;25773:308:1:o;26086:195::-;26125:3;26156:66;26149:5;26146:77;26143:103;;;26226:18;;:::i;:::-;-1:-1:-1;26273:1:1;26262:13;;26086:195::o;26286:184::-;26338:77;26335:1;26328:88;26435:4;26432:1;26425:15;26459:4;26456:1;26449:15;26475:184;26527:77;26524:1;26517:88;26624:4;26621:1;26614:15;26648:4;26645:1;26638:15;26664:184;26716:77;26713:1;26706:88;26813:4;26810:1;26803:15;26837:4;26834:1;26827:15;26853:179;26888:3;26930:1;26912:16;26909:23;26906:120;;;26976:1;26973;26970;26955:23;-1:-1:-1;27013:1:1;27007:8;27002:3;26998:18;26906:120;26853:179;:::o;27037:731::-;27076:3;27118:4;27100:16;27097:26;27094:39;;;27037:731;:::o;27094:39::-;27160:2;27154:9;27182:66;27303:2;27285:16;27281:25;27278:1;27272:4;27257:50;27336:4;27330:11;27360:16;27395:18;27466:2;27459:4;27451:6;27447:17;27444:25;27439:2;27431:6;27428:14;27425:45;27422:58;;;27473:5;;;;;27037:731;:::o;27422:58::-;27510:6;27504:4;27500:17;27489:28;;27546:3;27540:10;27573:2;27565:6;27562:14;27559:27;;;27579:5;;;;;;27037:731;:::o;27559:27::-;27663:2;27644:16;27638:4;27634:27;27630:36;27623:4;27614:6;27609:3;27605:16;27601:27;27598:69;27595:82;;;27670:5;;;;;;27037:731;:::o;27595:82::-;27686:57;27737:4;27728:6;27720;27716:19;27712:30;27706:4;27686:57;:::i;:::-;-1:-1:-1;27759:3:1;;27037:731;-1:-1:-1;;;;;27037:731:1:o;27773:177::-;27858:66;27851:5;27847:78;27840:5;27837:89;27827:117;;27940:1;27937;27930:12;27827:117;27773:177;:::o

ipfs://cad69b7a7345c44027befe437b8cced7644b49f05de04ba008ac6cffe3912938