Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

import {IDiamondCut} from "./interfaces/IDiamondCut.sol";
import {Lively1155Diamond} from "./Lively1155Diamond.sol";

/// @custom:security-contact [email protected]
contract umLIVE is Lively1155Diamond {
    constructor(
        IDiamondCut.FacetCut[] memory _diamondCut,
        Lively1155Diamond.DiamondArgs memory _args
    ) payable Lively1155Diamond(_diamondCut, _args) {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides a set of functions to operate with Base64 strings.
 *
 * _Available since v4.5._
 */
library Base64Upgradeable {
    /**
     * @dev Base64 Encoding/Decoding Table
     */
    string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /**
     * @dev Converts a `bytes` to its Bytes64 `string` representation.
     */
    function encode(bytes memory data) internal pure returns (string memory) {
        /**
         * Inspired by Brecht Devos (Brechtpd) implementation - MIT licence
         * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol
         */
        if (data.length == 0) return "";

        // Loads the table into memory
        string memory table = _TABLE;

        // Encoding takes 3 bytes chunks of binary data from `bytes` data parameter
        // and split into 4 numbers of 6 bits.
        // The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up
        // - `data.length + 2`  -> Round up
        // - `/ 3`              -> Number of 3-bytes chunks
        // - `4 *`              -> 4 characters for each chunk
        string memory result = new string(4 * ((data.length + 2) / 3));

        /// @solidity memory-safe-assembly
        assembly {
            // Prepare the lookup table (skip the first "length" byte)
            let tablePtr := add(table, 1)

            // Prepare result pointer, jump over length
            let resultPtr := add(result, 32)

            // Run over the input, 3 bytes at a time
            for {
                let dataPtr := data
                let endPtr := add(data, mload(data))
            } lt(dataPtr, endPtr) {

            } {
                // Advance 3 bytes
                dataPtr := add(dataPtr, 3)
                let input := mload(dataPtr)

                // To write each character, shift the 3 bytes (18 bits) chunk
                // 4 times in blocks of 6 bits for each character (18, 12, 6, 0)
                // and apply logical AND with 0x3F which is the number of
                // the previous character in the ASCII table prior to the Base64 Table
                // The result is then added to the table to get the character to write,
                // and finally write it in the result pointer but with a left shift
                // of 256 (1 byte) - 8 (1 ASCII char) = 248 bits

                mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance
            }

            // When data `bytes` is not exactly 3 bytes long
            // it is padded with `=` characters at the end
            switch mod(mload(data), 3)
            case 1 {
                mstore8(sub(resultPtr, 1), 0x3d)
                mstore8(sub(resultPtr, 2), 0x3d)
            }
            case 2 {
                mstore8(sub(resultPtr, 1), 0x3d)
            }
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library StringsUpgradeable {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

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

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

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

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

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/Address.sol";

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

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

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

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

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

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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.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
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides a set of functions to operate with Base64 strings.
 *
 * _Available since v4.5._
 */
library Base64 {
    /**
     * @dev Base64 Encoding/Decoding Table
     */
    string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /**
     * @dev Converts a `bytes` to its Bytes64 `string` representation.
     */
    function encode(bytes memory data) internal pure returns (string memory) {
        /**
         * Inspired by Brecht Devos (Brechtpd) implementation - MIT licence
         * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol
         */
        if (data.length == 0) return "";

        // Loads the table into memory
        string memory table = _TABLE;

        // Encoding takes 3 bytes chunks of binary data from `bytes` data parameter
        // and split into 4 numbers of 6 bits.
        // The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up
        // - `data.length + 2`  -> Round up
        // - `/ 3`              -> Number of 3-bytes chunks
        // - `4 *`              -> 4 characters for each chunk
        string memory result = new string(4 * ((data.length + 2) / 3));

        /// @solidity memory-safe-assembly
        assembly {
            // Prepare the lookup table (skip the first "length" byte)
            let tablePtr := add(table, 1)

            // Prepare result pointer, jump over length
            let resultPtr := add(result, 32)

            // Run over the input, 3 bytes at a time
            for {
                let dataPtr := data
                let endPtr := add(data, mload(data))
            } lt(dataPtr, endPtr) {

            } {
                // Advance 3 bytes
                dataPtr := add(dataPtr, 3)
                let input := mload(dataPtr)

                // To write each character, shift the 3 bytes (18 bits) chunk
                // 4 times in blocks of 6 bits for each character (18, 12, 6, 0)
                // and apply logical AND with 0x3F which is the number of
                // the previous character in the ASCII table prior to the Base64 Table
                // The result is then added to the table to get the character to write,
                // and finally write it in the result pointer but with a left shift
                // of 256 (1 byte) - 8 (1 ASCII char) = 248 bits

                mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance
            }

            // When data `bytes` is not exactly 3 bytes long
            // it is padded with `=` characters at the end
            switch mod(mload(data), 3)
            case 1 {
                mstore8(sub(resultPtr, 1), 0x3d)
                mstore8(sub(resultPtr, 2), 0x3d)
            }
            case 2 {
                mstore8(sub(resultPtr, 1), 0x3d)
            }
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// 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;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC173 } from '../../interfaces/IERC173.sol';

interface IOwnable is IERC173 {}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC173Internal } from '../../interfaces/IERC173Internal.sol';

interface IOwnableInternal is IERC173Internal {
    error Ownable__NotOwner();
    error Ownable__NotTransitiveOwner();
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC173 } from '../../interfaces/IERC173.sol';
import { IOwnable } from './IOwnable.sol';
import { OwnableInternal } from './OwnableInternal.sol';
import { OwnableStorage } from './OwnableStorage.sol';

/**
 * @title Ownership access control based on ERC173
 */
abstract contract Ownable is IOwnable, OwnableInternal {
    using OwnableStorage for OwnableStorage.Layout;

    /**
     * @inheritdoc IERC173
     */
    function owner() public view virtual returns (address) {
        return _owner();
    }

    /**
     * @inheritdoc IERC173
     */
    function transferOwnership(address account) public virtual onlyOwner {
        _transferOwnership(account);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC173 } from '../../interfaces/IERC173.sol';
import { AddressUtils } from '../../utils/AddressUtils.sol';
import { IOwnableInternal } from './IOwnableInternal.sol';
import { OwnableStorage } from './OwnableStorage.sol';

abstract contract OwnableInternal is IOwnableInternal {
    using AddressUtils for address;
    using OwnableStorage for OwnableStorage.Layout;

    modifier onlyOwner() {
        if (msg.sender != _owner()) revert Ownable__NotOwner();
        _;
    }

    modifier onlyTransitiveOwner() {
        if (msg.sender != _transitiveOwner())
            revert Ownable__NotTransitiveOwner();
        _;
    }

    function _owner() internal view virtual returns (address) {
        return OwnableStorage.layout().owner;
    }

    function _transitiveOwner() internal view virtual returns (address) {
        address owner = _owner();

        while (owner.isContract()) {
            try IERC173(owner).owner() returns (address transitiveOwner) {
                owner = transitiveOwner;
            } catch {
                return owner;
            }
        }

        return owner;
    }

    function _transferOwnership(address account) internal virtual {
        OwnableStorage.layout().setOwner(account);
        emit OwnershipTransferred(msg.sender, account);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

library OwnableStorage {
    struct Layout {
        address owner;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.Ownable');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }

    function setOwner(Layout storage l, address owner) internal {
        l.owner = owner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

/**
 * @title Set implementation with enumeration functions
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts (MIT license)
 */
library EnumerableSet {
    error EnumerableSet__IndexOutOfBounds();

    struct Set {
        bytes32[] _values;
        // 1-indexed to allow 0 to signify nonexistence
        mapping(bytes32 => uint256) _indexes;
    }

    struct Bytes32Set {
        Set _inner;
    }

    struct AddressSet {
        Set _inner;
    }

    struct UintSet {
        Set _inner;
    }

    function at(
        Bytes32Set storage set,
        uint256 index
    ) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    function at(
        AddressSet storage set,
        uint256 index
    ) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    function at(
        UintSet storage set,
        uint256 index
    ) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    function contains(
        Bytes32Set storage set,
        bytes32 value
    ) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    function contains(
        AddressSet storage set,
        address value
    ) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    function contains(
        UintSet storage set,
        uint256 value
    ) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    function indexOf(
        Bytes32Set storage set,
        bytes32 value
    ) internal view returns (uint256) {
        return _indexOf(set._inner, value);
    }

    function indexOf(
        AddressSet storage set,
        address value
    ) internal view returns (uint256) {
        return _indexOf(set._inner, bytes32(uint256(uint160(value))));
    }

    function indexOf(
        UintSet storage set,
        uint256 value
    ) internal view returns (uint256) {
        return _indexOf(set._inner, bytes32(value));
    }

    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function add(
        Bytes32Set storage set,
        bytes32 value
    ) internal returns (bool) {
        return _add(set._inner, value);
    }

    function add(
        AddressSet storage set,
        address value
    ) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    function remove(
        Bytes32Set storage set,
        bytes32 value
    ) internal returns (bool) {
        return _remove(set._inner, value);
    }

    function remove(
        AddressSet storage set,
        address value
    ) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    function remove(
        UintSet storage set,
        uint256 value
    ) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    function toArray(
        Bytes32Set storage set
    ) internal view returns (bytes32[] memory) {
        return set._inner._values;
    }

    function toArray(
        AddressSet storage set
    ) internal view returns (address[] memory) {
        bytes32[] storage values = set._inner._values;
        address[] storage array;

        assembly {
            array.slot := values.slot
        }

        return array;
    }

    function toArray(
        UintSet storage set
    ) internal view returns (uint256[] memory) {
        bytes32[] storage values = set._inner._values;
        uint256[] storage array;

        assembly {
            array.slot := values.slot
        }

        return array;
    }

    function _at(
        Set storage set,
        uint256 index
    ) private view returns (bytes32) {
        if (index >= set._values.length)
            revert EnumerableSet__IndexOutOfBounds();
        return set._values[index];
    }

    function _contains(
        Set storage set,
        bytes32 value
    ) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    function _indexOf(
        Set storage set,
        bytes32 value
    ) private view returns (uint256) {
        unchecked {
            return set._indexes[value] - 1;
        }
    }

    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    function _add(
        Set storage set,
        bytes32 value
    ) private returns (bool status) {
        if (!_contains(set, value)) {
            set._values.push(value);
            set._indexes[value] = set._values.length;
            status = true;
        }
    }

    function _remove(
        Set storage set,
        bytes32 value
    ) private returns (bool status) {
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            unchecked {
                bytes32 last = set._values[set._values.length - 1];

                // move last value to now-vacant index

                set._values[valueIndex - 1] = last;
                set._indexes[last] = valueIndex;
            }
            // clear last index

            set._values.pop();
            delete set._indexes[value];

            status = true;
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC165 } from './IERC165.sol';
import { IERC1155Internal } from './IERC1155Internal.sol';

/**
 * @title ERC1155 interface
 * @dev see https://github.com/ethereum/EIPs/issues/1155
 */
interface IERC1155 is IERC1155Internal, IERC165 {
    /**
     * @notice query the balance of given token held by given address
     * @param account address to query
     * @param id token to query
     * @return token balance
     */
    function balanceOf(
        address account,
        uint256 id
    ) external view returns (uint256);

    /**
     * @notice query the balances of given tokens held by given addresses
     * @param accounts addresss to query
     * @param ids tokens to query
     * @return token balances
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @notice query approval status of given operator with respect to given address
     * @param account address to query for approval granted
     * @param operator address to query for approval received
     * @return whether operator is approved to spend tokens held by account
     */
    function isApprovedForAll(
        address account,
        address operator
    ) external view returns (bool);

    /**
     * @notice grant approval to or revoke approval from given operator to spend held tokens
     * @param operator address whose approval status to update
     * @param status whether operator should be considered approved
     */
    function setApprovalForAll(address operator, bool status) external;

    /**
     * @notice transfer tokens between given addresses, checking for ERC1155Receiver implementation if applicable
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @notice transfer batch of tokens between given addresses, checking for ERC1155Receiver implementation if applicable
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param ids list of token IDs
     * @param amounts list of quantities of tokens to transfer
     * @param data data payload
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

/**
 * @title Partial ERC1155 interface needed by internal functions
 */
interface IERC1155Internal {
    event TransferSingle(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 id,
        uint256 value
    );

    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    event ApprovalForAll(
        address indexed account,
        address indexed operator,
        bool approved
    );
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC165 } from './IERC165.sol';

/**
 * @title ERC1155 transfer receiver interface
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @notice validate receipt of ERC1155 transfer
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param id token ID received
     * @param value quantity of tokens received
     * @param data data payload
     * @return function's own selector if transfer is accepted
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @notice validate receipt of ERC1155 batch transfer
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param ids token IDs received
     * @param values quantities of tokens received
     * @param data data payload
     * @return function's own selector if transfer is accepted
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

/**
 * @title ERC165 interface registration interface
 * @dev see https://eips.ethereum.org/EIPS/eip-165
 */
interface IERC165 {
    /**
     * @notice query whether contract has registered support for given interface
     * @param interfaceId interface id
     * @return bool whether interface is supported
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC173Internal } from './IERC173Internal.sol';

/**
 * @title Contract ownership standard interface
 * @dev see https://eips.ethereum.org/EIPS/eip-173
 */
interface IERC173 is IERC173Internal {
    /**
     * @notice get the ERC173 contract owner
     * @return conrtact owner
     */
    function owner() external view returns (address);

    /**
     * @notice transfer contract ownership to new account
     * @param account address of new owner
     */
    function transferOwnership(address account) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

/**
 * @title Partial ERC173 interface needed by internal functions
 */
interface IERC173Internal {
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC165 } from './IERC165.sol';
import { IERC2981Internal } from './IERC2981Internal.sol';

/**
 * @title ERC2981 interface
 * @dev see https://eips.ethereum.org/EIPS/eip-2981
 */
interface IERC2981 is IERC2981Internal, IERC165 {
    /**
     * @notice called with the sale price to determine how much royalty is owed and to whom
     * @param tokenId the ERC721 or ERC1155 token id to query for royalty information
     * @param salePrice the sale price of the given asset
     * @return receiever rightful recipient of royalty
     * @return royaltyAmount amount of royalty owed
     */
    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view returns (address receiever, uint256 royaltyAmount);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

/**
 * @title ERC2981 interface
 */
interface IERC2981Internal {

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC165 } from '../interfaces/IERC165.sol';
import { ERC165Storage } from './ERC165Storage.sol';

/**
 * @title ERC165 implementation
 */
abstract contract ERC165 is IERC165 {
    using ERC165Storage for ERC165Storage.Layout;

    /**
     * @inheritdoc IERC165
     */
    function supportsInterface(bytes4 interfaceId) public view returns (bool) {
        return ERC165Storage.layout().isSupportedInterface(interfaceId);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

library ERC165Storage {
    error ERC165Storage__InvalidInterfaceId();

    struct Layout {
        mapping(bytes4 => bool) supportedInterfaces;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC165');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }

    function isSupportedInterface(
        Layout storage l,
        bytes4 interfaceId
    ) internal view returns (bool) {
        return l.supportedInterfaces[interfaceId];
    }

    function setSupportedInterface(
        Layout storage l,
        bytes4 interfaceId,
        bool status
    ) internal {
        if (interfaceId == 0xffffffff)
            revert ERC165Storage__InvalidInterfaceId();
        l.supportedInterfaces[interfaceId] = status;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { PausableStorage } from './PausableStorage.sol';

/**
 * @title Internal functions for Pausable security control module.
 */
abstract contract PausableInternal {
    using PausableStorage for PausableStorage.Layout;

    error Pausable__Paused();
    error Pausable__NotPaused();

    event Paused(address account);
    event Unpaused(address account);

    modifier whenNotPaused() {
        if (_paused()) revert Pausable__Paused();
        _;
    }

    modifier whenPaused() {
        if (!_paused()) revert Pausable__NotPaused();
        _;
    }

    /**
     * @notice query the contracts paused state.
     * @return true if paused, false if unpaused.
     */
    function _paused() internal view virtual returns (bool) {
        return PausableStorage.layout().paused;
    }

    /**
     * @notice Triggers paused state, when contract is unpaused.
     */
    function _pause() internal virtual whenNotPaused {
        PausableStorage.layout().paused = true;
        emit Paused(msg.sender);
    }

    /**
     * @notice Triggers unpaused state, when contract is paused.
     */
    function _unpause() internal virtual whenPaused {
        PausableStorage.layout().paused = false;
        emit Unpaused(msg.sender);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

library PausableStorage {
    struct Layout {
        bool paused;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.Pausable');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

library ERC2981Storage {
    struct Layout {
        // token id -> royalty (denominated in basis points)
        mapping(uint256 => uint16) royaltiesBPS;
        uint16 defaultRoyaltyBPS;
        // token id -> receiver address
        mapping(uint256 => address) royaltyReceivers;
        address defaultRoyaltyReceiver;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC2981');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC1155 } from '../../../interfaces/IERC1155.sol';
import { IERC1155Receiver } from '../../../interfaces/IERC1155Receiver.sol';
import { IERC1155Base } from './IERC1155Base.sol';
import { ERC1155BaseInternal, ERC1155BaseStorage } from './ERC1155BaseInternal.sol';

/**
 * @title Base ERC1155 contract
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license)
 */
abstract contract ERC1155Base is IERC1155Base, ERC1155BaseInternal {
    /**
     * @inheritdoc IERC1155
     */
    function balanceOf(
        address account,
        uint256 id
    ) public view virtual returns (uint256) {
        return _balanceOf(account, id);
    }

    /**
     * @inheritdoc IERC1155
     */
    function balanceOfBatch(
        address[] memory accounts,
        uint256[] memory ids
    ) public view virtual returns (uint256[] memory) {
        if (accounts.length != ids.length)
            revert ERC1155Base__ArrayLengthMismatch();

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

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

        unchecked {
            for (uint256 i; i < accounts.length; i++) {
                if (accounts[i] == address(0))
                    revert ERC1155Base__BalanceQueryZeroAddress();
                batchBalances[i] = balances[ids[i]][accounts[i]];
            }
        }

        return batchBalances;
    }

    /**
     * @inheritdoc IERC1155
     */
    function isApprovedForAll(
        address account,
        address operator
    ) public view virtual returns (bool) {
        return ERC1155BaseStorage.layout().operatorApprovals[account][operator];
    }

    /**
     * @inheritdoc IERC1155
     */
    function setApprovalForAll(address operator, bool status) public virtual {
        if (msg.sender == operator) revert ERC1155Base__SelfApproval();
        ERC1155BaseStorage.layout().operatorApprovals[msg.sender][
            operator
        ] = status;
        emit ApprovalForAll(msg.sender, operator, status);
    }

    /**
     * @inheritdoc IERC1155
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual {
        if (from != msg.sender && !isApprovedForAll(from, msg.sender))
            revert ERC1155Base__NotOwnerOrApproved();
        _safeTransfer(msg.sender, from, to, id, amount, data);
    }

    /**
     * @inheritdoc IERC1155
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual {
        if (from != msg.sender && !isApprovedForAll(from, msg.sender))
            revert ERC1155Base__NotOwnerOrApproved();
        _safeTransferBatch(msg.sender, from, to, ids, amounts, data);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC1155Receiver } from '../../../interfaces/IERC1155Receiver.sol';
import { AddressUtils } from '../../../utils/AddressUtils.sol';
import { IERC1155BaseInternal } from './IERC1155BaseInternal.sol';
import { ERC1155BaseStorage } from './ERC1155BaseStorage.sol';

/**
 * @title Base ERC1155 internal functions
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license)
 */
abstract contract ERC1155BaseInternal is IERC1155BaseInternal {
    using AddressUtils for address;

    /**
     * @notice query the balance of given token held by given address
     * @param account address to query
     * @param id token to query
     * @return token balance
     */
    function _balanceOf(
        address account,
        uint256 id
    ) internal view virtual returns (uint256) {
        if (account == address(0))
            revert ERC1155Base__BalanceQueryZeroAddress();
        return ERC1155BaseStorage.layout().balances[id][account];
    }

    /**
     * @notice mint given quantity of tokens for given address
     * @dev ERC1155Receiver implementation is not checked
     * @param account beneficiary of minting
     * @param id token ID
     * @param amount quantity of tokens to mint
     * @param data data payload
     */
    function _mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        if (account == address(0)) revert ERC1155Base__MintToZeroAddress();

        _beforeTokenTransfer(
            msg.sender,
            address(0),
            account,
            _asSingletonArray(id),
            _asSingletonArray(amount),
            data
        );

        ERC1155BaseStorage.layout().balances[id][account] += amount;

        emit TransferSingle(msg.sender, address(0), account, id, amount);
    }

    /**
     * @notice mint given quantity of tokens for given address
     * @param account beneficiary of minting
     * @param id token ID
     * @param amount quantity of tokens to mint
     * @param data data payload
     */
    function _safeMint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        _mint(account, id, amount, data);

        _doSafeTransferAcceptanceCheck(
            msg.sender,
            address(0),
            account,
            id,
            amount,
            data
        );
    }

    /**
     * @notice mint batch of tokens for given address
     * @dev ERC1155Receiver implementation is not checked
     * @param account beneficiary of minting
     * @param ids list of token IDs
     * @param amounts list of quantities of tokens to mint
     * @param data data payload
     */
    function _mintBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        if (account == address(0)) revert ERC1155Base__MintToZeroAddress();
        if (ids.length != amounts.length)
            revert ERC1155Base__ArrayLengthMismatch();

        _beforeTokenTransfer(
            msg.sender,
            address(0),
            account,
            ids,
            amounts,
            data
        );

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        for (uint256 i; i < ids.length; ) {
            balances[ids[i]][account] += amounts[i];
            unchecked {
                i++;
            }
        }

        emit TransferBatch(msg.sender, address(0), account, ids, amounts);
    }

    /**
     * @notice mint batch of tokens for given address
     * @param account beneficiary of minting
     * @param ids list of token IDs
     * @param amounts list of quantities of tokens to mint
     * @param data data payload
     */
    function _safeMintBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        _mintBatch(account, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(
            msg.sender,
            address(0),
            account,
            ids,
            amounts,
            data
        );
    }

    /**
     * @notice burn given quantity of tokens held by given address
     * @param account holder of tokens to burn
     * @param id token ID
     * @param amount quantity of tokens to burn
     */
    function _burn(
        address account,
        uint256 id,
        uint256 amount
    ) internal virtual {
        if (account == address(0)) revert ERC1155Base__BurnFromZeroAddress();

        _beforeTokenTransfer(
            msg.sender,
            account,
            address(0),
            _asSingletonArray(id),
            _asSingletonArray(amount),
            ''
        );

        mapping(address => uint256) storage balances = ERC1155BaseStorage
            .layout()
            .balances[id];

        unchecked {
            if (amount > balances[account])
                revert ERC1155Base__BurnExceedsBalance();
            balances[account] -= amount;
        }

        emit TransferSingle(msg.sender, account, address(0), id, amount);
    }

    /**
     * @notice burn given batch of tokens held by given address
     * @param account holder of tokens to burn
     * @param ids token IDs
     * @param amounts quantities of tokens to burn
     */
    function _burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        if (account == address(0)) revert ERC1155Base__BurnFromZeroAddress();
        if (ids.length != amounts.length)
            revert ERC1155Base__ArrayLengthMismatch();

        _beforeTokenTransfer(msg.sender, account, address(0), ids, amounts, '');

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        unchecked {
            for (uint256 i; i < ids.length; i++) {
                uint256 id = ids[i];
                if (amounts[i] > balances[id][account])
                    revert ERC1155Base__BurnExceedsBalance();
                balances[id][account] -= amounts[i];
            }
        }

        emit TransferBatch(msg.sender, account, address(0), ids, amounts);
    }

    /**
     * @notice transfer tokens between given addresses
     * @dev ERC1155Receiver implementation is not checked
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function _transfer(
        address operator,
        address sender,
        address recipient,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        if (recipient == address(0))
            revert ERC1155Base__TransferToZeroAddress();

        _beforeTokenTransfer(
            operator,
            sender,
            recipient,
            _asSingletonArray(id),
            _asSingletonArray(amount),
            data
        );

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

        unchecked {
            uint256 senderBalance = balances[id][sender];
            if (amount > senderBalance)
                revert ERC1155Base__TransferExceedsBalance();
            balances[id][sender] = senderBalance - amount;
        }

        balances[id][recipient] += amount;

        emit TransferSingle(operator, sender, recipient, id, amount);
    }

    /**
     * @notice transfer tokens between given addresses
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    function _safeTransfer(
        address operator,
        address sender,
        address recipient,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        _transfer(operator, sender, recipient, id, amount, data);

        _doSafeTransferAcceptanceCheck(
            operator,
            sender,
            recipient,
            id,
            amount,
            data
        );
    }

    /**
     * @notice transfer batch of tokens between given addresses
     * @dev ERC1155Receiver implementation is not checked
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _transferBatch(
        address operator,
        address sender,
        address recipient,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        if (recipient == address(0))
            revert ERC1155Base__TransferToZeroAddress();
        if (ids.length != amounts.length)
            revert ERC1155Base__ArrayLengthMismatch();

        _beforeTokenTransfer(operator, sender, recipient, ids, amounts, data);

        mapping(uint256 => mapping(address => uint256))
            storage balances = ERC1155BaseStorage.layout().balances;

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

            unchecked {
                uint256 senderBalance = balances[token][sender];

                if (amount > senderBalance)
                    revert ERC1155Base__TransferExceedsBalance();

                balances[token][sender] = senderBalance - amount;

                i++;
            }

            // balance increase cannot be unchecked because ERC1155Base neither tracks nor validates a totalSupply
            balances[token][recipient] += amount;
        }

        emit TransferBatch(operator, sender, recipient, ids, amounts);
    }

    /**
     * @notice transfer batch of tokens between given addresses
     * @param operator executor of transfer
     * @param sender sender of tokens
     * @param recipient receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _safeTransferBatch(
        address operator,
        address sender,
        address recipient,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        _transferBatch(operator, sender, recipient, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(
            operator,
            sender,
            recipient,
            ids,
            amounts,
            data
        );
    }

    /**
     * @notice wrap given element in array of length 1
     * @param element element to wrap
     * @return singleton array
     */
    function _asSingletonArray(
        uint256 element
    ) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;
        return array;
    }

    /**
     * @notice revert if applicable transfer recipient is not valid ERC1155Receiver
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param id token ID
     * @param amount quantity of tokens to transfer
     * @param data data payload
     */
    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 ERC1155Base__ERC1155ReceiverRejected();
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert ERC1155Base__ERC1155ReceiverNotImplemented();
            }
        }
    }

    /**
     * @notice revert if applicable transfer recipient is not valid ERC1155Receiver
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    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 ERC1155Base__ERC1155ReceiverRejected();
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert ERC1155Base__ERC1155ReceiverNotImplemented();
            }
        }
    }

    /**
     * @notice ERC1155 hook, called before all transfers including mint and burn
     * @dev function should be overridden and new implementation must call super
     * @dev called for both single and batch transfers
     * @param operator executor of transfer
     * @param from sender of tokens
     * @param to receiver of tokens
     * @param ids token IDs
     * @param amounts quantities of tokens to transfer
     * @param data data payload
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

library ERC1155BaseStorage {
    struct Layout {
        mapping(uint256 => mapping(address => uint256)) balances;
        mapping(address => mapping(address => bool)) operatorApprovals;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC1155Base');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC1155 } from '../../../interfaces/IERC1155.sol';
import { IERC1155BaseInternal } from './IERC1155BaseInternal.sol';

/**
 * @title ERC1155 base interface
 */
interface IERC1155Base is IERC1155BaseInternal, IERC1155 {

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC1155Internal } from '../../../interfaces/IERC1155Internal.sol';

/**
 * @title ERC1155 base interface
 */
interface IERC1155BaseInternal is IERC1155Internal {
    error ERC1155Base__ArrayLengthMismatch();
    error ERC1155Base__BalanceQueryZeroAddress();
    error ERC1155Base__NotOwnerOrApproved();
    error ERC1155Base__SelfApproval();
    error ERC1155Base__BurnExceedsBalance();
    error ERC1155Base__BurnFromZeroAddress();
    error ERC1155Base__ERC1155ReceiverRejected();
    error ERC1155Base__ERC1155ReceiverNotImplemented();
    error ERC1155Base__MintToZeroAddress();
    error ERC1155Base__TransferExceedsBalance();
    error ERC1155Base__TransferToZeroAddress();
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { EnumerableSet } from '../../../data/EnumerableSet.sol';
import { ERC1155BaseInternal } from '../base/ERC1155BaseInternal.sol';
import { IERC1155Enumerable } from './IERC1155Enumerable.sol';
import { ERC1155EnumerableInternal, ERC1155EnumerableStorage } from './ERC1155EnumerableInternal.sol';

/**
 * @title ERC1155 implementation including enumerable and aggregate functions
 */
abstract contract ERC1155Enumerable is
    IERC1155Enumerable,
    ERC1155EnumerableInternal
{
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.UintSet;

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function totalSupply(uint256 id) public view virtual returns (uint256) {
        return _totalSupply(id);
    }

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function totalHolders(uint256 id) public view virtual returns (uint256) {
        return _totalHolders(id);
    }

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function accountsByToken(
        uint256 id
    ) public view virtual returns (address[] memory) {
        return _accountsByToken(id);
    }

    /**
     * @inheritdoc IERC1155Enumerable
     */
    function tokensByAccount(
        address account
    ) public view virtual returns (uint256[] memory) {
        return _tokensByAccount(account);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { EnumerableSet } from '../../../data/EnumerableSet.sol';
import { ERC1155BaseInternal, ERC1155BaseStorage } from '../base/ERC1155BaseInternal.sol';
import { ERC1155EnumerableStorage } from './ERC1155EnumerableStorage.sol';

/**
 * @title ERC1155Enumerable internal functions
 */
abstract contract ERC1155EnumerableInternal is ERC1155BaseInternal {
    using EnumerableSet for EnumerableSet.AddressSet;
    using EnumerableSet for EnumerableSet.UintSet;

    /**
     * @notice query total minted supply of given token
     * @param id token id to query
     * @return token supply
     */
    function _totalSupply(uint256 id) internal view virtual returns (uint256) {
        return ERC1155EnumerableStorage.layout().totalSupply[id];
    }

    /**
     * @notice query total number of holders for given token
     * @param id token id to query
     * @return quantity of holders
     */
    function _totalHolders(uint256 id) internal view virtual returns (uint256) {
        return ERC1155EnumerableStorage.layout().accountsByToken[id].length();
    }

    /**
     * @notice query holders of given token
     * @param id token id to query
     * @return list of holder addresses
     */
    function _accountsByToken(
        uint256 id
    ) internal view virtual returns (address[] memory) {
        EnumerableSet.AddressSet storage accounts = ERC1155EnumerableStorage
            .layout()
            .accountsByToken[id];

        address[] memory addresses = new address[](accounts.length());

        unchecked {
            for (uint256 i; i < accounts.length(); i++) {
                addresses[i] = accounts.at(i);
            }
        }

        return addresses;
    }

    /**
     * @notice query tokens held by given address
     * @param account address to query
     * @return list of token ids
     */
    function _tokensByAccount(
        address account
    ) internal view virtual returns (uint256[] memory) {
        EnumerableSet.UintSet storage tokens = ERC1155EnumerableStorage
            .layout()
            .tokensByAccount[account];

        uint256[] memory ids = new uint256[](tokens.length());

        unchecked {
            for (uint256 i; i < tokens.length(); i++) {
                ids[i] = tokens.at(i);
            }
        }

        return ids;
    }

    /**
     * @notice ERC1155 hook: update aggregate values
     * @inheritdoc ERC1155BaseInternal
     */
    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 != to) {
            ERC1155EnumerableStorage.Layout storage l = ERC1155EnumerableStorage
                .layout();
            mapping(uint256 => EnumerableSet.AddressSet)
                storage tokenAccounts = l.accountsByToken;
            EnumerableSet.UintSet storage fromTokens = l.tokensByAccount[from];
            EnumerableSet.UintSet storage toTokens = l.tokensByAccount[to];

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

                if (amount > 0) {
                    uint256 id = ids[i];

                    if (from == address(0)) {
                        l.totalSupply[id] += amount;
                    } else if (_balanceOf(from, id) == amount) {
                        tokenAccounts[id].remove(from);
                        fromTokens.remove(id);
                    }

                    if (to == address(0)) {
                        l.totalSupply[id] -= amount;
                    } else if (_balanceOf(to, id) == 0) {
                        tokenAccounts[id].add(to);
                        toTokens.add(id);
                    }
                }

                unchecked {
                    i++;
                }
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { EnumerableSet } from '../../../data/EnumerableSet.sol';

library ERC1155EnumerableStorage {
    struct Layout {
        mapping(uint256 => uint256) totalSupply;
        mapping(uint256 => EnumerableSet.AddressSet) accountsByToken;
        mapping(address => EnumerableSet.UintSet) tokensByAccount;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC1155Enumerable');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC1155BaseInternal } from '../base/IERC1155BaseInternal.sol';

/**
 * @title ERC1155 enumerable and aggregate function interface
 */
interface IERC1155Enumerable is IERC1155BaseInternal {
    /**
     * @notice query total minted supply of given token
     * @param id token id to query
     * @return token supply
     */
    function totalSupply(uint256 id) external view returns (uint256);

    /**
     * @notice query total number of holders for given token
     * @param id token id to query
     * @return quantity of holders
     */
    function totalHolders(uint256 id) external view returns (uint256);

    /**
     * @notice query holders of given token
     * @param id token id to query
     * @return list of holder addresses
     */
    function accountsByToken(
        uint256 id
    ) external view returns (address[] memory);

    /**
     * @notice query tokens held by given address
     * @param account address to query
     * @return list of token ids
     */
    function tokensByAccount(
        address account
    ) external view returns (uint256[] memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC1155Base } from './base/IERC1155Base.sol';
import { IERC1155Enumerable } from './enumerable/IERC1155Enumerable.sol';
import { IERC1155Metadata } from './metadata/IERC1155Metadata.sol';

interface ISolidStateERC1155 is
    IERC1155Base,
    IERC1155Enumerable,
    IERC1155Metadata
{}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { UintUtils } from '../../../utils/UintUtils.sol';
import { IERC1155Metadata } from './IERC1155Metadata.sol';
import { ERC1155MetadataInternal } from './ERC1155MetadataInternal.sol';
import { ERC1155MetadataStorage } from './ERC1155MetadataStorage.sol';

/**
 * @title ERC1155 metadata extensions
 */
abstract contract ERC1155Metadata is IERC1155Metadata, ERC1155MetadataInternal {
    using UintUtils for uint256;

    /**
     * @notice inheritdoc IERC1155Metadata
     */
    function uri(uint256 tokenId) public view virtual returns (string memory) {
        ERC1155MetadataStorage.Layout storage l = ERC1155MetadataStorage
            .layout();

        string memory tokenIdURI = l.tokenURIs[tokenId];
        string memory baseURI = l.baseURI;

        if (bytes(baseURI).length == 0) {
            return tokenIdURI;
        } else if (bytes(tokenIdURI).length > 0) {
            return string(abi.encodePacked(baseURI, tokenIdURI));
        } else {
            return string(abi.encodePacked(baseURI, tokenId.toString()));
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC1155MetadataInternal } from './IERC1155MetadataInternal.sol';
import { ERC1155MetadataStorage } from './ERC1155MetadataStorage.sol';

/**
 * @title ERC1155Metadata internal functions
 */
abstract contract ERC1155MetadataInternal is IERC1155MetadataInternal {
    /**
     * @notice set base metadata URI
     * @dev base URI is a non-standard feature adapted from the ERC721 specification
     * @param baseURI base URI
     */
    function _setBaseURI(string memory baseURI) internal {
        ERC1155MetadataStorage.layout().baseURI = baseURI;
    }

    /**
     * @notice set per-token metadata URI
     * @param tokenId token whose metadata URI to set
     * @param tokenURI per-token URI
     */
    function _setTokenURI(uint256 tokenId, string memory tokenURI) internal {
        ERC1155MetadataStorage.layout().tokenURIs[tokenId] = tokenURI;
        emit URI(tokenURI, tokenId);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

/**
 * @title ERC1155 metadata extensions
 */
library ERC1155MetadataStorage {
    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.ERC1155Metadata');

    struct Layout {
        string baseURI;
        mapping(uint256 => string) tokenURIs;
    }

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { IERC1155MetadataInternal } from './IERC1155MetadataInternal.sol';

/**
 * @title ERC1155Metadata interface
 */
interface IERC1155Metadata is IERC1155MetadataInternal {
    /**
     * @notice get generated URI for given token
     * @return token URI
     */
    function uri(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

/**
 * @title Partial ERC1155Metadata interface needed by internal functions
 */
interface IERC1155MetadataInternal {
    event URI(string value, uint256 indexed tokenId);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { ERC165 } from '../../introspection/ERC165.sol';
import { ERC1155Base, ERC1155BaseInternal } from './base/ERC1155Base.sol';
import { ERC1155Enumerable } from './enumerable/ERC1155Enumerable.sol';
import { ERC1155EnumerableInternal } from './enumerable/ERC1155EnumerableInternal.sol';
import { ERC1155Metadata } from './metadata/ERC1155Metadata.sol';
import { ISolidStateERC1155 } from './ISolidStateERC1155.sol';

/**
 * @title SolidState ERC1155 implementation
 */
abstract contract SolidStateERC1155 is
    ISolidStateERC1155,
    ERC1155Base,
    ERC1155Enumerable,
    ERC1155Metadata,
    ERC165
{
    /**
     * @inheritdoc ERC1155BaseInternal
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    )
        internal
        virtual
        override(ERC1155BaseInternal, ERC1155EnumerableInternal)
    {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

import { UintUtils } from './UintUtils.sol';

library AddressUtils {
    using UintUtils for uint256;

    error AddressUtils__InsufficientBalance();
    error AddressUtils__NotContract();
    error AddressUtils__SendValueFailed();

    function toString(address account) internal pure returns (string memory) {
        return uint256(uint160(account)).toHexString(20);
    }

    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function sendValue(address payable account, uint256 amount) internal {
        (bool success, ) = account.call{ value: amount }('');
        if (!success) revert AddressUtils__SendValueFailed();
    }

    function functionCall(
        address target,
        bytes memory data
    ) internal returns (bytes memory) {
        return
            functionCall(target, data, 'AddressUtils: failed low-level call');
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory error
    ) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, error);
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                'AddressUtils: failed low-level call with value'
            );
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory error
    ) internal returns (bytes memory) {
        if (value > address(this).balance)
            revert AddressUtils__InsufficientBalance();
        return _functionCallWithValue(target, data, value, error);
    }

    /**
     * @notice execute arbitrary external call with limited gas usage and amount of copied return data
     * @dev derived from https://github.com/nomad-xyz/ExcessivelySafeCall (MIT License)
     * @param target recipient of call
     * @param gasAmount gas allowance for call
     * @param value native token value to include in call
     * @param maxCopy maximum number of bytes to copy from return data
     * @param data encoded call data
     * @return success whether call is successful
     * @return returnData copied return data
     */
    function excessivelySafeCall(
        address target,
        uint256 gasAmount,
        uint256 value,
        uint16 maxCopy,
        bytes memory data
    ) internal returns (bool success, bytes memory returnData) {
        returnData = new bytes(maxCopy);

        assembly {
            // execute external call via assembly to avoid automatic copying of return data
            success := call(
                gasAmount,
                target,
                value,
                add(data, 0x20),
                mload(data),
                0,
                0
            )

            // determine whether to limit amount of data to copy
            let toCopy := returndatasize()

            if gt(toCopy, maxCopy) {
                toCopy := maxCopy
            }

            // store the length of the copied bytes
            mstore(returnData, toCopy)

            // copy the bytes from returndata[0:toCopy]
            returndatacopy(add(returnData, 0x20), 0, toCopy)
        }
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory error
    ) private returns (bytes memory) {
        if (!isContract(target)) revert AddressUtils__NotContract();

        (bool success, bytes memory returnData) = target.call{ value: value }(
            data
        );

        if (success) {
            return returnData;
        } else if (returnData.length > 0) {
            assembly {
                let returnData_size := mload(returnData)
                revert(add(32, returnData), returnData_size)
            }
        } else {
            revert(error);
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.8;

/**
 * @title utility functions for uint256 operations
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license)
 */
library UintUtils {
    error UintUtils__InsufficientHexLength();

    bytes16 private constant HEX_SYMBOLS = '0123456789abcdef';

    function add(uint256 a, int256 b) internal pure returns (uint256) {
        return b < 0 ? sub(a, -b) : a + uint256(b);
    }

    function sub(uint256 a, int256 b) internal pure returns (uint256) {
        return b < 0 ? add(a, -b) : a - uint256(b);
    }

    function toString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return '0';
        }

        uint256 temp = value;
        uint256 digits;

        while (temp != 0) {
            digits++;
            temp /= 10;
        }

        bytes memory buffer = new bytes(digits);

        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }

        return string(buffer);
    }

    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return '0x00';
        }

        uint256 length = 0;

        for (uint256 temp = value; temp != 0; temp >>= 8) {
            unchecked {
                length++;
            }
        }

        return toHexString(value, length);
    }

    function toHexString(
        uint256 value,
        uint256 length
    ) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = '0';
        buffer[1] = 'x';

        unchecked {
            for (uint256 i = 2 * length + 1; i > 1; --i) {
                buffer[i] = HEX_SYMBOLS[value & 0xf];
                value >>= 4;
            }
        }

        if (value != 0) revert UintUtils__InsufficientHexLength();

        return string(buffer);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {ERC1155Storage} from "../storage/ERC1155Storage.sol";
import {TokenMetadata} from "../libraries/TokenMetadata.sol";
import {IERC1155Facet} from "../interfaces/IERC1155Facet.sol";
import {Base64} from "@openzeppelin/contracts/utils/Base64.sol";
import {IERC1155} from "@solidstate/contracts/interfaces/IERC1155.sol";
import {OwnableInternal} from "@solidstate/contracts/access/ownable/Ownable.sol";
import {PausableInternal} from "@solidstate/contracts/security/PausableInternal.sol";
import {DefaultOperatorFilterer} from "operator-filter-registry/src/DefaultOperatorFilterer.sol";
import {IERC1155Metadata} from "@solidstate/contracts/token/ERC1155/metadata/IERC1155Metadata.sol";
import {ERC1155MetadataStorage} from "@solidstate/contracts/token/ERC1155/metadata/ERC1155MetadataStorage.sol";
import {ERC1155EnumerableStorage} from "@solidstate/contracts/token/ERC1155/enumerable/ERC1155EnumerableStorage.sol";
import {SolidStateERC1155, ERC1155Base, ERC1155Metadata} from "@solidstate/contracts/token/ERC1155/SolidStateERC1155.sol";
import {MetadataInternal, MetadataStorage} from "../utils/Metadata/MetadataInternal.sol";

import "hardhat/console.sol";

contract ERC1155Facet is
    SolidStateERC1155,
    IERC1155Facet,
    OwnableInternal,
    PausableInternal,
    MetadataInternal,
    DefaultOperatorFilterer
{
    using ERC1155Storage for ERC1155Storage.Layout;
    using MetadataStorage for MetadataStorage.Layout;
    using ERC1155MetadataStorage for ERC1155MetadataStorage.Layout;
    using ERC1155EnumerableStorage for ERC1155EnumerableStorage.Layout;

    modifier validTokenID(uint256 _tokenId) {
        if (!_exists(_tokenId)) revert InvalidTokenID();

        _;
    }

    modifier validQuantity(uint256 _id, uint256 _amount) {
        uint256 currentTotalSupply = totalSupply(_id);
        uint256 maxSupply_ = ERC1155Storage.layout().tokenData[_id].maxSupply;

        if (currentTotalSupply + _amount > maxSupply_)
            revert ExceedsMaxSupply();

        _;
    }

    /**
     * @notice Checks if the amount sent is greater than or equal to the price of the token. If the sender is the owner, it will bypass this check allowing the owner to mint or airdrop for free.
     * @param _id The token ID
     * @param _amount The amount of tokens being minted
     */
    modifier validValueSent(uint256 _id, uint256 _amount) {
        uint256 totalPrice = ERC1155Storage.layout().tokenData[_id].price *
            _amount;

        if (msg.sender != _owner() && msg.value < totalPrice)
            revert InvalidAmount();

        _;
    }

    modifier validMint(uint256 _tokenId, uint256 _amount) {
        if (ERC1155Storage.layout().tokenData[_tokenId].allowListEnabled) {}

        _;
    }

    function mint(
        address account,
        uint256 id,
        uint256 amount
    )
        external
        payable
        validTokenID(id)
        validQuantity(id, amount)
        validValueSent(id, amount)
    {
        _mint(account, id, amount, "");
    }

    // On chain metadata
    function uri(
        uint256 _tokenId
    )
        public
        view
        override(ERC1155Metadata, IERC1155Metadata)
        returns (string memory)
    {
        string memory uniqueTokenURI = ERC1155Storage
            .layout()
            .tokenData[_tokenId]
            .tokenUri;
        if (bytes(uniqueTokenURI).length > 0) {
            return uniqueTokenURI;
        }

        // if (!ERC1155Storage.layout().tokenData[_tokenId].onChainMetadata) {
        // console.log("Off chain metadata response for token", _tokenId);
        // Return off chain url
        return
            string(
                abi.encodePacked(
                    ERC1155MetadataStorage.layout().baseURI,
                    _toString(_tokenId)
                )
            );
        // } else {
        //     return
        //         TokenMetadata.makeMetadataJSON(
        //             _tokenId,
        //             msg.sender,
        //             MetadataStorage.layout().metadata[_tokenId].name,
        //             MetadataStorage.layout().metadata[_tokenId].image,
        //             MetadataStorage.layout().metadata[_tokenId].description,
        //             MetadataStorage.layout().metadata[_tokenId].attributes
        //         );
        // }
    }

    // on chain metadata
    function _onChainMetadata(
        uint256 _tokenId
    ) internal view returns (string memory metadata) {
        MetadataStorage.Metadata storage tokenMetadata = MetadataStorage
            .layout()
            .metadata[_tokenId];

        metadata = TokenMetadata.makeMetadataJSON(
            _tokenId,
            msg.sender,
            tokenMetadata.name,
            tokenMetadata.image,
            tokenMetadata.description,
            tokenMetadata.attributes
        );
    }

    function maxSupply(uint256 _id) public view returns (uint256) {
        return ERC1155Storage.layout().tokenData[_id].maxSupply;
    }

    function setMaxSupply(
        uint256 _id,
        uint256 _maxSupply
    ) external validTokenID(_id) onlyOwner {
        if (_maxSupply < totalSupply(_id)) revert InvalidMaxSupply();

        ERC1155Storage.layout().tokenData[_id].maxSupply = _maxSupply;
    }

    // ERC1155Storage.TokenStructure memory _tokenData
    // tokenUri // Optional, baseUri is set in ERC1155MetadataStorage (https://sample.com/{id}.json) would be valid)
    /**
     * @dev Creates a new token type
     * NOTE: remove onlyOwner if you want third parties to create new tokens on your contract (which may change your IDs)
     * @param _maxSupply Maxmium amount of new token.
     * @param _price Price of new token.
     * @param _allowListEnabled Whether or not the token is on the allow list.
     * @param _tokenUri Optional, baseUri is set in ERC1155MetadataStorage (https://sample.com/{id}.json) would be valid)
     * @return The newly created token ID
     */
    function create(
        uint256 _maxSupply,
        uint256 _price,
        string calldata _tokenUri,
        bool _allowListEnabled
    )
        external
        // bool __onChainMetadata,
        // MetadataStorage.Metadata calldata _metadata
        onlyOwner
        returns (uint256)
    {
        console.log("Successfully called create function");
        uint256 _id = ERC1155Storage.layout().currentTokenId;

        // Do we want to store everything in top level mappings or use the tokenData struct mapping?
        // Not sure if there's a huge difference in gas costs here.
        ERC1155Storage.TokenStructure storage tokenData = ERC1155Storage
            .layout()
            .tokenData[_id];

        tokenData.maxSupply = _maxSupply;
        tokenData.price = _price;
        tokenData.creator = tx.origin;
        tokenData.tokenUri = _tokenUri;
        tokenData.allowListEnabled = _allowListEnabled;

        _incrementTokenTypeId();

        // ERC1155Storage
        //     .TokenStructure(
        //         _maxSupply,
        //         _price,
        //         msg.sender,
        //         _tokenUri,
        //         _allowListEnabled
        //     );
        // ERC1155Storage.Layout().tokenData[_id] = tokenData;

        // ERC1155Storage
        //     .layout()
        //     .tokenData[_id]
        //     .onChainMetadata = __onChainMetadata;

        // MetadataStorage.layout().metadata[_id] = _metadata;
        // _setMetadata(_id, _metadata);

        if (bytes(_tokenUri).length > 0) {
            emit URI(_tokenUri, _id);
        }

        ERC1155EnumerableStorage.layout().totalSupply[_id] = 0; // Might not be neccessary since it's 0 by default
        return _id;
    }

    function exists(uint256 _tokenId) external view returns (bool) {
        return _exists(_tokenId);
    }

    /**
     * @dev Returns whether the specified token exists by checking to see if it has a creator
     * @param _id uint256 ID of the token to query the existence of
     * @return bool whether the token exists
     */
    function _exists(uint256 _id) internal view returns (bool) {
        return ERC1155Storage.tokenData(_id).creator != address(0);
    }

    /**
     * @dev calculates the next token ID based on value of _currentTokenID
     * @return uint256 for the next token ID
     */
    function _getNextTokenID() private view returns (uint256) {
        unchecked {
            return ERC1155Storage.layout().currentTokenId + 1;
        }
    }

    /**
     * @dev increments the value of _currentTokenID
     */
    function _incrementTokenTypeId() private {
        unchecked {
            ++ERC1155Storage.layout().currentTokenId;
        }
    }

    function burn(
        address account,
        uint256 id,
        uint256 amount
    ) external validTokenID(id) onlyOwner {
        _burn(account, id, amount);
    }

    // Pause beforeTransfer for security
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal override whenNotPaused {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    }

    function setTokenData(
        ERC1155Storage.TokenStructure memory _tokenStructure,
        uint256 _id
    ) external validTokenID(_id) onlyOwner {
        ERC1155Storage.layout().tokenData[_id] = _tokenStructure;
    }

    // Opensea Compliance
    function setApprovalForAll(
        address operator,
        bool approved
    )
        public
        override(ERC1155Base, IERC1155)
        onlyAllowedOperatorApproval(operator)
    {
        super.setApprovalForAll(operator, approved);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        uint256 amount,
        bytes memory data
    ) public override(ERC1155Base, IERC1155) onlyAllowedOperator(from) {
        super.safeTransferFrom(from, to, tokenId, amount, data);
    }

    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory _amounts,
        bytes memory data
    ) public virtual override(ERC1155Base, IERC1155) onlyAllowedOperator(from) {
        super.safeBatchTransferFrom(from, to, ids, _amounts, data);
    }

    /**
     * @dev Converts a uint256 to its ASCII string decimal representation.
     */
    function _toString(
        uint256 value
    ) internal pure virtual returns (string memory str) {
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit),
            // but we allocate 0x80 bytes to keep the free memory pointer 32-byte word aligned.
            // We will need 1 32-byte word to store the length,
            // and 3 32-byte words to store a maximum of 78 digits. Total: 0x20 + 3 * 0x20 = 0x80.
            str := add(mload(0x40), 0x80)
            // Update the free memory pointer to allocate.
            mstore(0x40, str)

            // Cache the end of the memory to calculate the length later.
            let end := str

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            // prettier-ignore
            for { let temp := value } 1 {} {
                str := sub(str, 1)
                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
                // prettier-ignore
                if iszero(temp) { break }
            }

            let length := sub(end, str)
            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 0x20)
            // Store the length.
            mstore(str, length)
        }
    }

    /**
     * Get price for certain edition
     */
    function price(
        uint256 _id
    ) external view validTokenID(_id) returns (uint256) {
        return ERC1155Storage.tokenData(_id).price;
    }

    /**
     * Set price for certain edition
     */
    function setPrice(
        uint256 _id,
        uint256 _price
    ) external validTokenID(_id) onlyOwner {
        ERC1155Storage.layout().tokenData[_id].price = _price;
    }

    /** @dev Name/symbol needed for certain sites like OpenSea */
    function name() public view returns (string memory) {
        return ERC1155Storage.layout().name;
    }

    function symbol() public view returns (string memory) {
        return ERC1155Storage.layout().symbol;
    }

    function setName(string calldata _name) external onlyOwner {
        ERC1155Storage.layout().name = _name;
    }

    function setSymbol(string calldata _symbol) external onlyOwner {
        ERC1155Storage.layout().symbol = _symbol;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/

interface IDiamondCut {
    enum FacetCutAction {
        Add,
        Replace,
        Remove
    }
    // Add=0, Replace=1, Remove=2

    struct FacetCut {
        address facetAddress;
        FacetCutAction action;
        bytes4[] functionSelectors;
    }

    /// @notice Add/replace/remove any number of functions and optionally execute
    ///         a function with delegatecall
    /// @param _diamondCut Contains the facet addresses and function selectors
    /// @param _init The address of the contract or facet to execute _calldata
    /// @param _calldata A function call, including function selector and arguments
    ///                  _calldata is executed with delegatecall on _init
    function diamondCut(
        FacetCut[] calldata _diamondCut,
        address _init,
        bytes calldata _calldata
    ) external;

    event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/

// A loupe is a small magnifying glass used to look at diamonds.
// These functions look at diamonds
interface IDiamondLoupe {
    /// These functions are expected to be called frequently
    /// by tools.

    struct Facet {
        address facetAddress;
        bytes4[] functionSelectors;
    }

    /// @notice Gets all facet addresses and their four byte function selectors.
    /// @return facets_ Facet
    function facets() external view returns (Facet[] memory facets_);

    /// @notice Gets all the function selectors supported by a specific facet.
    /// @param _facet The facet address.
    /// @return facetFunctionSelectors_
    function facetFunctionSelectors(
        address _facet
    ) external view returns (bytes4[] memory facetFunctionSelectors_);

    /// @notice Get all the facet addresses used by a diamond.
    /// @return facetAddresses_
    function facetAddresses()
        external
        view
        returns (address[] memory facetAddresses_);

    /// @notice Gets the facet that supports the given selector.
    /// @dev If facet is not found return address(0).
    /// @param _functionSelector The function selector.
    /// @return facetAddress_ The facet address.
    function facetAddress(
        bytes4 _functionSelector
    ) external view returns (address facetAddress_);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

abstract contract IERC1155Facet {
    error ExceedsMaxSupply();
    error InvalidTokenID();
    error InvalidAmount();
    error InvalidMaxSupply();
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
/******************************************************************************/
import {IDiamondCut} from "../interfaces/IDiamondCut.sol";

import "hardhat/console.sol";

// Remember to add the loupe functions from DiamondLoupeFacet to the diamond.
// The loupe functions are required by the EIP2535 Diamonds standard

error InitializationFunctionReverted(
    address _initializationContractAddress,
    bytes _calldata
);

library LibDiamond {
    bytes32 constant DIAMOND_STORAGE_POSITION =
        keccak256("diamond.standard.diamond.storage");

    struct DiamondStorage {
        // maps function selectors to the facets that execute the functions.
        // and maps the selectors to their position in the selectorSlots array.
        // func selector => address facet, selector position
        mapping(bytes4 => bytes32) facets;
        // array of slots of function selectors.
        // each slot holds 8 function selectors.
        mapping(uint256 => bytes32) selectorSlots;
        // The number of function selectors in selectorSlots
        uint16 selectorCount;
        // Used to query if a contract implements an interface.
        // Used to implement ERC-165.
        mapping(bytes4 => bool) supportedInterfaces;
        // owner of the contract
        address contractOwner;
    }

    function diamondStorage()
        internal
        pure
        returns (DiamondStorage storage ds)
    {
        bytes32 position = DIAMOND_STORAGE_POSITION;
        assembly {
            ds.slot := position
        }
    }

    event DiamondCut(
        IDiamondCut.FacetCut[] _diamondCut,
        address _init,
        bytes _calldata
    );

    bytes32 constant CLEAR_ADDRESS_MASK =
        bytes32(uint256(0xffffffffffffffffffffffff));
    bytes32 constant CLEAR_SELECTOR_MASK = bytes32(uint256(0xffffffff << 224));

    // Internal function version of diamondCut
    // This code is almost the same as the external diamondCut,
    // except it is using 'Facet[] memory _diamondCut' instead of
    // 'Facet[] calldata _diamondCut'.
    // The code is duplicated to prevent copying calldata to memory which
    // causes an error for a two dimensional array.
    function diamondCut(
        IDiamondCut.FacetCut[] memory _diamondCut,
        address _init,
        bytes memory _calldata
    ) internal {
        DiamondStorage storage ds = diamondStorage();
        uint256 originalSelectorCount = ds.selectorCount;
        uint256 selectorCount = originalSelectorCount;
        bytes32 selectorSlot;
        // Check if last selector slot is not full
        // "selectorCount & 7" is a gas efficient modulo by eight "selectorCount % 8"
        if (selectorCount & 7 > 0) {
            // get last selectorSlot
            // "selectorSlot >> 3" is a gas efficient division by 8 "selectorSlot / 8"
            selectorSlot = ds.selectorSlots[selectorCount >> 3];
        }
        // loop through diamond cut
        for (
            uint256 facetIndex;
            facetIndex < _diamondCut.length;
            facetIndex++
        ) {
            (selectorCount, selectorSlot) = addReplaceRemoveFacetSelectors(
                selectorCount,
                selectorSlot,
                _diamondCut[facetIndex].facetAddress,
                _diamondCut[facetIndex].action,
                _diamondCut[facetIndex].functionSelectors
            );
        }
        if (selectorCount != originalSelectorCount) {
            ds.selectorCount = uint16(selectorCount);
        }
        // If last selector slot is not full
        // "selectorCount & 7" is a gas efficient modulo by eight "selectorCount % 8"
        if (selectorCount & 7 > 0) {
            // "selectorSlot >> 3" is a gas efficient division by 8 "selectorSlot / 8"
            ds.selectorSlots[selectorCount >> 3] = selectorSlot;
        }
        emit DiamondCut(_diamondCut, _init, _calldata);
        initializeDiamondCut(_init, _calldata);
    }

    function addReplaceRemoveFacetSelectors(
        uint256 _selectorCount,
        bytes32 _selectorSlot,
        address _newFacetAddress,
        IDiamondCut.FacetCutAction _action,
        bytes4[] memory _selectors
    ) internal returns (uint256, bytes32) {
        DiamondStorage storage ds = diamondStorage();
        require(
            _selectors.length > 0,
            "LibDiamondCut: No selectors in facet to cut"
        );
        if (_action == IDiamondCut.FacetCutAction.Add) {
            enforceHasContractCode(
                _newFacetAddress,
                "LibDiamondCut: Add facet has no code"
            );
            for (
                uint256 selectorIndex;
                selectorIndex < _selectors.length;
                selectorIndex++
            ) {
                bytes4 selector = _selectors[selectorIndex];
                bytes32 oldFacet = ds.facets[selector];
                if (address(bytes20(oldFacet)) != address(0)) {
                    console.log("oldFacet");
                    console.logBytes32(oldFacet);
                }
                require(
                    address(bytes20(oldFacet)) == address(0),
                    "LibDiamondCut: Can't add function that already exists"
                );
                // add facet for selector
                ds.facets[selector] =
                    bytes20(_newFacetAddress) |
                    bytes32(_selectorCount);
                // "_selectorCount & 7" is a gas efficient modulo by eight "_selectorCount % 8"
                // " << 5 is the same as multiplying by 32 ( * 32)
                uint256 selectorInSlotPosition = (_selectorCount & 7) << 5;
                // clear selector position in slot and add selector
                _selectorSlot =
                    (_selectorSlot &
                        ~(CLEAR_SELECTOR_MASK >> selectorInSlotPosition)) |
                    (bytes32(selector) >> selectorInSlotPosition);
                // if slot is full then write it to storage
                if (selectorInSlotPosition == 224) {
                    // "_selectorSlot >> 3" is a gas efficient division by 8 "_selectorSlot / 8"
                    ds.selectorSlots[_selectorCount >> 3] = _selectorSlot;
                    _selectorSlot = 0;
                }
                _selectorCount++;
            }
        } else if (_action == IDiamondCut.FacetCutAction.Replace) {
            enforceHasContractCode(
                _newFacetAddress,
                "LibDiamondCut: Replace facet has no code"
            );
            for (
                uint256 selectorIndex;
                selectorIndex < _selectors.length;
                selectorIndex++
            ) {
                bytes4 selector = _selectors[selectorIndex];
                bytes32 oldFacet = ds.facets[selector];
                address oldFacetAddress = address(bytes20(oldFacet));
                // only useful if immutable functions exist
                require(
                    oldFacetAddress != address(this),
                    "LibDiamondCut: Can't replace immutable function"
                );
                require(
                    oldFacetAddress != _newFacetAddress,
                    "LibDiamondCut: Can't replace function with same function"
                );
                require(
                    oldFacetAddress != address(0),
                    "LibDiamondCut: Can't replace function that doesn't exist"
                );
                // replace old facet address
                ds.facets[selector] =
                    (oldFacet & CLEAR_ADDRESS_MASK) |
                    bytes20(_newFacetAddress);
            }
        } else if (_action == IDiamondCut.FacetCutAction.Remove) {
            require(
                _newFacetAddress == address(0),
                "LibDiamondCut: Remove facet address must be address(0)"
            );
            // "_selectorCount >> 3" is a gas efficient division by 8 "_selectorCount / 8"
            uint256 selectorSlotCount = _selectorCount >> 3;
            // "_selectorCount & 7" is a gas efficient modulo by eight "_selectorCount % 8"
            uint256 selectorInSlotIndex = _selectorCount & 7;
            for (
                uint256 selectorIndex;
                selectorIndex < _selectors.length;
                selectorIndex++
            ) {
                if (_selectorSlot == 0) {
                    // get last selectorSlot
                    selectorSlotCount--;
                    _selectorSlot = ds.selectorSlots[selectorSlotCount];
                    selectorInSlotIndex = 7;
                } else {
                    selectorInSlotIndex--;
                }
                bytes4 lastSelector;
                uint256 oldSelectorsSlotCount;
                uint256 oldSelectorInSlotPosition;
                // adding a block here prevents stack too deep error
                {
                    bytes4 selector = _selectors[selectorIndex];
                    bytes32 oldFacet = ds.facets[selector];
                    require(
                        address(bytes20(oldFacet)) != address(0),
                        "LibDiamondCut: Can't remove function that doesn't exist"
                    );
                    // only useful if immutable functions exist
                    require(
                        address(bytes20(oldFacet)) != address(this),
                        "LibDiamondCut: Can't remove immutable function"
                    );
                    // replace selector with last selector in ds.facets
                    // gets the last selector
                    // " << 5 is the same as multiplying by 32 ( * 32)
                    lastSelector = bytes4(
                        _selectorSlot << (selectorInSlotIndex << 5)
                    );
                    if (lastSelector != selector) {
                        // update last selector slot position info
                        ds.facets[lastSelector] =
                            (oldFacet & CLEAR_ADDRESS_MASK) |
                            bytes20(ds.facets[lastSelector]);
                    }
                    delete ds.facets[selector];
                    uint256 oldSelectorCount = uint16(uint256(oldFacet));
                    // "oldSelectorCount >> 3" is a gas efficient division by 8 "oldSelectorCount / 8"
                    oldSelectorsSlotCount = oldSelectorCount >> 3;
                    // "oldSelectorCount & 7" is a gas efficient modulo by eight "oldSelectorCount % 8"
                    // " << 5 is the same as multiplying by 32 ( * 32)
                    oldSelectorInSlotPosition = (oldSelectorCount & 7) << 5;
                }
                if (oldSelectorsSlotCount != selectorSlotCount) {
                    bytes32 oldSelectorSlot = ds.selectorSlots[
                        oldSelectorsSlotCount
                    ];
                    // clears the selector we are deleting and puts the last selector in its place.
                    oldSelectorSlot =
                        (oldSelectorSlot &
                            ~(CLEAR_SELECTOR_MASK >>
                                oldSelectorInSlotPosition)) |
                        (bytes32(lastSelector) >> oldSelectorInSlotPosition);
                    // update storage with the modified slot
                    ds.selectorSlots[oldSelectorsSlotCount] = oldSelectorSlot;
                } else {
                    // clears the selector we are deleting and puts the last selector in its place.
                    _selectorSlot =
                        (_selectorSlot &
                            ~(CLEAR_SELECTOR_MASK >>
                                oldSelectorInSlotPosition)) |
                        (bytes32(lastSelector) >> oldSelectorInSlotPosition);
                }
                if (selectorInSlotIndex == 0) {
                    delete ds.selectorSlots[selectorSlotCount];
                    _selectorSlot = 0;
                }
            }
            _selectorCount = selectorSlotCount * 8 + selectorInSlotIndex;
        } else {
            revert("LibDiamondCut: Incorrect FacetCutAction");
        }
        return (_selectorCount, _selectorSlot);
    }

    function initializeDiamondCut(
        address _init,
        bytes memory _calldata
    ) internal {
        if (_init == address(0)) {
            return;
        }
        enforceHasContractCode(
            _init,
            "LibDiamondCut: _init address has no code"
        );
        (bool success, bytes memory error) = _init.delegatecall(_calldata);
        if (!success) {
            if (error.length > 0) {
                // bubble up error
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(error)
                    revert(add(32, error), returndata_size)
                }
            } else {
                revert InitializationFunctionReverted(_init, _calldata);
            }
        }
    }

    function enforceHasContractCode(
        address _contract,
        string memory _errorMessage
    ) internal view {
        uint256 contractSize;
        assembly {
            contractSize := extcodesize(_contract)
        }
        require(contractSize > 0, _errorMessage);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/Base64Upgradeable.sol";

library TokenMetadata {
    using StringsUpgradeable for uint256;
    using StringsUpgradeable for address;
    using Base64Upgradeable for bytes;
    using TokenMetadata for TokenType;
    using TokenMetadata for Attribute[];

    enum TokenType {
        ERC20,
        ERC1155,
        ERC721
    }

    struct Attribute {
        string name;
        string displayType;
        string value;
        bool isNumber;
    }

    function toBase64(
        string memory json
    ) internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    "data:application/json;base64,",
                    bytes(json).encode()
                )
            );
    }

    function makeMetadataJSON(
        uint256 tokenId,
        address owner,
        string memory name,
        string memory imageURI,
        string memory description,
        Attribute[] memory attributes
    ) internal pure returns (string memory) {
        string memory metadataJSON = makeMetadataString(
            tokenId,
            owner,
            name,
            imageURI,
            description
        );
        return
            string(
                abi.encodePacked(
                    "data:application/json;base64,",
                    Base64Upgradeable.encode(
                        abi.encodePacked(
                            "{",
                            metadataJSON,
                            // attributes.toJSONString(),
                            "}"
                        )
                    )
                )
            );
    }

    function makeMetadataString(
        uint256 tokenId,
        address owner,
        string memory name,
        string memory imageURI,
        string memory description
    ) internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    '"name":"',
                    name,
                    '",',
                    // '"tokenId":"',
                    // tokenId.toString(),
                    // '",',
                    '"image":"',
                    imageURI,
                    '",',
                    '"description":"',
                    description //,
                    // '",',
                    // '"owner":"',
                    // owner.toHexString() //,
                    // '",'
                )
            );
    }

    function toJSONString(
        Attribute[] memory attributes
    ) internal pure returns (string memory) {
        string memory attributeString = "";
        for (uint256 i = 0; i < attributes.length; i++) {
            string memory comma = i == (attributes.length - 1) ? "" : ",";
            string memory quote = attributes[i].isNumber ? "" : '"';
            string memory value = string(
                abi.encodePacked(quote, attributes[i].value, quote)
            );
            string memory displayType = bytes(attributes[i].displayType)
                .length == 0
                ? ""
                : string(
                    abi.encodePacked(
                        '"display_type":"',
                        attributes[i].displayType,
                        '",'
                    )
                );
            string memory newAttributeString = string(
                abi.encodePacked(
                    attributeString,
                    '{"trait_type":"',
                    attributes[i].name,
                    '",',
                    displayType,
                    '"value":',
                    value,
                    "}",
                    comma
                )
            );
            attributeString = newAttributeString;
        }
        return string(abi.encodePacked('"attributes":[', attributeString, "]"));
    }

    function toString(
        TokenType tokenType
    ) internal pure returns (string memory) {
        return
            tokenType == TokenType.ERC721
                ? "ERC721"
                : tokenType == TokenType.ERC1155
                ? "ERC1155"
                : "ERC20";
    }

    function makeContractURI(
        string memory name,
        string memory description,
        string memory imageURL,
        string memory externalLinkURL,
        uint256 sellerFeeBasisPoints,
        address feeRecipient
    ) internal pure returns (string memory) {
        return
            string(
                abi.encodePacked(
                    '{"name":"',
                    name,
                    '",',
                    '"description":"',
                    description,
                    '",',
                    '"image":"',
                    imageURL,
                    '",',
                    '"external_link":"',
                    externalLinkURL,
                    '",',
                    '"seller_fee_basis_points":',
                    sellerFeeBasisPoints.toString(),
                    ",",
                    '"fee_recipient":"',
                    feeRecipient.toHexString(),
                    '"}'
                )
            );
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;

/******************************************************************************\
* Author: Nick Mudge <[email protected]> (https://twitter.com/mudgen)
* EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
*
* Implementation of a diamond.
/******************************************************************************/

import {LibDiamond} from "./libraries/LibDiamond.sol";
import {IDiamondCut} from "./interfaces/IDiamondCut.sol";
import {OwnableStorage, OwnableInternal} from "@solidstate/contracts/access/ownable/OwnableInternal.sol";
import {PaymentSplitterInternal} from "./utils/PaymentSplitter/PaymentSplitterInternal.sol";
import {ERC1155Facet} from "./facets/ERC1155Facet.sol";

// EIP-165 Imports
import {IDiamondLoupe} from "./interfaces/IDiamondLoupe.sol";
import {IERC165} from "@solidstate/contracts/interfaces/IERC165.sol";
import {IERC173} from "@solidstate/contracts/interfaces/IERC173.sol";
import {IERC1155} from "@solidstate/contracts/interfaces/IERC1155.sol";
import {IERC2981} from "@solidstate/contracts/interfaces/IERC2981.sol";
import {IERC1155Metadata} from "@solidstate/contracts/token/ERC1155/metadata/IERC1155Metadata.sol";

// Storage
import {ERC165Storage} from "@solidstate/contracts/introspection/ERC165Storage.sol";
import {ERC2981Storage} from "@solidstate/contracts/token/common/ERC2981/ERC2981Storage.sol";
import {ERC1155Storage} from "./storage/ERC1155Storage.sol";
import {ERC1155MetadataStorage} from "@solidstate/contracts/token/ERC1155/metadata/ERC1155MetadataStorage.sol";
import {ERC1155EnumerableStorage} from "@solidstate/contracts/token/ERC1155/enumerable/ERC1155EnumerableStorage.sol";

import "hardhat/console.sol";

contract Lively1155Diamond is PaymentSplitterInternal, OwnableInternal {
    using ERC165Storage for ERC165Storage.Layout;
    using ERC2981Storage for ERC2981Storage.Layout;

    event URI(string _value, uint256 indexed _id);

    /** @dev Think about cutting this constructor down and using multicall
     * transactions to set up in the contract in efficient way without bloating
     * the main constructor.  */
    struct DiamondArgs {
        address[] _payees;
        uint256[] _shares;
        address _secondaryPayee;
        uint16 _secondaryShare;
        bool _airdrop;
        string _name;
        string _symbol;
        string _contractURI;
        string _baseURI;
        ERC1155Storage.TokenStructure[] _tokenData;
    }

    constructor(
        IDiamondCut.FacetCut[] memory _diamondCut,
        DiamondArgs memory _args
    ) payable {
        uint256 payeesLength;
        uint256 sharesLength = _args._shares.length;
        if (!_args._airdrop) {
            payeesLength = _args._payees.length;
            if (payeesLength != sharesLength) {
                revert PaymentSplitterMismatch();
            }

            if (payeesLength == 0) {
                revert PaymentSplitterNoPayees();
            }
        }

        // Set various state variables
        OwnableStorage.layout().owner = msg.sender;
        ERC1155MetadataStorage.layout().baseURI = _args._baseURI;
        ERC1155Storage.layout().airdrop = _args._airdrop;
        ERC1155Storage.layout().name = _args._name;
        ERC1155Storage.layout().symbol = _args._symbol;

        // Set EIP-165 Supported Interfaces
        ERC165Storage.layout().setSupportedInterface(
            type(IERC165).interfaceId,
            true
        );
        ERC165Storage.layout().setSupportedInterface(
            type(IERC1155).interfaceId,
            true
        );
        ERC165Storage.layout().setSupportedInterface(
            type(IDiamondCut).interfaceId,
            true
        );
        ERC165Storage.layout().setSupportedInterface(
            type(IDiamondLoupe).interfaceId,
            true
        );
        ERC165Storage.layout().setSupportedInterface(
            type(IERC173).interfaceId,
            true
        );
        ERC165Storage.layout().setSupportedInterface(
            type(IERC1155Metadata).interfaceId,
            true
        );
        ERC165Storage.layout().setSupportedInterface(
            type(IERC2981).interfaceId,
            true
        );

        // Initial Cut
        LibDiamond.diamondCut(_diamondCut, address(0), "");

        // Initialize PaymentSplitter information (Primary Royalties)
        uint256 i = 0;
        for (; i < sharesLength; ) {
            _addPayee(_args._payees[i], _args._shares[i]);
            // Gas Optimization
            unchecked {
                ++i;
            }
        }

        // Initialize initial token data if available
        i = 0;
        uint256 tokenDataLength = _args._tokenData.length;
        ERC1155Storage.TokenStructure memory _token;
        for (; i < tokenDataLength; ) {
            console.log("About to create token: %s", i);

            _token = _args._tokenData[i];
            _token.creator = msg.sender;
            console.log("Max Supply: %s", _token.maxSupply);
            console.log("Price: %s", _token.price);
            console.log("creator: %s", _token.creator);
            console.log("Token URI: %s", _token.tokenUri);
            console.log("Allow List Enabled: %s", _token.allowListEnabled);

            console.log("Successfully called create function");
            uint256 _id = ERC1155Storage.layout().currentTokenId;

            // Do we want to store everything in top level mappings or use the tokenData struct mapping?
            // Not sure if there's a huge difference in gas costs here.
            ERC1155Storage.TokenStructure storage tokenData = ERC1155Storage
                .layout()
                .tokenData[_id];

            tokenData.maxSupply = _token.maxSupply;
            tokenData.price = _token.price;
            tokenData.creator = msg.sender;
            tokenData.tokenUri = _token.tokenUri;
            tokenData.allowListEnabled = _token.allowListEnabled;

            if (bytes(_token.tokenUri).length > 0) {
                emit URI(_token.tokenUri, _id);
            }

            ERC1155EnumerableStorage.layout().totalSupply[_id] = 0;
            ++ERC1155Storage.layout().currentTokenId;
            ++i;
        }
        // Set 2981 Royalty Info (Secondary Royalties)
        ERC2981Storage.layout().defaultRoyaltyBPS = _args._secondaryShare;
        ERC2981Storage.layout().defaultRoyaltyReceiver = _args._secondaryPayee;
    }

    // Find facet for function that is called and execute the
    // function if a facet is found and return any value.
    fallback() external payable {
        LibDiamond.DiamondStorage storage ds;
        bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;
        // get diamond storage
        assembly {
            ds.slot := position
        }
        // get facet from function selector
        address facet = address(bytes20(ds.facets[msg.sig]));
        require(facet != address(0), "Diamond: Function does not exist");
        // Execute external function from facet using delegatecall and return any value.
        assembly {
            // copy function selector and any arguments
            calldatacopy(0, 0, calldatasize())
            // execute function call using the facet
            let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)
            // get any return value
            returndatacopy(0, 0, returndatasize())
            // return any return value or error back to the caller
            switch result
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }

    receive() external payable {
        emit PaymentReceived(msg.sender, msg.value);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {EnumerableSet} from "@solidstate/contracts/data/EnumerableSet.sol";

library ERC1155Storage {
    using EnumerableSet for EnumerableSet.UintSet;

    struct TokenStructure {
        uint256 maxSupply;
        uint256 price;
        address creator;
        string tokenUri; // Optional, baseUri is set in ERC1155MetadataStorage (https://sample.com/{id}.json) would be valid)
        bool allowListEnabled;
        // bool onChainMetadata;
    }

    struct Layout {
        uint256 currentTokenId;
        bool airdrop;
        string name;
        string symbol;
        string contractURI;
        mapping(uint256 => uint256) maxSupply;
        mapping(uint256 => uint256) price;
        mapping(uint256 => EnumerableSet.AddressSet) creator;
        mapping(uint256 => string) tokenUri;
        mapping(uint256 => bool) allowListEnabled;
        mapping(uint256 => TokenStructure) tokenData; // Map Token ID to it's data, maybe take out?
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256("lively.contracts.storage.ERC1155");

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }

    function tokenData(
        uint256 _tokenId
    ) internal view returns (TokenStructure storage) {
        return layout().tokenData[_tokenId];
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {MetadataStorage} from "./MetadataStorage.sol";
import {TokenMetadata} from "../../libraries/TokenMetadata.sol";
import {OwnableInternal} from "@solidstate/contracts/access/ownable/OwnableInternal.sol";

contract MetadataInternal is OwnableInternal {
    using MetadataStorage for MetadataStorage.Layout;

    function _setMetadata(
        uint256 _tokenId,
        MetadataStorage.Metadata calldata _metadata
    ) internal onlyOwner {
        MetadataStorage.Layout storage metadataStore = MetadataStorage.layout();

        metadataStore.metadata[_tokenId].description = _metadata.description;
        metadataStore.metadata[_tokenId].external_url = _metadata.external_url;
        metadataStore.metadata[_tokenId].image = _metadata.image;
        metadataStore.metadata[_tokenId].name = _metadata.name;
        metadataStore.metadata[_tokenId].animation_url = _metadata
            .animation_url;
        // metadata.attributes = _metadata.attributes;

        uint256 attributesLength = _metadata.attributes.length;
        uint256 i = 0;
        while (i < attributesLength) {
            metadataStore.metadata[_tokenId].attributes.push(
                _metadata.attributes[i]
            );
            i++;
        }
    }

    function _getMetadata(
        uint256 _tokenId
    ) internal view returns (string memory) {
        return
            TokenMetadata.makeMetadataJSON(
                _tokenId,
                msg.sender,
                MetadataStorage.layout().metadata[_tokenId].name,
                MetadataStorage.layout().metadata[_tokenId].image,
                MetadataStorage.layout().metadata[_tokenId].description,
                MetadataStorage.layout().metadata[_tokenId].attributes
            );
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {TokenMetadata} from "../../libraries/TokenMetadata.sol";

library MetadataStorage {
    // struct Attribute {
    //     string trait_type;
    //     string value;
    // }
    struct Metadata {
        string description; // "Umphrey's McGee Nashville, TN 12/15/2020. Collection of all songs in the Lively NFT player and the ability to mint out all the songs into individual NFTs."
        string external_url; // https://golive.ly
        string image; // https://golive.ly/metadata/1155/images/{id}.png
        string name; // UM Tour Dec 15th, 22 - Nashville
        string animation_url; // https://golive.ly/metadata/1155/animations/{id}.mp4
        TokenMetadata.Attribute[] attributes; // [{ "trait_type": "Artist", "value": "Umphrey's McGee"}]
    }

    struct Layout {
        mapping(uint256 => Metadata) metadata;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256("lively.contracts.storage.MetadataStorage");

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (finance/PaymentSplitter.sol)

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned. The distribution of shares is set at the
 * time of contract deployment and can't be updated thereafter.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
interface IPaymentSplitterInternal {
    error PaymentSplitterMismatch();
    error PaymentSplitterNoPayees();

    event PayeeAdded(address account, uint256 shares);
    event PaymentReceived(address from, uint256 amount);
    event PaymentReleased(address to, uint256 amount);
    event ERC20PaymentReleased(
        IERC20 indexed token,
        address to,
        uint256 amount
    );
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (finance/PaymentSplitter.sol)

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";

import {PaymentSplitterStorage} from "./PaymentSplitterStorage.sol";
import {IPaymentSplitterInternal} from "./IPaymentSplitterInternal.sol";

abstract contract PaymentSplitterInternal is IPaymentSplitterInternal {
    using PaymentSplitterStorage for PaymentSplitterStorage.Layout;

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     *
     * Removed for diamond contract, moved emitter to Diamond.sol
     */
    // receive() external payable virtual {
    //     emit PaymentReceived(_msgSender(), msg.value);
    // }

    // =============================================================
    //                   From OpenZeppelin
    // =============================================================
    /**
     * @dev Getter for the total shares held by payees.
     */
    // Public
    function _totalShares() internal view returns (uint256) {
        return PaymentSplitterStorage.layout().totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    // Public
    function _totalReleased() internal view returns (uint256) {
        return PaymentSplitterStorage.layout().totalReleased;
    }

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    // Public
    function _totalReleased(IERC20 token) internal view returns (uint256) {
        return PaymentSplitterStorage.layout().erc20TotalReleased[token];
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    // Public
    function _shares(address account) internal view returns (uint256) {
        return PaymentSplitterStorage.layout().shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    // Public
    function _released(address account) internal view returns (uint256) {
        return PaymentSplitterStorage.layout().released[account];
    }

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    // Public
    function _released(
        IERC20 token,
        address account
    ) internal view returns (uint256) {
        return PaymentSplitterStorage.layout().erc20Released[token][account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    // Public
    function _payee(uint256 index) internal view returns (address) {
        return PaymentSplitterStorage.layout().payees[index];
    }

    /**
     * @dev Getter for the amount of payee's releasable Ether.
     */
    // Public
    function _releasable(address account) internal view returns (uint256) {
        uint256 totalReceived = address(this).balance + _totalReleased();
        return _pendingPayment(account, totalReceived, _released(account));
    }

    /**
     * @dev Getter for the amount of payee's releasable `token` tokens. `token` should be the address of an
     * IERC20 contract.
     */
    // Public
    function _releasable(
        IERC20 token,
        address account
    ) internal view returns (uint256) {
        uint256 totalReceived = token.balanceOf(address(this)) +
            _totalReleased(token);
        return
            _pendingPayment(account, totalReceived, _released(token, account));
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    // Public
    function _release(address payable account) internal virtual {
        require(
            PaymentSplitterStorage.layout().shares[account] > 0,
            "PaymentSplitter: account has no shares"
        );

        uint256 payment = _releasable(account);

        require(payment != 0, "PaymentSplitter: account is not due payment");

        // PaymentSplitterStorage.layout().totalReleased is the sum of all values in PaymentSplitterStorage.layout().released.
        // If "s.totalReleased += payment" does not overflow, then "s.released[account] += payment" cannot overflow.
        PaymentSplitterStorage.layout().totalReleased += payment;
        unchecked {
            PaymentSplitterStorage.layout().released[account] += payment;
        }

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
     * contract.
     */
    // Public
    function _release(IERC20 token, address account) internal virtual {
        require(
            PaymentSplitterStorage.layout().shares[account] > 0,
            "PaymentSplitter: account has no shares"
        );

        uint256 payment = _releasable(token, account);

        require(payment != 0, "PaymentSplitter: account is not due payment");

        // PaymentSplitterStorage.layout().erc20TotalReleased[token] is the sum of all values in PaymentSplitterStorage.layout().erc20Released[token].
        // If "s.erc20TotalReleased[token] += payment" does not overflow, then "s.erc20Released[token][account] += payment"
        // cannot overflow.
        PaymentSplitterStorage.layout().erc20TotalReleased[token] += payment;
        unchecked {
            PaymentSplitterStorage.layout().erc20Released[token][
                account
            ] += payment;
        }

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) internal view returns (uint256) {
        return
            (totalReceived * PaymentSplitterStorage.layout().shares[account]) /
            PaymentSplitterStorage.layout().totalShares -
            alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) internal {
        require(
            account != address(0),
            "PaymentSplitter: account is the zero address"
        );
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(
            PaymentSplitterStorage.layout().shares[account] == 0,
            "PaymentSplitter: account already has shares"
        );

        PaymentSplitterStorage.layout().payees.push(account);
        PaymentSplitterStorage.layout().shares[account] = shares_;
        PaymentSplitterStorage.layout().totalShares =
            PaymentSplitterStorage.layout().totalShares +
            shares_;
        emit PayeeAdded(account, shares_);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

library PaymentSplitterStorage {
    struct Layout {
        uint256 totalShares;
        uint256 totalReleased;
        mapping(address => uint256) shares;
        mapping(address => uint256) released;
        address[] payees;
        mapping(IERC20 => uint256) erc20TotalReleased;
        mapping(IERC20 => mapping(address => uint256)) erc20Released;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256("lively.contracts.storage.PaymentSplitter");

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >= 0.4.22 <0.9.0;

library console {
	address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);

	function _sendLogPayload(bytes memory payload) private view {
		uint256 payloadLength = payload.length;
		address consoleAddress = CONSOLE_ADDRESS;
		assembly {
			let payloadStart := add(payload, 32)
			let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
		}
	}

	function log() internal view {
		_sendLogPayload(abi.encodeWithSignature("log()"));
	}

	function logInt(int256 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
	}

	function logUint(uint256 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
	}

	function logString(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function logBool(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function logAddress(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function logBytes(bytes memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
	}

	function logBytes1(bytes1 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
	}

	function logBytes2(bytes2 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
	}

	function logBytes3(bytes3 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
	}

	function logBytes4(bytes4 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
	}

	function logBytes5(bytes5 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
	}

	function logBytes6(bytes6 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
	}

	function logBytes7(bytes7 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
	}

	function logBytes8(bytes8 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
	}

	function logBytes9(bytes9 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
	}

	function logBytes10(bytes10 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
	}

	function logBytes11(bytes11 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
	}

	function logBytes12(bytes12 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
	}

	function logBytes13(bytes13 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
	}

	function logBytes14(bytes14 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
	}

	function logBytes15(bytes15 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
	}

	function logBytes16(bytes16 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
	}

	function logBytes17(bytes17 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
	}

	function logBytes18(bytes18 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
	}

	function logBytes19(bytes19 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
	}

	function logBytes20(bytes20 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
	}

	function logBytes21(bytes21 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
	}

	function logBytes22(bytes22 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
	}

	function logBytes23(bytes23 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
	}

	function logBytes24(bytes24 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
	}

	function logBytes25(bytes25 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
	}

	function logBytes26(bytes26 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
	}

	function logBytes27(bytes27 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
	}

	function logBytes28(bytes28 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
	}

	function logBytes29(bytes29 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
	}

	function logBytes30(bytes30 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
	}

	function logBytes31(bytes31 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
	}

	function logBytes32(bytes32 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
	}

	function log(uint256 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
	}

	function log(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function log(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function log(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function log(uint256 p0, uint256 p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
	}

	function log(uint256 p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
	}

	function log(uint256 p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
	}

	function log(uint256 p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
	}

	function log(string memory p0, uint256 p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
	}

	function log(string memory p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
	}

	function log(string memory p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
	}

	function log(string memory p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
	}

	function log(bool p0, uint256 p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
	}

	function log(bool p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
	}

	function log(bool p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
	}

	function log(bool p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
	}

	function log(address p0, uint256 p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
	}

	function log(address p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
	}

	function log(address p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
	}

	function log(address p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
	}

	function log(uint256 p0, uint256 p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
	}

	function log(uint256 p0, uint256 p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
	}

	function log(uint256 p0, uint256 p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
	}

	function log(uint256 p0, uint256 p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
	}

	function log(uint256 p0, string memory p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
	}

	function log(uint256 p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
	}

	function log(uint256 p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
	}

	function log(uint256 p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
	}

	function log(uint256 p0, bool p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
	}

	function log(uint256 p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
	}

	function log(uint256 p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
	}

	function log(uint256 p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
	}

	function log(uint256 p0, address p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
	}

	function log(uint256 p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
	}

	function log(uint256 p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
	}

	function log(uint256 p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
	}

	function log(string memory p0, uint256 p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
	}

	function log(string memory p0, uint256 p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
	}

	function log(string memory p0, uint256 p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
	}

	function log(string memory p0, uint256 p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
	}

	function log(string memory p0, address p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
	}

	function log(string memory p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
	}

	function log(string memory p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
	}

	function log(string memory p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
	}

	function log(bool p0, uint256 p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
	}

	function log(bool p0, uint256 p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
	}

	function log(bool p0, uint256 p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
	}

	function log(bool p0, uint256 p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
	}

	function log(bool p0, bool p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
	}

	function log(bool p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
	}

	function log(bool p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
	}

	function log(bool p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
	}

	function log(bool p0, address p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
	}

	function log(bool p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
	}

	function log(bool p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
	}

	function log(bool p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
	}

	function log(address p0, uint256 p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
	}

	function log(address p0, uint256 p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
	}

	function log(address p0, uint256 p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
	}

	function log(address p0, uint256 p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
	}

	function log(address p0, string memory p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
	}

	function log(address p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
	}

	function log(address p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
	}

	function log(address p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
	}

	function log(address p0, bool p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
	}

	function log(address p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
	}

	function log(address p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
	}

	function log(address p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
	}

	function log(address p0, address p1, uint256 p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
	}

	function log(address p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
	}

	function log(address p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
	}

	function log(address p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
	}

	function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, uint256 p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
	}

	function log(uint256 p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint256 p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint256 p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint256 p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint256 p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint256 p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint256 p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint256 p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, uint256 p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
	}

}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import {OperatorFilterer} from "./OperatorFilterer.sol";

/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 */
abstract contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function unregister(address addr) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

import {IOperatorFilterRegistry} from "./IOperatorFilterRegistry.sol";

/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"components":[{"internalType":"address","name":"facetAddress","type":"address"},{"internalType":"enum IDiamondCut.FacetCutAction","name":"action","type":"uint8"},{"internalType":"bytes4[]","name":"functionSelectors","type":"bytes4[]"}],"internalType":"struct IDiamondCut.FacetCut[]","name":"_diamondCut","type":"tuple[]"},{"components":[{"internalType":"address[]","name":"_payees","type":"address[]"},{"internalType":"uint256[]","name":"_shares","type":"uint256[]"},{"internalType":"address","name":"_secondaryPayee","type":"address"},{"internalType":"uint16","name":"_secondaryShare","type":"uint16"},{"internalType":"bool","name":"_airdrop","type":"bool"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"string","name":"_contractURI","type":"string"},{"internalType":"string","name":"_baseURI","type":"string"},{"components":[{"internalType":"uint256","name":"maxSupply","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"address","name":"creator","type":"address"},{"internalType":"string","name":"tokenUri","type":"string"},{"internalType":"bool","name":"allowListEnabled","type":"bool"}],"internalType":"struct ERC1155Storage.TokenStructure[]","name":"_tokenData","type":"tuple[]"}],"internalType":"struct Lively1155Diamond.DiamondArgs","name":"_args","type":"tuple"}],"stateMutability":"payable","type":"constructor"},{"inputs":[],"name":"ERC165Storage__InvalidInterfaceId","type":"error"},{"inputs":[{"internalType":"address","name":"_initializationContractAddress","type":"address"},{"internalType":"bytes","name":"_calldata","type":"bytes"}],"name":"InitializationFunctionReverted","type":"error"},{"inputs":[],"name":"Ownable__NotOwner","type":"error"},{"inputs":[],"name":"Ownable__NotTransitiveOwner","type":"error"},{"inputs":[],"name":"PaymentSplitterMismatch","type":"error"},{"inputs":[],"name":"PaymentSplitterNoPayees","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","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"},{"stateMutability":"payable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000004c000000000000000000000000000000000000000000000000000000000000005e000000000000000000000000000000000000000000000000000000000000006e000000000000000000000000000000000000000000000000000000000000007c000000000000000000000000000000000000000000000000000000000000009c00000000000000000000000000000000000000000000000000000000000000a800000000000000000000000000000000000000000000000000000000000000c400000000000000000000000000000000000000000000000000000000000000ce0000000000000000000000000940ca54dcaa9a19c32735d3062ae83b751ec64f400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000001941f43434000000000000000000000000000000000000000000000000000000006dcfd8410000000000000000000000000000000000000000000000000000000000fdd58e000000000000000000000000000000000000000000000000000000004e1273f400000000000000000000000000000000000000000000000000000000f5298aca000000000000000000000000000000000000000000000000000000008fdc4294000000000000000000000000000000000000000000000000000000004f558e7900000000000000000000000000000000000000000000000000000000e985e9c500000000000000000000000000000000000000000000000000000000869f759400000000000000000000000000000000000000000000000000000000156e29f60000000000000000000000000000000000000000000000000000000006fdde030000000000000000000000000000000000000000000000000000000026a49e37000000000000000000000000000000000000000000000000000000002eb2c2d600000000000000000000000000000000000000000000000000000000f242432a00000000000000000000000000000000000000000000000000000000a22cb4650000000000000000000000000000000000000000000000000000000037da577c00000000000000000000000000000000000000000000000000000000c47f002700000000000000000000000000000000000000000000000000000000f7d9757700000000000000000000000000000000000000000000000000000000b84c82460000000000000000000000000000000000000000000000000000000045205c670000000000000000000000000000000000000000000000000000000095d89b410000000000000000000000000000000000000000000000000000000085bff2e70000000000000000000000000000000000000000000000000000000013ba55df00000000000000000000000000000000000000000000000000000000bd85b039000000000000000000000000000000000000000000000000000000000e89341c000000000000000000000000000000000000000000000000000000000000000000000000000000004e64f37e15f4be33981fab15d77ffcaa3dcceef2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000005cdffacc60000000000000000000000000000000000000000000000000000000052ef6b2c00000000000000000000000000000000000000000000000000000000adfca15e000000000000000000000000000000000000000000000000000000007a0ed6270000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000000000000000e6da1f03e5340318f161ae7f74f3d4130db908d80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000043344ca2e000000000000000000000000000000000000000000000000000000008da5cb5b0000000000000000000000000000000000000000000000000000000013af403500000000000000000000000000000000000000000000000000000000f2fde38b000000000000000000000000000000000000000000000000000000000000000000000000000000006345fb9d762c8a73f243a86cf7326a13f4a4b1f40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000038456cb59000000000000000000000000000000000000000000000000000000005c975abb000000000000000000000000000000000000000000000000000000003f4ba83a000000000000000000000000000000000000000000000000000000000000000000000000000000002b9da8c64c1c8f17655f80f430f2ea50135dd66300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000c18f9b023000000000000000000000000000000000000000000000000000000008b83209b00000000000000000000000000000000000000000000000000000000a3f8eace00000000000000000000000000000000000000000000000000000000c45ac05000000000000000000000000000000000000000000000000000000000191655870000000000000000000000000000000000000000000000000000000048b7504400000000000000000000000000000000000000000000000000000000406072a9000000000000000000000000000000000000000000000000000000009852595c00000000000000000000000000000000000000000000000000000000ce7c2ac200000000000000000000000000000000000000000000000000000000d79779b200000000000000000000000000000000000000000000000000000000e33b7de3000000000000000000000000000000000000000000000000000000003a98ef3900000000000000000000000000000000000000000000000000000000000000000000000000000000b06606c9fcb36bb05d8c9d56874315f1dc8ab6e40000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000022a55205a0000000000000000000000000000000000000000000000000000000005b4d1d60000000000000000000000000000000000000000000000000000000000000000000000000000000024d2272618f929c7126be6f2c860a5b9a2bfb73f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000a029238170000000000000000000000000000000000000000000000000000000031f59102000000000000000000000000000000000000000000000000000000007263cfe200000000000000000000000000000000000000000000000000000000d9ebffcd0000000000000000000000000000000000000000000000000000000087b9d25c0000000000000000000000000000000000000000000000000000000022bd5c1c00000000000000000000000000000000000000000000000000000000834029ba00000000000000000000000000000000000000000000000000000000dc2fbaee00000000000000000000000000000000000000000000000000000000a51312c800000000000000000000000000000000000000000000000000000000eba8dabc00000000000000000000000000000000000000000000000000000000000000000000000000000000250d46b7a8d797e79c759695c05adf8dc3a68c080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000011f931c1c000000000000000000000000000000000000000000000000000000000000000000000000000000000ef10d2ded7d1c8f2f00d99f52c9f2850f0c562b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000025c60da1b00000000000000000000000000000000000000000000000000000000c39aa07d00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000001a0000000000000000000000000906df91f5c2c7ad60deaf6a54990676276fcede200000000000000000000000000000000000000000000000000000000000001f4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000240000000000000000000000000000000000000000000000000000000000000028000000000000000000000000000000000000000000000000000000000000002e000000000000000000000000000000000000000000000000000000000000003600000000000000000000000000000000000000000000000000000000000000002000000000000000000000000906df91f5c2c7ad60deaf6a54990676276fcede2000000000000000000000000a443d182c44703c4e823d252e8b1ac01f04610840000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000213400000000000000000000000000000000000000000000000000000000000005dc0000000000000000000000000000000000000000000000000000000000000006756d4c49564500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006756d4c4956450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004068747470733a2f2f676f6c6976652e6c792f776562332f6d6574612f61303966303934392d666461342d346531622d613762322d373964646134396136383938000000000000000000000000000000000000000000000000000000000000004168747470733a2f2f676f6c6976652e6c792f776562332f6d6574612f61303966303934392d666461342d346531622d613762322d3739646461343961363839382f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000190000000000000000000000000000000000000000000000000058d15e17628000000000000000000000000000906df91f5c2c7ad60deaf6a54990676276fcede200000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _diamondCut (tuple[]): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput],System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]
Arg [1] : _args (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]

-----Encoded View---------------
147 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000e00
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [4] : 00000000000000000000000000000000000000000000000000000000000004c0
Arg [5] : 00000000000000000000000000000000000000000000000000000000000005e0
Arg [6] : 00000000000000000000000000000000000000000000000000000000000006e0
Arg [7] : 00000000000000000000000000000000000000000000000000000000000007c0
Arg [8] : 00000000000000000000000000000000000000000000000000000000000009c0
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000a80
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000c40
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000ce0
Arg [12] : 000000000000000000000000940ca54dcaa9a19c32735d3062ae83b751ec64f4
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000019
Arg [16] : 41f4343400000000000000000000000000000000000000000000000000000000
Arg [17] : 6dcfd84100000000000000000000000000000000000000000000000000000000
Arg [18] : 00fdd58e00000000000000000000000000000000000000000000000000000000
Arg [19] : 4e1273f400000000000000000000000000000000000000000000000000000000
Arg [20] : f5298aca00000000000000000000000000000000000000000000000000000000
Arg [21] : 8fdc429400000000000000000000000000000000000000000000000000000000
Arg [22] : 4f558e7900000000000000000000000000000000000000000000000000000000
Arg [23] : e985e9c500000000000000000000000000000000000000000000000000000000
Arg [24] : 869f759400000000000000000000000000000000000000000000000000000000
Arg [25] : 156e29f600000000000000000000000000000000000000000000000000000000
Arg [26] : 06fdde0300000000000000000000000000000000000000000000000000000000
Arg [27] : 26a49e3700000000000000000000000000000000000000000000000000000000
Arg [28] : 2eb2c2d600000000000000000000000000000000000000000000000000000000
Arg [29] : f242432a00000000000000000000000000000000000000000000000000000000
Arg [30] : a22cb46500000000000000000000000000000000000000000000000000000000
Arg [31] : 37da577c00000000000000000000000000000000000000000000000000000000
Arg [32] : c47f002700000000000000000000000000000000000000000000000000000000
Arg [33] : f7d9757700000000000000000000000000000000000000000000000000000000
Arg [34] : b84c824600000000000000000000000000000000000000000000000000000000
Arg [35] : 45205c6700000000000000000000000000000000000000000000000000000000
Arg [36] : 95d89b4100000000000000000000000000000000000000000000000000000000
Arg [37] : 85bff2e700000000000000000000000000000000000000000000000000000000
Arg [38] : 13ba55df00000000000000000000000000000000000000000000000000000000
Arg [39] : bd85b03900000000000000000000000000000000000000000000000000000000
Arg [40] : 0e89341c00000000000000000000000000000000000000000000000000000000
Arg [41] : 0000000000000000000000004e64f37e15f4be33981fab15d77ffcaa3dcceef2
Arg [42] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [43] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [44] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [45] : cdffacc600000000000000000000000000000000000000000000000000000000
Arg [46] : 52ef6b2c00000000000000000000000000000000000000000000000000000000
Arg [47] : adfca15e00000000000000000000000000000000000000000000000000000000
Arg [48] : 7a0ed62700000000000000000000000000000000000000000000000000000000
Arg [49] : 01ffc9a700000000000000000000000000000000000000000000000000000000
Arg [50] : 000000000000000000000000e6da1f03e5340318f161ae7f74f3d4130db908d8
Arg [51] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [52] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [53] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [54] : 3344ca2e00000000000000000000000000000000000000000000000000000000
Arg [55] : 8da5cb5b00000000000000000000000000000000000000000000000000000000
Arg [56] : 13af403500000000000000000000000000000000000000000000000000000000
Arg [57] : f2fde38b00000000000000000000000000000000000000000000000000000000
Arg [58] : 0000000000000000000000006345fb9d762c8a73f243a86cf7326a13f4a4b1f4
Arg [59] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [60] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [61] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [62] : 8456cb5900000000000000000000000000000000000000000000000000000000
Arg [63] : 5c975abb00000000000000000000000000000000000000000000000000000000
Arg [64] : 3f4ba83a00000000000000000000000000000000000000000000000000000000
Arg [65] : 0000000000000000000000002b9da8c64c1c8f17655f80f430f2ea50135dd663
Arg [66] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [67] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [68] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [69] : 18f9b02300000000000000000000000000000000000000000000000000000000
Arg [70] : 8b83209b00000000000000000000000000000000000000000000000000000000
Arg [71] : a3f8eace00000000000000000000000000000000000000000000000000000000
Arg [72] : c45ac05000000000000000000000000000000000000000000000000000000000
Arg [73] : 1916558700000000000000000000000000000000000000000000000000000000
Arg [74] : 48b7504400000000000000000000000000000000000000000000000000000000
Arg [75] : 406072a900000000000000000000000000000000000000000000000000000000
Arg [76] : 9852595c00000000000000000000000000000000000000000000000000000000
Arg [77] : ce7c2ac200000000000000000000000000000000000000000000000000000000
Arg [78] : d79779b200000000000000000000000000000000000000000000000000000000
Arg [79] : e33b7de300000000000000000000000000000000000000000000000000000000
Arg [80] : 3a98ef3900000000000000000000000000000000000000000000000000000000
Arg [81] : 000000000000000000000000b06606c9fcb36bb05d8c9d56874315f1dc8ab6e4
Arg [82] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [83] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [84] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [85] : 2a55205a00000000000000000000000000000000000000000000000000000000
Arg [86] : 05b4d1d600000000000000000000000000000000000000000000000000000000
Arg [87] : 00000000000000000000000024d2272618f929c7126be6f2c860a5b9a2bfb73f
Arg [88] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [89] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [90] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [91] : 0292381700000000000000000000000000000000000000000000000000000000
Arg [92] : 31f5910200000000000000000000000000000000000000000000000000000000
Arg [93] : 7263cfe200000000000000000000000000000000000000000000000000000000
Arg [94] : d9ebffcd00000000000000000000000000000000000000000000000000000000
Arg [95] : 87b9d25c00000000000000000000000000000000000000000000000000000000
Arg [96] : 22bd5c1c00000000000000000000000000000000000000000000000000000000
Arg [97] : 834029ba00000000000000000000000000000000000000000000000000000000
Arg [98] : dc2fbaee00000000000000000000000000000000000000000000000000000000
Arg [99] : a51312c800000000000000000000000000000000000000000000000000000000
Arg [100] : eba8dabc00000000000000000000000000000000000000000000000000000000
Arg [101] : 000000000000000000000000250d46b7a8d797e79c759695c05adf8dc3a68c08
Arg [102] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [103] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [104] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [105] : 1f931c1c00000000000000000000000000000000000000000000000000000000
Arg [106] : 0000000000000000000000000ef10d2ded7d1c8f2f00d99f52c9f2850f0c562b
Arg [107] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [108] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [109] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [110] : 5c60da1b00000000000000000000000000000000000000000000000000000000
Arg [111] : c39aa07d00000000000000000000000000000000000000000000000000000000
Arg [112] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [113] : 00000000000000000000000000000000000000000000000000000000000001a0
Arg [114] : 000000000000000000000000906df91f5c2c7ad60deaf6a54990676276fcede2
Arg [115] : 00000000000000000000000000000000000000000000000000000000000001f4
Arg [116] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [117] : 0000000000000000000000000000000000000000000000000000000000000200
Arg [118] : 0000000000000000000000000000000000000000000000000000000000000240
Arg [119] : 0000000000000000000000000000000000000000000000000000000000000280
Arg [120] : 00000000000000000000000000000000000000000000000000000000000002e0
Arg [121] : 0000000000000000000000000000000000000000000000000000000000000360
Arg [122] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [123] : 000000000000000000000000906df91f5c2c7ad60deaf6a54990676276fcede2
Arg [124] : 000000000000000000000000a443d182c44703c4e823d252e8b1ac01f0461084
Arg [125] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [126] : 0000000000000000000000000000000000000000000000000000000000002134
Arg [127] : 00000000000000000000000000000000000000000000000000000000000005dc
Arg [128] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [129] : 756d4c4956450000000000000000000000000000000000000000000000000000
Arg [130] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [131] : 756d4c4956450000000000000000000000000000000000000000000000000000
Arg [132] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [133] : 68747470733a2f2f676f6c6976652e6c792f776562332f6d6574612f61303966
Arg [134] : 303934392d666461342d346531622d613762322d373964646134396136383938
Arg [135] : 0000000000000000000000000000000000000000000000000000000000000041
Arg [136] : 68747470733a2f2f676f6c6976652e6c792f776562332f6d6574612f61303966
Arg [137] : 303934392d666461342d346531622d613762322d373964646134396136383938
Arg [138] : 2f00000000000000000000000000000000000000000000000000000000000000
Arg [139] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [140] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [141] : 0000000000000000000000000000000000000000000000000000000000000019
Arg [142] : 0000000000000000000000000000000000000000000000000058d15e17628000
Arg [143] : 000000000000000000000000906df91f5c2c7ad60deaf6a54990676276fcede2
Arg [144] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [145] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [146] : 0000000000000000000000000000000000000000000000000000000000000000

222:214:53:-:0;;;;;;7734:38:45;;;7750:10;297:51:63;;7762:9:45;379:2:63;364:18;;357:34;7734:38:45;;270:18:63;7734:38:45;;;;;;;222:214:53;;6616:36:45;6904:7;;-1:-1:-1;;;;;;6904:7:45;6894:18;;784:45:50;6894:18:45;;;;;;;;;784:45:50;;6878:36:45;;;6924:64;;;;-1:-1:-1;;;6924:64:45;;604:2:63;6924:64:45;;;586:21:63;;;623:18;;;616:30;682:34;662:18;;;655:62;734:18;;6924:64:45;;;;;;;;;7185:14;7182:1;7179;7166:34;7329:1;7326;7310:14;7307:1;7300:5;7293;7280:51;7401:16;7398:1;7395;7380:38;7505:6;7524:66;;;;7639:16;7636:1;7629:27;7524:66;7559:16;7556:1;7549:27;242:159:12;186:49;;242:159::o;351::39:-;190:57;;351:159::o;1118::52:-;1066:45;;1118:159::o;318::23:-;263:48;;318:159::o;666:276::-;-1:-1:-1;;;;;;801:25:23;;;;;797:85;;847:35;;-1:-1:-1;;;847:35:23;;;;;;;;;;;797:85;-1:-1:-1;;;;;;892:34:23;;;;:21;:34;;;;;;;;;;;;:43;;-1:-1:-1;;892:43:23;;;;;;;;;;666:276::o;2462:1756:50:-;2699:16;;784:45;;2699:16;;;;;;2613:25;;2967:1;2951:17;:21;2947:227;;-1:-1:-1;3161:1:50;3144:18;;;3127:36;;;;:16;;;:36;;;;;;2947:227;3237:18;3219:441;3282:11;:18;3269:10;:31;3219:441;;;3383:266;3431:13;3462:12;3492:11;3504:10;3492:23;;;;;;;;:::i;:::-;;;;;;;:36;;;3546:11;3558:10;3546:23;;;;;;;;:::i;:::-;;;;;;;:30;;;3594:11;3606:10;3594:23;;;;;;;;:::i;:::-;;;;;;;:41;;;3383:30;:266::i;:::-;3351:298;;-1:-1:-1;3351:298:50;-1:-1:-1;3314:12:50;;;;:::i;:::-;;;;3219:441;;;;3690:21;3673:13;:38;3669:109;;3727:16;;;:40;;-1:-1:-1;;3727:40:50;;;;;;;3669:109;3938:1;3922:17;;:21;3918:190;;4080:1;4063:18;;;4046:36;;;;:16;;;:36;;;;;:51;;;3918:190;4122:41;4133:11;4146:5;4153:9;4122:41;;;;;;;;:::i;:::-;;;;;;;;4173:38;4194:5;4201:9;4173:20;:38::i;:::-;2603:1615;;;;2462:1756;;;:::o;5936:136:59:-;5997:71;6060:2;6064;6013:54;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;6013:54:59;;;;;;;;;;;;;;-1:-1:-1;;;;;6013:54:59;-1:-1:-1;;;6013:54:59;;;5997:15;:71::i;:::-;5936:136;;:::o;6352:::-;6413:71;6476:2;6480;6429:54;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;6429:54:59;;;;;;;;;;;;;;-1:-1:-1;;;;;6429:54:59;-1:-1:-1;;;6429:54:59;;;6413:15;:71::i;6075:141::-;6142:70;6204:2;6208;6158:53;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;6158:53:59;;;;;;;;;;;;;;-1:-1:-1;;;;;6158:53:59;-1:-1:-1;;;6158:53:59;;;6142:15;:70::i;6219:130::-;6277:68;6337:2;6341;6293:51;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;6293:51:59;;;;;;;;;;;;;;-1:-1:-1;;;;;6293:51:59;-1:-1:-1;;;6293:51:59;;;6277:15;:68::i;5072:112::-;5121:59;5176:2;5137:42;;;;;;;;:::i;:::-;;;;-1:-1:-1;;5137:42:59;;;;;;;;;;;;;;-1:-1:-1;;;;;5137:42:59;-1:-1:-1;;;5137:42:59;;;5121:15;:59::i;:::-;5072:112;:::o;491:159:35:-;425:59;;491:159::o;497::42:-;441:49;;497:159::o;613::58:-;553:53;;613:159::o;4845:114:59:-;4895:60;4951:2;4911:43;;;;;;5601:25:63;;5589:2;5574:18;;5455:177;4911:43:59;;;;-1:-1:-1;;4911:43:59;;;;;;;;;;;;;;-1:-1:-1;;;;;4911:43:59;-1:-1:-1;;;4911:43:59;;;4895:15;:60::i;4224:8231:50:-;4465:7;;;784:45;4493:44;;4588:1;4568:10;:17;:21;4547:111;;;;-1:-1:-1;;;4547:111:50;;5839:2:63;4547:111:50;;;5821:21:63;5878:2;5858:18;;;5851:30;5917:34;5897:18;;;5890:62;-1:-1:-1;;;5968:18:63;;;5961:41;6019:19;;4547:111:50;5637:407:63;4547:111:50;4683:30;4672:7;:41;;;;;;;;:::i;:::-;;4668:7733;;4729:126;4769:16;4729:126;;;;;;;;;;;;;;;;;:22;:126::i;:::-;4891:21;4869:1701;4946:10;:17;4930:13;:33;4869:1701;;;5029:15;5047:10;5058:13;5047:25;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;;5109:19:50;;5090:16;5109:19;;;;;;;;;;;;5047:25;;-1:-1:-1;5150:26:50;;;;:40;5146:160;;5214:23;;;;;;;;;;;;;;-1:-1:-1;;;5214:23:50;;;:11;:23::i;:::-;5259:28;5278:8;5259:18;:28::i;:::-;5352:26;;;;:40;5323:164;;;;-1:-1:-1;;;5323:164:50;;6251:2:63;5323:164:50;;;6233:21:63;6290:2;6270:18;;;6263:30;6329:34;6309:18;;;6302:62;-1:-1:-1;;;6380:18:63;;;6373:51;6441:19;;5323:164:50;6049:417:63;5323:164:50;-1:-1:-1;;;;;;5547:19:50;;;5637:23;5547:19;;;;;;;;;;-1:-1:-1;;;;;;5589:25:50;;;;:71;;;5547:113;;5874:25;5898:1;5874:25;;;;;6064:45;;;6062:48;6022:88;;;;6135:43;;;6021:158;;6261:29;;;6257:265;;6446:1;6428:19;;;6411:37;;;;:16;;;:37;;;;;:53;;;;6257:265;6539:16;;;;:::i;:::-;;;;5011:1559;;;4981:15;;;;;:::i;:::-;;;;4869:1701;;;;4668:7733;;;6601:34;6590:7;:45;;;;;;;;:::i;:::-;;6586:5815;;6651:130;6691:16;6651:130;;;;;;;;;;;;;;;;;:22;:130::i;:::-;6817:21;6795:1110;6872:10;:17;6856:13;:33;6795:1110;;;6955:15;6973:10;6984:13;6973:25;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;;7035:19:50;;7016:16;7035:19;;;;;;;;;;;;6973:25;;-1:-1:-1;7098:26:50;;;;7258:4;7231:32;;7202:150;;;;-1:-1:-1;;;7202:150:50;;6673:2:63;7202:150:50;;;6655:21:63;6712:2;6692:18;;;6685:30;6751:34;6731:18;;;6724:62;-1:-1:-1;;;6802:18:63;;;6795:45;6857:19;;7202:150:50;6471:411:63;7202:150:50;7418:16;-1:-1:-1;;;;;7399:35:50;:15;-1:-1:-1;;;;;7399:35:50;;7370:162;;;;-1:-1:-1;;;7370:162:50;;7089:2:63;7370:162:50;;;7071:21:63;7128:2;7108:18;;;7101:30;7167:34;7147:18;;;7140:62;7238:26;7218:18;;;7211:54;7282:19;;7370:162:50;6887:420:63;7370:162:50;-1:-1:-1;;;;;7579:29:50;;7550:156;;;;-1:-1:-1;;;7550:156:50;;7514:2:63;7550:156:50;;;7496:21:63;7553:2;7533:18;;;7526:30;7592:34;7572:18;;;7565:62;7663:26;7643:18;;;7636:54;7707:19;;7550:156:50;7312:420:63;7550:156:50;-1:-1:-1;;;;;;;7769:19:50;;;1989:44;7769:19;;;;;;;;;;7811:79;7812:29;;;;-1:-1:-1;;;;;;7865:25:50;;;;7811:79;;7769:121;;6907:15;;;;:::i;:::-;;;;6795:1110;;6586:5815;7936:33;7925:7;:44;;;;;;;;:::i;:::-;;7921:4480;;-1:-1:-1;;;;;8010:30:50;;;7985:143;;;;-1:-1:-1;;;7985:143:50;;7939:2:63;7985:143:50;;;7921:21:63;7978:2;7958:18;;;7951:30;8017:34;7997:18;;;7990:62;-1:-1:-1;;;8068:18:63;;;8061:52;8130:19;;7985:143:50;7737:418:63;7985:143:50;8279:1;8261:19;;;8433:1;8416:18;;8233:25;8448:3789;8525:10;:17;8509:13;:33;8448:3789;;;8629:1;8612:18;;;8608:315;;8699:19;;;;:::i;:::-;8756:35;;;;:16;;;:35;;;;;;;-1:-1:-1;8699:19:50;-1:-1:-1;8835:1:50;;-1:-1:-1;8608:315:50;;-1:-1:-1;8608:315:50;;8883:21;;;;:::i;:::-;;;;8608:315;8940:19;8977:29;9024:33;9166:15;9184:10;9195:13;9184:25;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;;9250:19:50;;9231:16;9250:19;;;;;;;;;;;;9184:25;;-1:-1:-1;9324:26:50;;;;9291:178;;;;-1:-1:-1;;;9291:178:50;;8503:2:63;9291:178:50;;;8485:21:63;8542:2;8522:18;;;8515:30;8581:34;8561:18;;;8554:62;8652:25;8632:18;;;8625:53;8695:19;;9291:178:50;8301:419:63;9291:178:50;9626:4;9588:26;;;;:43;9555:172;;;;-1:-1:-1;;;9555:172:50;;8927:2:63;9555:172:50;;;8909:21:63;8966:2;8946:18;;;8939:30;9005:34;8985:18;;;8978:62;-1:-1:-1;;;9056:18:63;;;9049:44;9110:19;;9555:172:50;8725:410:63;9555:172:50;10026:1;10003:24;;;9985:43;;;;-1:-1:-1;;;;;;;10076:24:50;;;;;;;10072:294;;-1:-1:-1;;;;;;10319:23:50;;:9;:23;;;;;;;;;;;;-1:-1:-1;;;;;;10249:94:50;;10250:29;;10249:94;10195:148;;10072:294;-1:-1:-1;;;;;;10394:19:50;;;;:9;:19;;;;;;;;;;10387:26;10656:1;10636:21;;;;;;-1:-1:-1;10908:1:50;10882:27;;;;-1:-1:-1;10949:42:50;;;10945:1109;;11015:23;11041:85;;;:16;;;:85;;;;;;;-1:-1:-1;;;;;;11339:80:50;;;11337:83;11291:129;;;11449:21;;;:50;;11290:210;11583:57;;10945:1109;;;12009:25;11992:12;-1:-1:-1;;;;;11984:21:50;;:50;;11929:25;-1:-1:-1;;;;;;2078:35:50;;11874:80;;11872:83;11828:13;:127;11827:208;11787:248;;10945:1109;12075:19;12098:1;12075:24;12071:152;;12130:35;;;;:16;;;:35;;;;;12123:42;;;12130:35;-1:-1:-1;12071:152:50;8590:3647;;;8560:15;;;;;:::i;:::-;;;;8448:3789;;;-1:-1:-1;12291:19:50;12267:21;:17;12287:1;12267:21;:::i;:::-;:43;;;;:::i;:::-;12250:60;;7971:4350;;7921:4480;;;12341:49;;-1:-1:-1;;;12341:49:50;;9645:2:63;12341:49:50;;;9627:21:63;9684:2;9664:18;;;9657:30;9723:34;9703:18;;;9696:62;-1:-1:-1;;;9774:18:63;;;9767:37;9821:19;;12341:49:50;9443:403:63;7921:4480:50;-1:-1:-1;12418:14:50;;12434:13;;-1:-1:-1;;;;;4224:8231:50:o;12461:790::-;-1:-1:-1;;;;;12575:19:50;;12571:56;;12461:790;;:::o;12571:56::-;12636:107;12672:5;12636:107;;;;;;;;;;;;;;;;;:22;:107::i;:::-;12754:12;12768:18;12790:5;-1:-1:-1;;;;;12790:18:50;12809:9;12790:29;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12753:66;;;;12834:7;12829:416;;12861:12;;:16;12857:378;;13043:5;13037:12;13093:15;13085:5;13081:2;13077:14;13070:39;12857:378;13203:5;13210:9;13172:48;;-1:-1:-1;;;13172:48:50;;;;;;;;;:::i;12857:378::-;12561:690;;12461:790;;:::o;176:288:59:-;264:14;;129:42;373:2;360:16;;240:21;;264:14;360:16;129:42;400:5;389:68;380:77;;335:126;;176:288;:::o;13257:283:50:-;13452:22;;13519:13;13501:16;13493:40;;;;-1:-1:-1;;;13493:40:50;;;;;;;;:::i;763:127:63:-;824:10;819:3;815:20;812:1;805:31;855:4;852:1;845:15;879:4;876:1;869:15;895:127;956:10;951:3;947:20;944:1;937:31;987:4;984:1;977:15;1011:4;1008:1;1001:15;1027:135;1066:3;1087:17;;;1084:43;;1107:18;;:::i;:::-;-1:-1:-1;1154:1:63;1143:13;;1027:135::o;1167:127::-;1228:10;1223:3;1219:20;1216:1;1209:31;1259:4;1256:1;1249:15;1283:4;1280:1;1273:15;1299:250;1384:1;1394:113;1408:6;1405:1;1402:13;1394:113;;;1484:11;;;1478:18;1465:11;;;1458:39;1430:2;1423:10;1394:113;;;-1:-1:-1;;1541:1:63;1523:16;;1516:27;1299:250::o;1554:270::-;1595:3;1633:5;1627:12;1660:6;1655:3;1648:19;1676:76;1745:6;1738:4;1733:3;1729:14;1722:4;1715:5;1711:16;1676:76;:::i;:::-;1806:2;1785:15;-1:-1:-1;;1781:29:63;1772:39;;;;1813:4;1768:50;;1554:270;-1:-1:-1;;1554:270:63:o;1829:2090::-;2097:4;2126:2;2166;2155:9;2151:18;2196:2;2185:9;2178:21;2219:6;2254;2248:13;2285:6;2277;2270:22;2311:3;2301:13;;2345:2;2334:9;2330:18;2323:25;;2407:2;2397:6;2394:1;2390:14;2379:9;2375:30;2371:39;2429:4;2468:2;2460:6;2456:15;2489:1;2499:1249;2513:6;2510:1;2507:13;2499:1249;;;2578:22;;;-1:-1:-1;;2574:37:63;2562:50;;2635:13;;2722:9;;-1:-1:-1;;;;;2718:35:63;2703:51;;2793:11;;;2787:18;2675:15;;;;2845:1;2828:19;;2818:170;;2898:10;2893:3;2889:20;2886:1;2879:31;2937:4;2934:1;2927:15;2969:4;2966:1;2959:15;2818:170;3008:15;;;3001:37;3061:4;3106:11;;;3100:18;3138:15;;;3131:27;;;3219:21;;3253:24;;;;3343:23;;;;-1:-1:-1;;3299:15:63;;;;3404:236;3420:8;3415:3;3412:17;3404:236;;;3501:15;;-1:-1:-1;;;;;;3497:42:63;3483:57;;3609:17;;;;3448:1;3439:11;;;;;3566:14;;;;3404:236;;;-1:-1:-1;3726:12:63;;;;3663:5;-1:-1:-1;;;3691:15:63;;;;2535:1;2528:9;2499:1249;;;-1:-1:-1;;;;;;;80:31:63;;3784:18;;;68:44;3841:22;;;3834:4;3819:20;;3812:52;3881:32;3845:6;3898;3881:32;:::i;:::-;3873:40;1829:2090;-1:-1:-1;;;;;;;;;;1829:2090:63:o;3924:290::-;4101:2;4090:9;4083:21;4064:4;4121:44;4161:2;4150:9;4146:18;4138:6;4121:44;:::i;:::-;4113:52;;4201:6;4196:2;4185:9;4181:18;4174:34;3924:290;;;;;:::o;4219:316::-;4396:2;4385:9;4378:21;4359:4;4416:44;4456:2;4445:9;4441:18;4433:6;4416:44;:::i;:::-;4408:52;;4525:1;4521;4516:3;4512:11;4508:19;4500:6;4496:32;4491:2;4480:9;4476:18;4469:60;4219:316;;;;;:::o;4540:381::-;4737:2;4726:9;4719:21;4700:4;4763:44;4803:2;4792:9;4788:18;4780:6;4763:44;:::i;:::-;4855:9;4847:6;4843:22;4838:2;4827:9;4823:18;4816:50;4883:32;4908:6;4900;4883:32;:::i;:::-;4875:40;4540:381;-1:-1:-1;;;;;4540:381:63:o;4926:300::-;5097:2;5086:9;5079:21;5060:4;5117:44;5157:2;5146:9;5142:18;5134:6;5117:44;:::i;:::-;5109:52;;5211:6;5204:14;5197:22;5192:2;5181:9;5177:18;5170:50;4926:300;;;;;:::o;5231:219::-;5380:2;5369:9;5362:21;5343:4;5400:44;5440:2;5429:9;5425:18;5417:6;5400:44;:::i;:::-;5392:52;5231:219;-1:-1:-1;;;5231:219:63:o;8160:136::-;8199:3;8227:5;8217:39;;8236:18;;:::i;:::-;-1:-1:-1;;;8272:18:63;;8160:136::o;9140:168::-;9180:7;9246:1;9242;9238:6;9234:14;9231:1;9228:21;9223:1;9216:9;9209:17;9205:45;9202:71;;;9253:18;;:::i;:::-;-1:-1:-1;9293:9:63;;9140:168::o;9313:125::-;9378:9;;;9399:10;;;9396:36;;;9412:18;;:::i;:::-;9313:125;;;;:::o;9851:287::-;9980:3;10018:6;10012:13;10034:66;10093:6;10088:3;10081:4;10073:6;10069:17;10034:66;:::i;:::-;10116:16;;;;;9851:287;-1:-1:-1;;9851:287:63:o;10143:314::-;-1:-1:-1;;;;;10318:32:63;;10300:51;;10387:2;10382;10367:18;;10360:30;;;-1:-1:-1;;10407:44:63;;10432:18;;10424:6;10407:44;:::i;:::-;10399:52;10143:314;-1:-1:-1;;;;10143:314:63:o

ipfs://5b247b03ac6275f6eda198e5cc4ca1291b6d3cc8731b785e163e20bfcce945ef