Token

Overview ERC1155

Total Supply:
0 N/A

Holders:
12 addresses

Transfers:
-

Loading
[ Download CSV Export  ] 
Loading
Loading

Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
XPowerParaNft

Compiler Version
v0.8.9+commit.e5eed63a

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-03-14
*/

// Sources flattened with hardhat v2.9.1 https://hardhat.org
// SPDX-License-Identifier: GPL-3.0

// File @openzeppelin/contracts/utils/[email protected]
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// File @openzeppelin/contracts/access/[email protected]
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File @openzeppelin/contracts/utils/introspection/[email protected]
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/token/ERC1155/[email protected]
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/token/ERC1155/[email protected]
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/token/ERC1155/extensions/[email protected]
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/utils/[email protected]
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File @openzeppelin/contracts/utils/introspection/[email protected]
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/token/ERC1155/[email protected]
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.0;

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

// File @openzeppelin/contracts/token/ERC1155/extensions/[email protected]
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/ERC1155Burnable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Extension of {ERC1155} that allows token holders to destroy both their
 * own tokens and those that they have been approved to use.
 *
 * _Available since v3.1._
 */
abstract contract ERC1155Burnable is ERC1155 {
    function burn(
        address account,
        uint256 id,
        uint256 value
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: 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()),
            "ERC1155: caller is not owner nor approved"
        );

        _burnBatch(account, ids, values);
    }
}

// File @openzeppelin/contracts/token/ERC1155/extensions/[email protected]
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/ERC1155Supply.sol)

pragma solidity ^0.8.0;

/**
 * @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 whether 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-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);

        if (from == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                _totalSupply[ids[i]] += amounts[i];
            }
        }

        if (to == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                _totalSupply[ids[i]] -= amounts[i];
            }
        }
    }
}

// File @openzeppelin/contracts/token/ERC20/[email protected]
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File @openzeppelin/contracts/token/ERC20/[email protected]
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, _allowances[owner][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = _allowances[owner][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Spend `amount` form the allowance of `owner` toward `spender`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }
}

// File contracts/MigratableNft.sol
// solhint-disable not-rely-on-time

pragma solidity ^0.8.0;

/**
 * Allows migration of NFTs from an old contract; batch migration is also
 * possible. Further, it is also possible to seal migration manually.
 */
abstract contract MigratableNft is ERC1155, ERC1155Burnable, Ownable {
    /** old contract to migrate from */
    ERC1155Burnable private _token;
    /** flag to control migration */
    bool private _migratable = true;

    /** @param base address of old contract */
    constructor(address base) {
        _token = ERC1155Burnable(base);
    }

    /** import NFT from old contract */
    function migrate(uint256 id, uint256 amount) public virtual {
        require(_migratable, "migration sealed");
        _token.burn(msg.sender, id, amount);
        _mint(msg.sender, id, amount, "");
    }

    /** batch import NFTs from old contract */
    function migrateBatch(uint256[] memory ids, uint256[] memory amounts) public virtual {
        require(_migratable, "migration sealed");
        _token.burnBatch(msg.sender, ids, amounts);
        _mintBatch(msg.sender, ids, amounts, "");
    }

    /** seal migration (manually) */
    function seal() public onlyOwner {
        _migratable = false;
    }
}

// File contracts/XPowerNft.sol
// solhint-disable not-rely-on-time
// solhint-disable no-empty-blocks

pragma solidity ^0.8.0;

/**
 * Allows changing of the NFT's URI (by only the contract owner). Then, the URI
 * should redirect permanently (301) to the corresponding IPFS address.
 */
abstract contract URIMalleable is ERC1155, Ownable {
    function setURI(string memory newuri) public onlyOwner {
        _setURI(newuri);
    }
}

/**
 * NFT base class for the PARA, AQCH & QRSH proof-of-work tokens,
 * where each NFT can only be minted by burning the corresponding amount.
 */
contract XPowerNft is ERC1155, ERC1155Burnable, ERC1155Supply, URIMalleable, MigratableNft {
    /** NFT levels: UNIT, ..., YOTTA *or* higher! */
    uint256 public constant UNIT = 0;
    uint256 public constant KILO = 3;
    uint256 public constant MEGA = 6;
    uint256 public constant GIGA = 9;
    uint256 public constant TERA = 12;
    uint256 public constant PETA = 15;
    uint256 public constant EXA = 18;
    uint256 public constant ZETTA = 21;
    uint256 public constant YOTTA = 24;

    /** (Burnable) XPower contract */
    ERC20Burnable private _xpower;

    constructor(
        string memory uri,
        address xpower,
        address base
    )
        // ERC1155 constructor: uri
        ERC1155(uri)
        // MigratableNft: old contract
        MigratableNft(base)
    {
        _xpower = ERC20Burnable(xpower);
    }

    /** mint particular amount of tokens for given level and address */
    function mint(
        address to,
        uint256 level,
        uint256 amount
    ) public {
        require(level % 3 == 0, "non-ternary level");
        uint256 xpow = amount * (10**level);
        require(xpow > 0, "non-positive amount");
        _xpower.burnFrom(to, xpow);
        _mint(to, idBy(year(), level), amount, "");
    }

    /** mint particular amounts of tokens for given level and address */
    function mintBatch(
        address to,
        uint256[] memory levels,
        uint256[] memory amounts
    ) public {
        uint256 xpow = 0;
        for (uint256 i = 0; i < levels.length; i++) {
            require(levels[i] % 3 == 0, "non-ternary level");
            uint256 delta = amounts[i] * (10**levels[i]);
            require(delta > 0, "non-positive amount");
            xpow += delta;
        }
        _xpower.burnFrom(to, xpow);
        _mintBatch(to, idsBy(year(), levels), amounts, "");
    }

    /** @return current number of years since anno domini */
    function year() public view returns (uint256) {
        uint256 y = (100 * block.timestamp) / (365_25 days);
        require(y > 0, "invalid year");
        return y + 1970;
    }

    /** @return ID composed of (year, level) */
    function idBy(uint256 _year, uint256 level) public pure returns (uint256) {
        require(level < 100, "invalid level");
        return _year * 100 + level;
    }

    /** @return IDs composed of [(year, level) for level in levels] */
    function idsBy(uint256 _year, uint256[] memory levels) public pure returns (uint256[] memory) {
        uint256[] memory ids = new uint256[](levels.length);
        for (uint256 i = 0; i < levels.length; i++) {
            ids[i] = idBy(_year, levels[i]);
        }
        return ids;
    }

    /** burn particular amount of certain token(s) from given address */
    function _burn(
        address from,
        uint256 id,
        uint256 amount
    ) internal override(ERC1155) {
        super._burn(from, id, amount);
    }

    /** burn particular amounts of certain token(s) from given address */
    function _burnBatch(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal override(ERC1155) {
        super._burnBatch(from, ids, amounts);
    }

    /** mint particular amount of certain token(s) for given address */
    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal override(ERC1155) {
        super._mint(to, id, amount, data);
    }

    /** mint particular amounts of certain token(s) for given address */
    function _mintBatch(
        address to,
        uint256[] memory levels,
        uint256[] memory amounts,
        bytes memory data
    ) internal override(ERC1155) {
        super._mintBatch(to, levels, amounts, data);
    }

    /** called before any token transfer; includes (batched) minting and burning */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal override(ERC1155, ERC1155Supply) {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    }
}

/**
 * NFT class for PARA tokens: only the latter are allowed to get burned,
 * to mint the PARA NFTs.
 */
contract XPowerParaNft is XPowerNft {
    constructor(
        string memory uri,
        address xpower,
        address base
    ) XPowerNft(uri, xpower, base) {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"uri","type":"string"},{"internalType":"address","name":"xpower","type":"address"},{"internalType":"address","name":"base","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":"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":[],"name":"EXA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GIGA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"KILO","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MEGA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PETA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TERA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UNIT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"YOTTA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ZETTA","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"account","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"burnBatch","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":[{"internalType":"uint256","name":"_year","type":"uint256"},{"internalType":"uint256","name":"level","type":"uint256"}],"name":"idBy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"_year","type":"uint256"},{"internalType":"uint256[]","name":"levels","type":"uint256[]"}],"name":"idsBy","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"migrate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"migrateBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"level","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"levels","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"mintBatch","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":"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":[],"name":"seal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newuri","type":"string"}],"name":"setURI","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":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"year","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000bb8b956520caa6b8cd71c24cd4b515ad31937a90000000000000000000000000367905ee54817631dbf1d7a1aa15228426cb10ba000000000000000000000000000000000000000000000000000000000000002e68747470733a2f2f7777772e78706f7765726d696e652e636f6d2f6e6674732f706172612f7b69647d2e6a736f6e000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : uri (string): https://www.xpowermine.com/nfts/para/{id}.json
Arg [1] : xpower (address): 0xbb8b956520caa6b8cd71c24cd4b515ad31937a90
Arg [2] : base (address): 0x367905ee54817631dbf1d7a1aa15228426cb10ba

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 000000000000000000000000bb8b956520caa6b8cd71c24cd4b515ad31937a90
Arg [2] : 000000000000000000000000367905ee54817631dbf1d7a1aa15228426cb10ba
Arg [3] : 000000000000000000000000000000000000000000000000000000000000002e
Arg [4] : 68747470733a2f2f7777772e78706f7765726d696e652e636f6d2f6e6674732f
Arg [5] : 706172612f7b69647d2e6a736f6e000000000000000000000000000000000000


Deployed ByteCode Sourcemap

63933:172:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23474:231;;;;;;:::i;:::-;;:::i;:::-;;;597:25:1;;;585:2;570:18;23474:231:0;;;;;;;;22497:310;;;;;;:::i;:::-;;:::i;:::-;;;1184:14:1;;1177:22;1159:41;;1147:2;1132:18;22497:310:0;1019:187:1;59264:89:0;;;;;;:::i;:::-;;:::i;:::-;;23218:105;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;60459:348::-;;;;;;:::i;:::-;;:::i;25413:442::-;;;;;;:::i;:::-;;:::i;58535:248::-;;;;;;:::i;:::-;;:::i;59703:32::-;;59734:1;59703:32;;58270:209;;;;;;:::i;:::-;;:::i;58829:71::-;;;:::i;23871:524::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;39033:122::-;;;;;;:::i;:::-;39090:4;38911:16;;;:12;:16;;;;;;-1:-1:-1;;;39033:122:0;59939:34;;59971:2;59939:34;;61727:167;;;;;;:::i;:::-;;:::i;37737:353::-;;;;;;:::i;:::-;;:::i;59900:32::-;;59930:2;59900:32;;2709:103;;;:::i;59820:33::-;;59851:2;59820:33;;2058:87;2131:6;;2058:87;;-1:-1:-1;;;;;2131:6:0;;;9424:51:1;;9412:2;9397:18;2058:87:0;9278:203:1;59664:32:0;;59695:1;59664:32;;24468:155;;;;;;:::i;:::-;;:::i;38822:113::-;;;;;;:::i;:::-;38884:7;38911:16;;;:12;:16;;;;;;;38822:113;59781:32;;59812:1;59781:32;;61974:297;;;;;;:::i;:::-;;:::i;59742:32::-;;59773:1;59742:32;;59980:34;;60012:2;59980:34;;60889:528;;;;;;:::i;:::-;;:::i;59860:33::-;;59891:2;59860:33;;24695:168;;;;;;:::i;:::-;-1:-1:-1;;;;;24818:27:0;;;24794:4;24818:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;24695:168;24935:401;;;;;;:::i;:::-;;:::i;2967:201::-;;;;;;:::i;:::-;;:::i;61487:183::-;;;:::i;37408:321::-;;;;;;:::i;:::-;;:::i;23474:231::-;23560:7;-1:-1:-1;;;;;23588:21:0;;23580:77;;;;-1:-1:-1;;;23580:77:0;;11528:2:1;23580:77:0;;;11510:21:1;11567:2;11547:18;;;11540:30;11606:34;11586:18;;;11579:62;-1:-1:-1;;;11657:18:1;;;11650:41;11708:19;;23580:77:0;;;;;;;;;-1:-1:-1;23675:9:0;:13;;;;;;;;;;;-1:-1:-1;;;;;23675:22:0;;;;;;;;;;23474:231;;;;;:::o;22497:310::-;22599:4;-1:-1:-1;;;;;;22636:41:0;;-1:-1:-1;;;22636:41:0;;:110;;-1:-1:-1;;;;;;;22694:52:0;;-1:-1:-1;;;22694:52:0;22636:110;:163;;;-1:-1:-1;;;;;;;;;;21375:40:0;;;22763:36;21266:157;59264:89;2131:6;;-1:-1:-1;;;;;2131:6:0;862:10;2278:23;2270:68;;;;-1:-1:-1;;;2270:68:0;;;;;;;:::i;:::-;59330:15:::1;59338:6;59330:7;:15::i;:::-;59264:89:::0;:::o;23218:105::-;23278:13;23311:4;23304:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23218:105;;;:::o;60459:348::-;60576:9;60584:1;60576:5;:9;:::i;:::-;:14;60568:44;;;;-1:-1:-1;;;60568:44:0;;12935:2:1;60568:44:0;;;12917:21:1;12974:2;12954:18;;;12947:30;-1:-1:-1;;;12993:18:1;;;12986:47;13050:18;;60568:44:0;12733:341:1;60568:44:0;60623:12;60648:9;60652:5;60648:2;:9;:::i;:::-;60638:20;;:6;:20;:::i;:::-;60623:35;;60684:1;60677:4;:8;60669:40;;;;-1:-1:-1;;;60669:40:0;;14960:2:1;60669:40:0;;;14942:21:1;14999:2;14979:18;;;14972:30;-1:-1:-1;;;15018:18:1;;;15011:49;15077:18;;60669:40:0;14758:343:1;60669:40:0;60720:7;;:26;;-1:-1:-1;;;60720:26:0;;-1:-1:-1;;;;;15298:32:1;;;60720:26:0;;;15280:51:1;15347:18;;;15340:34;;;60720:7:0;;;;:16;;15253:18:1;;60720:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60757:42;60763:2;60767:19;60772:6;:4;:6::i;:::-;60780:5;60767:4;:19::i;:::-;60788:6;60757:42;;;;;;;;;;;;:5;:42::i;:::-;60557:250;60459:348;;;:::o;25413:442::-;-1:-1:-1;;;;;25646:20:0;;862:10;25646:20;;:60;;-1:-1:-1;25670:36:0;25687:4;862:10;24695:168;:::i;25670:36::-;25624:160;;;;-1:-1:-1;;;25624:160:0;;15587:2:1;25624:160:0;;;15569:21:1;15626:2;15606:18;;;15599:30;15665:34;15645:18;;;15638:62;-1:-1:-1;;;15716:18:1;;;15709:48;15774:19;;25624:160:0;15385:414:1;25624:160:0;25795:52;25818:4;25824:2;25828:3;25833:7;25842:4;25795:22;:52::i;:::-;25413:442;;;;;:::o;58535:248::-;58639:11;;-1:-1:-1;;;58639:11:0;;;;58631:40;;;;-1:-1:-1;;;58631:40:0;;16006:2:1;58631:40:0;;;15988:21:1;16045:2;16025:18;;;16018:30;-1:-1:-1;;;16064:18:1;;;16057:46;16120:18;;58631:40:0;15804:340:1;58631:40:0;58682:6;;:42;;-1:-1:-1;;;58682:42:0;;-1:-1:-1;;;;;58682:6:0;;;;:16;;:42;;58699:10;;58711:3;;58716:7;;58682:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58735:40;58746:10;58758:3;58763:7;58735:40;;;;;;;;;;;;:10;:40::i;:::-;58535:248;;:::o;58270:209::-;58349:11;;-1:-1:-1;;;58349:11:0;;;;58341:40;;;;-1:-1:-1;;;58341:40:0;;16006:2:1;58341:40:0;;;15988:21:1;16045:2;16025:18;;;16018:30;-1:-1:-1;;;16064:18:1;;;16057:46;16120:18;;58341:40:0;15804:340:1;58341:40:0;58392:6;;:35;;-1:-1:-1;;;58392:35:0;;58404:10;58392:35;;;16918:51:1;16985:18;;;16978:34;;;17028:18;;;17021:34;;;-1:-1:-1;;;;;58392:6:0;;;;:11;;16891:18:1;;58392:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58438:33;58444:10;58456:2;58460:6;58438:33;;;;;;;;;;;;:5;:33::i;58829:71::-;2131:6;;-1:-1:-1;;;;;2131:6:0;862:10;2278:23;2270:68;;;;-1:-1:-1;;;2270:68:0;;;;;;;:::i;:::-;58873:11:::1;:19:::0;;-1:-1:-1;;;;58873:19:0::1;::::0;;58829:71::o;23871:524::-;24027:16;24088:3;:10;24069:8;:15;:29;24061:83;;;;-1:-1:-1;;;24061:83:0;;17268:2:1;24061:83:0;;;17250:21:1;17307:2;17287:18;;;17280:30;17346:34;17326:18;;;17319:62;-1:-1:-1;;;17397:18:1;;;17390:39;17446:19;;24061:83:0;17066:405:1;24061:83:0;24157:30;24204:8;:15;-1:-1:-1;;;;;24190:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24190:30:0;;24157:63;;24238:9;24233:122;24257:8;:15;24253:1;:19;24233:122;;;24313:30;24323:8;24332:1;24323:11;;;;;;;;:::i;:::-;;;;;;;24336:3;24340:1;24336:6;;;;;;;;:::i;:::-;;;;;;;24313:9;:30::i;:::-;24294:13;24308:1;24294:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;24274:3;;;:::i;:::-;;;24233:122;;;-1:-1:-1;24374:13:0;23871:524;-1:-1:-1;;;23871:524:0:o;61727:167::-;61792:7;61828:3;61820:5;:11;61812:37;;;;-1:-1:-1;;;61812:37:0;;17950:2:1;61812:37:0;;;17932:21:1;17989:2;17969:18;;;17962:30;-1:-1:-1;;;18008:18:1;;;18001:43;18061:18;;61812:37:0;17748:337:1;61812:37:0;61881:5;61867:11;:5;61875:3;61867:11;:::i;:::-;:19;;;;:::i;:::-;61860:26;61727:167;-1:-1:-1;;;61727:167:0:o;37737:353::-;-1:-1:-1;;;;;37902:23:0;;862:10;37902:23;;:66;;-1:-1:-1;37929:39:0;37946:7;862:10;24695:168;:::i;37929:39::-;37880:157;;;;-1:-1:-1;;;37880:157:0;;;;;;;:::i;:::-;38050:32;38061:7;38070:3;38075:6;38050:10;:32::i;:::-;37737:353;;;:::o;2709:103::-;2131:6;;-1:-1:-1;;;;;2131:6:0;862:10;2278:23;2270:68;;;;-1:-1:-1;;;2270:68:0;;;;;;;:::i;:::-;2774:30:::1;2801:1;2774:18;:30::i;:::-;2709:103::o:0;24468:155::-;24563:52;862:10;24596:8;24606;24563:18;:52::i;61974:297::-;62050:16;62079:20;62116:6;:13;-1:-1:-1;;;;;62102:28:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62102:28:0;;62079:51;;62146:9;62141:102;62165:6;:13;62161:1;:17;62141:102;;;62209:22;62214:5;62221:6;62228:1;62221:9;;;;;;;;:::i;:::-;;;;;;;62209:4;:22::i;:::-;62200:3;62204:1;62200:6;;;;;;;;:::i;:::-;;;;;;;;;;:31;62180:3;;;;:::i;:::-;;;;62141:102;;60889:528;61023:12;61055:9;61050:262;61074:6;:13;61070:1;:17;61050:262;;;61129:1;61117:6;61124:1;61117:9;;;;;;;;:::i;:::-;;;;;;;:13;;;;:::i;:::-;:18;61109:48;;;;-1:-1:-1;;;61109:48:0;;12935:2:1;61109:48:0;;;12917:21:1;12974:2;12954:18;;;12947:30;-1:-1:-1;;;12993:18:1;;;12986:47;13050:18;;61109:48:0;12733:341:1;61109:48:0;61172:13;61206:6;61213:1;61206:9;;;;;;;;:::i;:::-;;;;;;;61202:2;:13;;;;:::i;:::-;61188:7;61196:1;61188:10;;;;;;;;:::i;:::-;;;;;;;:28;;;;:::i;:::-;61172:44;;61247:1;61239:5;:9;61231:41;;;;-1:-1:-1;;;61231:41:0;;14960:2:1;61231:41:0;;;14942:21:1;14999:2;14979:18;;;14972:30;-1:-1:-1;;;15018:18:1;;;15011:49;15077:18;;61231:41:0;14758:343:1;61231:41:0;61287:13;61295:5;61287:13;;:::i;:::-;;;61094:218;61089:3;;;;;:::i;:::-;;;;61050:262;;;-1:-1:-1;61322:7:0;;:26;;-1:-1:-1;;;61322:26:0;;-1:-1:-1;;;;;15298:32:1;;;61322:26:0;;;15280:51:1;15347:18;;;15340:34;;;61322:7:0;;;;:16;;15253:18:1;;61322:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61359:50;61370:2;61374:21;61380:6;:4;:6::i;:::-;61388;61374:5;:21::i;:::-;61397:7;61359:50;;;;;;;;;;;;:10;:50::i;24935:401::-;-1:-1:-1;;;;;25143:20:0;;862:10;25143:20;;:60;;-1:-1:-1;25167:36:0;25184:4;862:10;24695:168;:::i;25167:36::-;25121:151;;;;-1:-1:-1;;;25121:151:0;;;;;;;:::i;:::-;25283:45;25301:4;25307:2;25311;25315:6;25323:4;25283:17;:45::i;2967:201::-;2131:6;;-1:-1:-1;;;;;2131:6:0;862:10;2278:23;2270:68;;;;-1:-1:-1;;;2270:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3056:22:0;::::1;3048:73;;;::::0;-1:-1:-1;;;3048:73:0;;18835:2:1;3048:73:0::1;::::0;::::1;18817:21:1::0;18874:2;18854:18;;;18847:30;18913:34;18893:18;;;18886:62;-1:-1:-1;;;18964:18:1;;;18957:36;19010:19;;3048:73:0::1;18633:402:1::0;3048:73:0::1;3132:28;3151:8;3132:18;:28::i;61487:183::-:0;61524:7;;61583:11;61557:21;61563:15;61557:3;:21;:::i;:::-;61556:39;;;;:::i;:::-;61544:51;;61618:1;61614;:5;61606:30;;;;-1:-1:-1;;;61606:30:0;;19367:2:1;61606:30:0;;;19349:21:1;19406:2;19386:18;;;19379:30;-1:-1:-1;;;19425:18:1;;;19418:42;19477:18;;61606:30:0;19165:336:1;61606:30:0;61654:8;:1;61658:4;61654:8;:::i;:::-;61647:15;;;61487:183;:::o;37408:321::-;-1:-1:-1;;;;;37548:23:0;;862:10;37548:23;;:66;;-1:-1:-1;37575:39:0;37592:7;862:10;24695:168;:::i;37575:39::-;37526:157;;;;-1:-1:-1;;;37526:157:0;;;;;;;:::i;:::-;37696:25;37702:7;37711:2;37715:5;37696;:25::i;29415:88::-;29482:13;;;;:4;;:13;;;;;:::i;62881:196::-;63036:33;63048:2;63052;63056:6;63064:4;63036:11;:33::i;27497:1074::-;27724:7;:14;27710:3;:10;:28;27702:81;;;;-1:-1:-1;;;27702:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;27802:16:0;;27794:66;;;;-1:-1:-1;;;27794:66:0;;;;;;;:::i;:::-;862:10;27917:60;862:10;27948:4;27954:2;27958:3;27963:7;27972:4;27917:20;:60::i;:::-;27995:9;27990:421;28014:3;:10;28010:1;:14;27990:421;;;28046:10;28059:3;28063:1;28059:6;;;;;;;;:::i;:::-;;;;;;;28046:19;;28080:14;28097:7;28105:1;28097:10;;;;;;;;:::i;:::-;;;;;;;;;;;;28124:19;28146:13;;;;;;;;;;-1:-1:-1;;;;;28146:19:0;;;;;;;;;;;;28097:10;;-1:-1:-1;28188:21:0;;;;28180:76;;;;-1:-1:-1;;;28180:76:0;;;;;;;:::i;:::-;28300:9;:13;;;;;;;;;;;-1:-1:-1;;;;;28300:19:0;;;;;;;;;;28322:20;;;28300:42;;28372:17;;;;;;;:27;;28322:20;;28300:9;28372:27;;28322:20;;28372:27;:::i;:::-;;;;;;;;28031:380;;;28026:3;;;;:::i;:::-;;;27990:421;;;;28458:2;-1:-1:-1;;;;;28428:47:0;28452:4;-1:-1:-1;;;;;28428:47:0;28442:8;-1:-1:-1;;;;;28428:47:0;;28462:3;28467:7;28428:47;;;;;;;:::i;:::-;;;;;;;;28488:75;28524:8;28534:4;28540:2;28544:3;28549:7;28558:4;28488:35;:75::i;:::-;27691:880;27497:1074;;;;;:::o;63159:234::-;63342:43;63359:2;63363:6;63371:7;63380:4;63342:16;:43::i;62602:198::-;62756:36;62773:4;62779:3;62784:7;62756:16;:36::i;3328:191::-;3421:6;;;-1:-1:-1;;;;;3438:17:0;;;-1:-1:-1;;;;;;3438:17:0;;;;;;;3471:40;;3421:6;;;3438:17;3421:6;;3471:40;;3402:16;;3471:40;3391:128;3328:191;:::o;33683:331::-;33838:8;-1:-1:-1;;;;;33829:17:0;:5;-1:-1:-1;;;;;33829:17:0;;;33821:71;;;;-1:-1:-1;;;33821:71:0;;21404:2:1;33821:71:0;;;21386:21:1;21443:2;21423:18;;;21416:30;21482:34;21462:18;;;21455:62;-1:-1:-1;;;21533:18:1;;;21526:39;21582:19;;33821:71:0;21202:405:1;33821:71:0;-1:-1:-1;;;;;33903:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;33903:46:0;;;;;;;;;;33965:41;;1159::1;;;33965::0;;1132:18:1;33965:41:0;;;;;;;33683:331;;;:::o;26319:820::-;-1:-1:-1;;;;;26507:16:0;;26499:66;;;;-1:-1:-1;;;26499:66:0;;;;;;;:::i;:::-;862:10;26622:96;862:10;26653:4;26659:2;26663:21;26681:2;26663:17;:21::i;:::-;26686:25;26704:6;26686:17;:25::i;:::-;26713:4;26622:20;:96::i;:::-;26731:19;26753:13;;;;;;;;;;;-1:-1:-1;;;;;26753:19:0;;;;;;;;;;26791:21;;;;26783:76;;;;-1:-1:-1;;;26783:76:0;;;;;;;:::i;:::-;26895:9;:13;;;;;;;;;;;-1:-1:-1;;;;;26895:19:0;;;;;;;;;;26917:20;;;26895:42;;26959:17;;;;;;;:27;;26917:20;;26895:9;26959:27;;26917:20;;26959:27;:::i;:::-;;;;-1:-1:-1;;27004:46:0;;;21786:25:1;;;21842:2;21827:18;;21820:34;;;-1:-1:-1;;;;;27004:46:0;;;;;;;;;;;;;;21759:18:1;27004:46:0;;;;;;;27063:68;27094:8;27104:4;27110:2;27114;27118:6;27126:4;27063:30;:68::i;:::-;26488:651;;26319:820;;;;;:::o;62353:166::-;62482:29;62494:4;62500:2;62504:6;62482:11;:29::i;29889:569::-;-1:-1:-1;;;;;30042:16:0;;30034:62;;;;-1:-1:-1;;;30034:62:0;;;;;;;:::i;:::-;862:10;30153:102;862:10;30109:16;30196:2;30200:21;30218:2;30200:17;:21::i;30153:102::-;30268:9;:13;;;;;;;;;;;-1:-1:-1;;;;;30268:17:0;;;;;;;;;:27;;30289:6;;30268:9;:27;;30289:6;;30268:27;:::i;:::-;;;;-1:-1:-1;;30311:52:0;;;21786:25:1;;;21842:2;21827:18;;21820:34;;;-1:-1:-1;;;;;30311:52:0;;;;30344:1;;30311:52;;;;;;21759:18:1;30311:52:0;;;;;;;30376:74;30407:8;30425:1;30429:2;30433;30437:6;30445:4;30376:30;:74::i;63486:329::-;63741:66;63768:8;63778:4;63784:2;63788:3;63793:7;63802:4;63741:26;:66::i;35951:813::-;-1:-1:-1;;;;;36191:13:0;;13426:19;:23;36187:570;;36227:79;;-1:-1:-1;;;36227:79:0;;-1:-1:-1;;;;;36227:43:0;;;;;:79;;36271:8;;36281:4;;36287:3;;36292:7;;36301:4;;36227:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36227:79:0;;;;;;;;-1:-1:-1;;36227:79:0;;;;;;;;;;;;:::i;:::-;;;36223:523;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;36619:6;36612:14;;-1:-1:-1;;;36612:14:0;;;;;;;;:::i;36223:523::-;;;36668:62;;-1:-1:-1;;;36668:62:0;;24415:2:1;36668:62:0;;;24397:21:1;24454:2;24434:18;;;24427:30;24493:34;24473:18;;;24466:62;-1:-1:-1;;;24544:18:1;;;24537:50;24604:19;;36668:62:0;24213:416:1;36223:523:0;-1:-1:-1;;;;;;36388:60:0;;-1:-1:-1;;;36388:60:0;36384:159;;36473:50;;-1:-1:-1;;;36473:50:0;;;;;;;:::i;30814:735::-;-1:-1:-1;;;;;30992:16:0;;30984:62;;;;-1:-1:-1;;;30984:62:0;;;;;;;:::i;:::-;31079:7;:14;31065:3;:10;:28;31057:81;;;;-1:-1:-1;;;31057:81:0;;;;;;;:::i;:::-;862:10;31195:66;862:10;31151:16;31238:2;31242:3;31247:7;31256:4;31195:20;:66::i;:::-;31279:9;31274:103;31298:3;:10;31294:1;:14;31274:103;;;31355:7;31363:1;31355:10;;;;;;;;:::i;:::-;;;;;;;31330:9;:17;31340:3;31344:1;31340:6;;;;;;;;:::i;:::-;;;;;;;31330:17;;;;;;;;;;;:21;31348:2;-1:-1:-1;;;;;31330:21:0;-1:-1:-1;;;;;31330:21:0;;;;;;;;;;;;;:35;;;;;;;:::i;:::-;;;;-1:-1:-1;31310:3:0;;-1:-1:-1;31310:3:0;;;:::i;:::-;;;;31274:103;;;;31430:2;-1:-1:-1;;;;;31394:53:0;31426:1;-1:-1:-1;;;;;31394:53:0;31408:8;-1:-1:-1;;;;;31394:53:0;;31434:3;31439:7;31394:53;;;;;;;:::i;:::-;;;;;;;;31460:81;31496:8;31514:1;31518:2;31522:3;31527:7;31536:4;31460:35;:81::i;32650:891::-;-1:-1:-1;;;;;32802:18:0;;32794:66;;;;-1:-1:-1;;;32794:66:0;;;;;;;:::i;:::-;32893:7;:14;32879:3;:10;:28;32871:81;;;;-1:-1:-1;;;32871:81:0;;;;;;;:::i;:::-;32965:16;862:10;32965:31;;33009:66;33030:8;33040:4;33054:1;33058:3;33063:7;33009:66;;;;;;;;;;;;:20;:66::i;:::-;33093:9;33088:373;33112:3;:10;33108:1;:14;33088:373;;;33144:10;33157:3;33161:1;33157:6;;;;;;;;:::i;:::-;;;;;;;33144:19;;33178:14;33195:7;33203:1;33195:10;;;;;;;;:::i;:::-;;;;;;;;;;;;33222:19;33244:13;;;;;;;;;;-1:-1:-1;;;;;33244:19:0;;;;;;;;;;;;33195:10;;-1:-1:-1;33286:21:0;;;;33278:70;;;;-1:-1:-1;;;33278:70:0;;;;;;;:::i;:::-;33392:9;:13;;;;;;;;;;;-1:-1:-1;;;;;33392:19:0;;;;;;;;;;33414:20;;33392:42;;33124:3;;;;:::i;:::-;;;;33088:373;;;;33516:1;-1:-1:-1;;;;;33478:55:0;33502:4;-1:-1:-1;;;;;33478:55:0;33492:8;-1:-1:-1;;;;;33478:55:0;;33520:3;33525:7;33478:55;;;;;;;:::i;:::-;;;;;;;;32783:758;32650:891;;;:::o;36772:198::-;36892:16;;;36906:1;36892:16;;;;;;;;;36838;;36867:22;;36892:16;;;;;;;;;;;;-1:-1:-1;36892:16:0;36867:41;;36930:7;36919:5;36925:1;36919:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;36957:5;36772:198;-1:-1:-1;;36772:198:0:o;35199:744::-;-1:-1:-1;;;;;35414:13:0;;13426:19;:23;35410:526;;35450:72;;-1:-1:-1;;;35450:72:0;;-1:-1:-1;;;;;35450:38:0;;;;;:72;;35489:8;;35499:4;;35505:2;;35509:6;;35517:4;;35450:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35450:72:0;;;;;;;;-1:-1:-1;;35450:72:0;;;;;;;;;;;;:::i;:::-;;;35446:479;;;;:::i;:::-;-1:-1:-1;;;;;;35572:55:0;;-1:-1:-1;;;35572:55:0;35568:154;;35652:50;;-1:-1:-1;;;35652:50:0;;;;;;;:::i;31799:648::-;-1:-1:-1;;;;;31926:18:0;;31918:66;;;;-1:-1:-1;;;31918:66:0;;;;;;;:::i;:::-;862:10;32041:102;862:10;32072:4;31997:16;32090:21;32108:2;32090:17;:21::i;:::-;32113:25;32131:6;32113:17;:25::i;:::-;32041:102;;;;;;;;;;;;:20;:102::i;:::-;32156:19;32178:13;;;;;;;;;;;-1:-1:-1;;;;;32178:19:0;;;;;;;;;;32216:21;;;;32208:70;;;;-1:-1:-1;;;32208:70:0;;;;;;;:::i;:::-;32314:9;:13;;;;;;;;;;;-1:-1:-1;;;;;32314:19:0;;;;;;;;;;;;32336:20;;;32314:42;;32385:54;;21786:25:1;;;21827:18;;;21820:34;;;32314:19:0;;32385:54;;;;;;21759:18:1;32385:54:0;;;;;;;31907:540;;31799:648;;;:::o;39230:655::-;-1:-1:-1;;;;;39552:18:0;;39548:160;;39592:9;39587:110;39611:3;:10;39607:1;:14;39587:110;;;39671:7;39679:1;39671:10;;;;;;;;:::i;:::-;;;;;;;39647:12;:20;39660:3;39664:1;39660:6;;;;;;;;:::i;:::-;;;;;;;39647:20;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;-1:-1:-1;39623:3:0;;-1:-1:-1;39623:3:0;;:::i;:::-;;;39587:110;;;;39548:160;-1:-1:-1;;;;;39724:16:0;;39720:158;;39762:9;39757:110;39781:3;:10;39777:1;:14;39757:110;;;39841:7;39849:1;39841:10;;;;;;;;:::i;:::-;;;;;;;39817:12;:20;39830:3;39834:1;39830:6;;;;;;;;:::i;:::-;;;;;;;39817:20;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;-1:-1:-1;39793:3:0;;-1:-1:-1;39793:3:0;;:::i;:::-;;;39757:110;;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:254::-;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;360:29;379:9;360:29;:::i;:::-;350:39;436:2;421:18;;;;408:32;;-1:-1:-1;;;192:254:1:o;633:131::-;-1:-1:-1;;;;;;707:32:1;;697:43;;687:71;;754:1;751;744:12;769:245;827:6;880:2;868:9;859:7;855:23;851:32;848:52;;;896:1;893;886:12;848:52;935:9;922:23;954:30;978:5;954:30;:::i;1211:127::-;1272:10;1267:3;1263:20;1260:1;1253:31;1303:4;1300:1;1293:15;1327:4;1324:1;1317:15;1343:249;1453:2;1434:13;;-1:-1:-1;;1430:27:1;1418:40;;-1:-1:-1;;;;;1473:34:1;;1509:22;;;1470:62;1467:88;;;1535:18;;:::i;:::-;1571:2;1564:22;-1:-1:-1;;1343:249:1:o;1597:469::-;1662:5;-1:-1:-1;;;;;1688:6:1;1685:30;1682:56;;;1718:18;;:::i;:::-;1767:2;1761:9;1779:69;1836:2;1815:15;;-1:-1:-1;;1811:29:1;1842:4;1807:40;1761:9;1779:69;:::i;:::-;1866:6;1857:15;;1896:6;1888;1881:22;1936:3;1927:6;1922:3;1918:16;1915:25;1912:45;;;1953:1;1950;1943:12;1912:45;2003:6;1998:3;1991:4;1983:6;1979:17;1966:44;2058:1;2051:4;2042:6;2034;2030:19;2026:30;2019:41;;1597:469;;;;;:::o;2071:451::-;2140:6;2193:2;2181:9;2172:7;2168:23;2164:32;2161:52;;;2209:1;2206;2199:12;2161:52;2249:9;2236:23;-1:-1:-1;;;;;2274:6:1;2271:30;2268:50;;;2314:1;2311;2304:12;2268:50;2337:22;;2390:4;2382:13;;2378:27;-1:-1:-1;2368:55:1;;2419:1;2416;2409:12;2368:55;2442:74;2508:7;2503:2;2490:16;2485:2;2481;2477:11;2442:74;:::i;:::-;2432:84;2071:451;-1:-1:-1;;;;2071:451:1:o;2527:180::-;2586:6;2639:2;2627:9;2618:7;2614:23;2610:32;2607:52;;;2655:1;2652;2645:12;2607:52;-1:-1:-1;2678:23:1;;2527:180;-1:-1:-1;2527:180:1:o;2712:472::-;2754:3;2792:5;2786:12;2819:6;2814:3;2807:19;2844:1;2854:162;2868:6;2865:1;2862:13;2854:162;;;2930:4;2986:13;;;2982:22;;2976:29;2958:11;;;2954:20;;2947:59;2883:12;2854:162;;;3034:6;3031:1;3028:13;3025:87;;;3100:1;3093:4;3084:6;3079:3;3075:16;3071:27;3064:38;3025:87;-1:-1:-1;3166:2:1;3145:15;-1:-1:-1;;3141:29:1;3132:39;;;;3173:4;3128:50;;2712:472;-1:-1:-1;;2712:472:1:o;3189:220::-;3338:2;3327:9;3320:21;3301:4;3358:45;3399:2;3388:9;3384:18;3376:6;3358:45;:::i;3414:322::-;3491:6;3499;3507;3560:2;3548:9;3539:7;3535:23;3531:32;3528:52;;;3576:1;3573;3566:12;3528:52;3599:29;3618:9;3599:29;:::i;:::-;3589:39;3675:2;3660:18;;3647:32;;-1:-1:-1;3726:2:1;3711:18;;;3698:32;;3414:322;-1:-1:-1;;;3414:322:1:o;3741:183::-;3801:4;-1:-1:-1;;;;;3826:6:1;3823:30;3820:56;;;3856:18;;:::i;:::-;-1:-1:-1;3901:1:1;3897:14;3913:4;3893:25;;3741:183::o;3929:724::-;3983:5;4036:3;4029:4;4021:6;4017:17;4013:27;4003:55;;4054:1;4051;4044:12;4003:55;4090:6;4077:20;4116:4;4139:43;4179:2;4139:43;:::i;:::-;4211:2;4205:9;4223:31;4251:2;4243:6;4223:31;:::i;:::-;4289:18;;;4381:1;4377:10;;;;4365:23;;4361:32;;;4323:15;;;;-1:-1:-1;4405:15:1;;;4402:35;;;4433:1;4430;4423:12;4402:35;4469:2;4461:6;4457:15;4481:142;4497:6;4492:3;4489:15;4481:142;;;4563:17;;4551:30;;4601:12;;;;4514;;4481:142;;;-1:-1:-1;4641:6:1;3929:724;-1:-1:-1;;;;;;3929:724:1:o;4658:221::-;4700:5;4753:3;4746:4;4738:6;4734:17;4730:27;4720:55;;4771:1;4768;4761:12;4720:55;4793:80;4869:3;4860:6;4847:20;4840:4;4832:6;4828:17;4793:80;:::i;4884:943::-;5038:6;5046;5054;5062;5070;5123:3;5111:9;5102:7;5098:23;5094:33;5091:53;;;5140:1;5137;5130:12;5091:53;5163:29;5182:9;5163:29;:::i;:::-;5153:39;;5211:38;5245:2;5234:9;5230:18;5211:38;:::i;:::-;5201:48;;5300:2;5289:9;5285:18;5272:32;-1:-1:-1;;;;;5364:2:1;5356:6;5353:14;5350:34;;;5380:1;5377;5370:12;5350:34;5403:61;5456:7;5447:6;5436:9;5432:22;5403:61;:::i;:::-;5393:71;;5517:2;5506:9;5502:18;5489:32;5473:48;;5546:2;5536:8;5533:16;5530:36;;;5562:1;5559;5552:12;5530:36;5585:63;5640:7;5629:8;5618:9;5614:24;5585:63;:::i;:::-;5575:73;;5701:3;5690:9;5686:19;5673:33;5657:49;;5731:2;5721:8;5718:16;5715:36;;;5747:1;5744;5737:12;5715:36;;5770:51;5813:7;5802:8;5791:9;5787:24;5770:51;:::i;:::-;5760:61;;;4884:943;;;;;;;;:::o;5832:595::-;5950:6;5958;6011:2;5999:9;5990:7;5986:23;5982:32;5979:52;;;6027:1;6024;6017:12;5979:52;6067:9;6054:23;-1:-1:-1;;;;;6137:2:1;6129:6;6126:14;6123:34;;;6153:1;6150;6143:12;6123:34;6176:61;6229:7;6220:6;6209:9;6205:22;6176:61;:::i;:::-;6166:71;;6290:2;6279:9;6275:18;6262:32;6246:48;;6319:2;6309:8;6306:16;6303:36;;;6335:1;6332;6325:12;6303:36;;6358:63;6413:7;6402:8;6391:9;6387:24;6358:63;:::i;:::-;6348:73;;;5832:595;;;;;:::o;6432:248::-;6500:6;6508;6561:2;6549:9;6540:7;6536:23;6532:32;6529:52;;;6577:1;6574;6567:12;6529:52;-1:-1:-1;;6600:23:1;;;6670:2;6655:18;;;6642:32;;-1:-1:-1;6432:248:1:o;6685:1208::-;6803:6;6811;6864:2;6852:9;6843:7;6839:23;6835:32;6832:52;;;6880:1;6877;6870:12;6832:52;6920:9;6907:23;-1:-1:-1;;;;;6990:2:1;6982:6;6979:14;6976:34;;;7006:1;7003;6996:12;6976:34;7044:6;7033:9;7029:22;7019:32;;7089:7;7082:4;7078:2;7074:13;7070:27;7060:55;;7111:1;7108;7101:12;7060:55;7147:2;7134:16;7169:4;7192:43;7232:2;7192:43;:::i;:::-;7264:2;7258:9;7276:31;7304:2;7296:6;7276:31;:::i;:::-;7342:18;;;7430:1;7426:10;;;;7418:19;;7414:28;;;7376:15;;;;-1:-1:-1;7454:19:1;;;7451:39;;;7486:1;7483;7476:12;7451:39;7510:11;;;;7530:148;7546:6;7541:3;7538:15;7530:148;;;7612:23;7631:3;7612:23;:::i;:::-;7600:36;;7563:12;;;;7656;;;;7530:148;;;7697:6;-1:-1:-1;;7741:18:1;;7728:32;;-1:-1:-1;;7772:16:1;;;7769:36;;;7801:1;7798;7791:12;7898:435;7951:3;7989:5;7983:12;8016:6;8011:3;8004:19;8042:4;8071:2;8066:3;8062:12;8055:19;;8108:2;8101:5;8097:14;8129:1;8139:169;8153:6;8150:1;8147:13;8139:169;;;8214:13;;8202:26;;8248:12;;;;8283:15;;;;8175:1;8168:9;8139:169;;;-1:-1:-1;8324:3:1;;7898:435;-1:-1:-1;;;;;7898:435:1:o;8338:261::-;8517:2;8506:9;8499:21;8480:4;8537:56;8589:2;8578:9;8574:18;8566:6;8537:56;:::i;8604:669::-;8731:6;8739;8747;8800:2;8788:9;8779:7;8775:23;8771:32;8768:52;;;8816:1;8813;8806:12;8768:52;8839:29;8858:9;8839:29;:::i;:::-;8829:39;;8919:2;8908:9;8904:18;8891:32;-1:-1:-1;;;;;8983:2:1;8975:6;8972:14;8969:34;;;8999:1;8996;8989:12;8969:34;9022:61;9075:7;9066:6;9055:9;9051:22;9022:61;:::i;:::-;9012:71;;9136:2;9125:9;9121:18;9108:32;9092:48;;9165:2;9155:8;9152:16;9149:36;;;9181:1;9178;9171:12;9149:36;;9204:63;9259:7;9248:8;9237:9;9233:24;9204:63;:::i;:::-;9194:73;;;8604:669;;;;;:::o;9486:347::-;9551:6;9559;9612:2;9600:9;9591:7;9587:23;9583:32;9580:52;;;9628:1;9625;9618:12;9580:52;9651:29;9670:9;9651:29;:::i;:::-;9641:39;;9730:2;9719:9;9715:18;9702:32;9777:5;9770:13;9763:21;9756:5;9753:32;9743:60;;9799:1;9796;9789:12;9743:60;9822:5;9812:15;;;9486:347;;;;;:::o;9838:416::-;9931:6;9939;9992:2;9980:9;9971:7;9967:23;9963:32;9960:52;;;10008:1;10005;9998:12;9960:52;10044:9;10031:23;10021:33;;10105:2;10094:9;10090:18;10077:32;-1:-1:-1;;;;;10124:6:1;10121:30;10118:50;;;10164:1;10161;10154:12;10118:50;10187:61;10240:7;10231:6;10220:9;10216:22;10187:61;:::i;10259:260::-;10327:6;10335;10388:2;10376:9;10367:7;10363:23;10359:32;10356:52;;;10404:1;10401;10394:12;10356:52;10427:29;10446:9;10427:29;:::i;:::-;10417:39;;10475:38;10509:2;10498:9;10494:18;10475:38;:::i;:::-;10465:48;;10259:260;;;;;:::o;10524:606::-;10628:6;10636;10644;10652;10660;10713:3;10701:9;10692:7;10688:23;10684:33;10681:53;;;10730:1;10727;10720:12;10681:53;10753:29;10772:9;10753:29;:::i;:::-;10743:39;;10801:38;10835:2;10824:9;10820:18;10801:38;:::i;:::-;10791:48;;10886:2;10875:9;10871:18;10858:32;10848:42;;10937:2;10926:9;10922:18;10909:32;10899:42;;10992:3;10981:9;10977:19;10964:33;-1:-1:-1;;;;;11012:6:1;11009:30;11006:50;;;11052:1;11049;11042:12;11006:50;11075:49;11116:7;11107:6;11096:9;11092:22;11075:49;:::i;11135:186::-;11194:6;11247:2;11235:9;11226:7;11222:23;11218:32;11215:52;;;11263:1;11260;11253:12;11215:52;11286:29;11305:9;11286:29;:::i;11738:356::-;11940:2;11922:21;;;11959:18;;;11952:30;12018:34;12013:2;11998:18;;11991:62;12085:2;12070:18;;11738:356::o;12099:380::-;12178:1;12174:12;;;;12221;;;12242:61;;12296:4;12288:6;12284:17;12274:27;;12242:61;12349:2;12341:6;12338:14;12318:18;12315:38;12312:161;;;12395:10;12390:3;12386:20;12383:1;12376:31;12430:4;12427:1;12420:15;12458:4;12455:1;12448:15;12312:161;;12099:380;;;:::o;12484:127::-;12545:10;12540:3;12536:20;12533:1;12526:31;12576:4;12573:1;12566:15;12600:4;12597:1;12590:15;12616:112;12648:1;12674;12664:35;;12679:18;;:::i;:::-;-1:-1:-1;12713:9:1;;12616:112::o;13079:127::-;13140:10;13135:3;13131:20;13128:1;13121:31;13171:4;13168:1;13161:15;13195:4;13192:1;13185:15;13211:422;13300:1;13343:5;13300:1;13357:270;13378:7;13368:8;13365:21;13357:270;;;13437:4;13433:1;13429:6;13425:17;13419:4;13416:27;13413:53;;;13446:18;;:::i;:::-;13496:7;13486:8;13482:22;13479:55;;;13516:16;;;;13479:55;13595:22;;;;13555:15;;;;13357:270;;;13361:3;13211:422;;;;;:::o;13638:806::-;13687:5;13717:8;13707:80;;-1:-1:-1;13758:1:1;13772:5;;13707:80;13806:4;13796:76;;-1:-1:-1;13843:1:1;13857:5;;13796:76;13888:4;13906:1;13901:59;;;;13974:1;13969:130;;;;13881:218;;13901:59;13931:1;13922:10;;13945:5;;;13969:130;14006:3;13996:8;13993:17;13990:43;;;14013:18;;:::i;:::-;-1:-1:-1;;14069:1:1;14055:16;;14084:5;;13881:218;;14183:2;14173:8;14170:16;14164:3;14158:4;14155:13;14151:36;14145:2;14135:8;14132:16;14127:2;14121:4;14118:12;14114:35;14111:77;14108:159;;;-1:-1:-1;14220:19:1;;;14252:5;;14108:159;14299:34;14324:8;14318:4;14299:34;:::i;:::-;14369:6;14365:1;14361:6;14357:19;14348:7;14345:32;14342:58;;;14380:18;;:::i;:::-;14418:20;;13638:806;-1:-1:-1;;;13638:806:1:o;14449:131::-;14509:5;14538:36;14565:8;14559:4;14538:36;:::i;14585:168::-;14625:7;14691:1;14687;14683:6;14679:14;14676:1;14673:21;14668:1;14661:9;14654:17;14650:45;14647:71;;;14698:18;;:::i;:::-;-1:-1:-1;14738:9:1;;14585:168::o;16149:562::-;-1:-1:-1;;;;;16434:32:1;;16416:51;;16503:2;16498;16483:18;;16476:30;;;-1:-1:-1;;16529:56:1;;16566:18;;16558:6;16529:56;:::i;:::-;16633:9;16625:6;16621:22;16616:2;16605:9;16601:18;16594:50;16661:44;16698:6;16690;16661:44;:::i;:::-;16653:52;16149:562;-1:-1:-1;;;;;;16149:562:1:o;17476:127::-;17537:10;17532:3;17528:20;17525:1;17518:31;17568:4;17565:1;17558:15;17592:4;17589:1;17582:15;17608:135;17647:3;-1:-1:-1;;17668:17:1;;17665:43;;;17688:18;;:::i;:::-;-1:-1:-1;17735:1:1;17724:13;;17608:135::o;18090:128::-;18130:3;18161:1;18157:6;18154:1;18151:13;18148:39;;;18167:18;;:::i;:::-;-1:-1:-1;18203:9:1;;18090:128::o;18223:405::-;18425:2;18407:21;;;18464:2;18444:18;;;18437:30;18503:34;18498:2;18483:18;;18476:62;-1:-1:-1;;;18569:2:1;18554:18;;18547:39;18618:3;18603:19;;18223:405::o;19040:120::-;19080:1;19106;19096:35;;19111:18;;:::i;:::-;-1:-1:-1;19145:9:1;;19040:120::o;19506:404::-;19708:2;19690:21;;;19747:2;19727:18;;;19720:30;19786:34;19781:2;19766:18;;19759:62;-1:-1:-1;;;19852:2:1;19837:18;;19830:38;19900:3;19885:19;;19506:404::o;19915:401::-;20117:2;20099:21;;;20156:2;20136:18;;;20129:30;20195:34;20190:2;20175:18;;20168:62;-1:-1:-1;;;20261:2:1;20246:18;;20239:35;20306:3;20291:19;;19915:401::o;20321:406::-;20523:2;20505:21;;;20562:2;20542:18;;;20535:30;20601:34;20596:2;20581:18;;20574:62;-1:-1:-1;;;20667:2:1;20652:18;;20645:40;20717:3;20702:19;;20321:406::o;20732:465::-;20989:2;20978:9;20971:21;20952:4;21015:56;21067:2;21056:9;21052:18;21044:6;21015:56;:::i;:::-;21119:9;21111:6;21107:22;21102:2;21091:9;21087:18;21080:50;21147:44;21184:6;21176;21147:44;:::i;:::-;21139:52;20732:465;-1:-1:-1;;;;;20732:465:1:o;21865:397::-;22067:2;22049:21;;;22106:2;22086:18;;;22079:30;22145:34;22140:2;22125:18;;22118:62;-1:-1:-1;;;22211:2:1;22196:18;;22189:31;22252:3;22237:19;;21865:397::o;22267:827::-;-1:-1:-1;;;;;22664:15:1;;;22646:34;;22716:15;;22711:2;22696:18;;22689:43;22626:3;22763:2;22748:18;;22741:31;;;22589:4;;22795:57;;22832:19;;22824:6;22795:57;:::i;:::-;22900:9;22892:6;22888:22;22883:2;22872:9;22868:18;22861:50;22934:44;22971:6;22963;22934:44;:::i;:::-;22920:58;;23027:9;23019:6;23015:22;23009:3;22998:9;22994:19;22987:51;23055:33;23081:6;23073;23055:33;:::i;:::-;23047:41;22267:827;-1:-1:-1;;;;;;;;22267:827:1:o;23099:249::-;23168:6;23221:2;23209:9;23200:7;23196:23;23192:32;23189:52;;;23237:1;23234;23227:12;23189:52;23269:9;23263:16;23288:30;23312:5;23288:30;:::i;23353:179::-;23388:3;23430:1;23412:16;23409:23;23406:120;;;23476:1;23473;23470;23455:23;-1:-1:-1;23513:1:1;23507:8;23502:3;23498:18;23406:120;23353:179;:::o;23537:671::-;23576:3;23618:4;23600:16;23597:26;23594:39;;;23537:671;:::o;23594:39::-;23660:2;23654:9;-1:-1:-1;;23725:16:1;23721:25;;23718:1;23654:9;23697:50;23776:4;23770:11;23800:16;-1:-1:-1;;;;;23906:2:1;23899:4;23891:6;23887:17;23884:25;23879:2;23871:6;23868:14;23865:45;23862:58;;;23913:5;;;;;23537:671;:::o;23862:58::-;23950:6;23944:4;23940:17;23929:28;;23986:3;23980:10;24013:2;24005:6;24002:14;23999:27;;;24019:5;;;;;;23537:671;:::o;23999:27::-;24103:2;24084:16;24078:4;24074:27;24070:36;24063:4;24054:6;24049:3;24045:16;24041:27;24038:69;24035:82;;;24110:5;;;;;;23537:671;:::o;24035:82::-;24126:57;24177:4;24168:6;24160;24156:19;24152:30;24146:4;24126:57;:::i;:::-;-1:-1:-1;24199:3:1;;23537:671;-1:-1:-1;;;;;23537:671:1:o;24634:404::-;24836:2;24818:21;;;24875:2;24855:18;;;24848:30;24914:34;24909:2;24894:18;;24887:62;-1:-1:-1;;;24980:2:1;24965:18;;24958:38;25028:3;25013:19;;24634:404::o;25043:399::-;25245:2;25227:21;;;25284:2;25264:18;;;25257:30;25323:34;25318:2;25303:18;;25296:62;-1:-1:-1;;;25389:2:1;25374:18;;25367:33;25432:3;25417:19;;25043:399::o;25447:400::-;25649:2;25631:21;;;25688:2;25668:18;;;25661:30;25727:34;25722:2;25707:18;;25700:62;-1:-1:-1;;;25793:2:1;25778:18;;25771:34;25837:3;25822:19;;25447:400::o;25852:561::-;-1:-1:-1;;;;;26149:15:1;;;26131:34;;26201:15;;26196:2;26181:18;;26174:43;26248:2;26233:18;;26226:34;;;26291:2;26276:18;;26269:34;;;26111:3;26334;26319:19;;26312:32;;;26074:4;;26361:46;;26387:19;;26379:6;26361:46;:::i;:::-;26353:54;25852:561;-1:-1:-1;;;;;;;25852:561:1:o;26418:125::-;26458:4;26486:1;26483;26480:8;26477:34;;;26491:18;;:::i;:::-;-1:-1:-1;26528:9:1;;26418:125::o

Swarm Source

ipfs://a14924afdc8ad46c23efbbb07443e38e109b5431804263f9e3a0f6a2a670e6c7
Loading