Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

import './ERC1155Tradable.sol';
import './BlastManager.sol';

/**
 * @title Ticket
 * Ticket - a contract for Ticket semi-fungible tokens.
 */
contract Ticket is ERC1155Tradable, BlastManager {
  event TicketUsed(address indexed user, uint256 indexed ticketId);

  constructor(
    address _blastAddress,
    address _blastPointsAddress,
    address _blastPointsOperator
  )
    BlastManager(_blastAddress, _blastPointsAddress, _blastPointsOperator)
    ERC1155Tradable('FP Ticket', 'TICKET', 'https://game.fortunepike.xyz/api/nft/ticket/{id}')
  {}

  /**
   * Use a ticket to register for a tournament.
   * Burns a ticket and records the event.
   * @param ticketId The ID of the ticket to use.
   */
  function useTicket(uint256 ticketId) public {
    require(balanceOf(msg.sender, ticketId) > 0, 'You do not own this ticket');

    _burn(msg.sender, ticketId, 1);
    emit TicketUsed(msg.sender, ticketId);
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

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

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.20;

import {IERC1155} from "./IERC1155.sol";
import {IERC1155Receiver} from "./IERC1155Receiver.sol";
import {IERC1155MetadataURI} from "./extensions/IERC1155MetadataURI.sol";
import {Context} from "../../utils/Context.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {Arrays} from "../../utils/Arrays.sol";
import {IERC1155Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 */
abstract contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI, IERC1155Errors {
    using Arrays for uint256[];
    using Arrays for address[];

    mapping(uint256 id => mapping(address account => uint256)) private _balances;

    mapping(address account => mapping(address operator => bool)) private _operatorApprovals;

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

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

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

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

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

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

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

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

        return batchBalances;
    }

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) public virtual {
        address sender = _msgSender();
        if (from != sender && !isApprovedForAll(from, sender)) {
            revert ERC1155MissingApprovalForAll(sender, from);
        }
        _safeTransferFrom(from, to, id, value, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) public virtual {
        address sender = _msgSender();
        if (from != sender && !isApprovedForAll(from, sender)) {
            revert ERC1155MissingApprovalForAll(sender, from);
        }
        _safeBatchTransferFrom(from, to, ids, values, data);
    }

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. Will mint (or burn) if `from`
     * (or `to`) is the zero address.
     *
     * Emits a {TransferSingle} event if the arrays contain one element, and {TransferBatch} otherwise.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement either {IERC1155Receiver-onERC1155Received}
     *   or {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value.
     * - `ids` and `values` must have the same length.
     *
     * NOTE: The ERC-1155 acceptance check is not performed in this function. See {_updateWithAcceptanceCheck} instead.
     */
    function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal virtual {
        if (ids.length != values.length) {
            revert ERC1155InvalidArrayLength(ids.length, values.length);
        }

        address operator = _msgSender();

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids.unsafeMemoryAccess(i);
            uint256 value = values.unsafeMemoryAccess(i);

            if (from != address(0)) {
                uint256 fromBalance = _balances[id][from];
                if (fromBalance < value) {
                    revert ERC1155InsufficientBalance(from, fromBalance, value, id);
                }
                unchecked {
                    // Overflow not possible: value <= fromBalance
                    _balances[id][from] = fromBalance - value;
                }
            }

            if (to != address(0)) {
                _balances[id][to] += value;
            }
        }

        if (ids.length == 1) {
            uint256 id = ids.unsafeMemoryAccess(0);
            uint256 value = values.unsafeMemoryAccess(0);
            emit TransferSingle(operator, from, to, id, value);
        } else {
            emit TransferBatch(operator, from, to, ids, values);
        }
    }

    /**
     * @dev Version of {_update} that performs the token acceptance check by calling
     * {IERC1155Receiver-onERC1155Received} or {IERC1155Receiver-onERC1155BatchReceived} on the receiver address if it
     * contains code (eg. is a smart contract at the moment of execution).
     *
     * IMPORTANT: Overriding this function is discouraged because it poses a reentrancy risk from the receiver. So any
     * update to the contract state after this function would break the check-effect-interaction pattern. Consider
     * overriding {_update} instead.
     */
    function _updateWithAcceptanceCheck(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) internal virtual {
        _update(from, to, ids, values);
        if (to != address(0)) {
            address operator = _msgSender();
            if (ids.length == 1) {
                uint256 id = ids.unsafeMemoryAccess(0);
                uint256 value = values.unsafeMemoryAccess(0);
                _doSafeTransferAcceptanceCheck(operator, from, to, id, value, data);
            } else {
                _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, values, data);
            }
        }
    }

    /**
     * @dev Transfers a `value` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(from, to, ids, values, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     * - `ids` and `values` must have the same length.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        _updateWithAcceptanceCheck(from, to, ids, values, data);
    }

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

    /**
     * @dev Creates a `value` amount of tokens of type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(address to, uint256 id, uint256 value, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(address(0), to, ids, values, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `values` must have the same length.
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(address to, uint256[] memory ids, uint256[] memory values, bytes memory data) internal {
        if (to == address(0)) {
            revert ERC1155InvalidReceiver(address(0));
        }
        _updateWithAcceptanceCheck(address(0), to, ids, values, data);
    }

    /**
     * @dev Destroys a `value` amount of tokens of type `id` from `from`
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `value` amount of tokens of type `id`.
     */
    function _burn(address from, uint256 id, uint256 value) internal {
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value);
        _updateWithAcceptanceCheck(from, address(0), ids, values, "");
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `value` amount of tokens of type `id`.
     * - `ids` and `values` must have the same length.
     */
    function _burnBatch(address from, uint256[] memory ids, uint256[] memory values) internal {
        if (from == address(0)) {
            revert ERC1155InvalidSender(address(0));
        }
        _updateWithAcceptanceCheck(from, address(0), ids, values, "");
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the zero address.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC1155InvalidOperator(address(0));
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Performs an acceptance check by calling {IERC1155-onERC1155Received} on the `to` address
     * if it contains code at the moment of execution.
     */
    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 value,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, value, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    // Tokens rejected
                    revert ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-ERC1155Receiver implementer
                    revert ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    /**
     * @dev Performs a batch acceptance check by calling {IERC1155-onERC1155BatchReceived} on the `to` address
     * if it contains code at the moment of execution.
     */
    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values,
        bytes memory data
    ) private {
        if (to.code.length > 0) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, values, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    // Tokens rejected
                    revert ERC1155InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    // non-ERC1155Receiver implementer
                    revert ERC1155InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }

    /**
     * @dev Creates an array in memory with only one value for each of the elements provided.
     */
    function _asSingletonArrays(
        uint256 element1,
        uint256 element2
    ) private pure returns (uint256[] memory array1, uint256[] memory array2) {
        /// @solidity memory-safe-assembly
        assembly {
            // Load the free memory pointer
            array1 := mload(0x40)
            // Set array length to 1
            mstore(array1, 1)
            // Store the single element at the next word after the length (where content starts)
            mstore(add(array1, 0x20), element1)

            // Repeat for next array locating it right after the first array
            array2 := add(array1, 0x40)
            mstore(array2, 1)
            mstore(add(array2, 0x20), element2)

            // Update the free memory pointer by pointing after the second array
            mstore(0x40, add(array2, 0x40))
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.20;

import {IERC1155} from "../IERC1155.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

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

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

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

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

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

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

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

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

    /**
     * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155Received} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `value` amount.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * WARNING: This function can potentially allow a reentrancy attack when transferring tokens
     * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver.
     * Ensure to follow the checks-effects-interactions pattern and consider employing
     * reentrancy guards when interacting with untrusted contracts.
     *
     * Emits either a {TransferSingle} or a {TransferBatch} event, depending on the length of the array arguments.
     *
     * Requirements:
     *
     * - `ids` and `values` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.20;

import {IERC165} from "../../utils/introspection/IERC165.sol";

/**
 * @dev Interface that must be implemented by smart contracts in order to receive
 * ERC-1155 token transfers.
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

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

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

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Arrays.sol)

pragma solidity ^0.8.20;

import {StorageSlot} from "./StorageSlot.sol";
import {Math} from "./math/Math.sol";

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    using StorageSlot for bytes32;

    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        uint256 low = 0;
        uint256 high = array.length;

        if (high == 0) {
            return 0;
        }

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds towards zero (it does integer division with truncation).
            if (unsafeAccess(array, mid).value > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && unsafeAccess(array, low - 1).value == element) {
            return low - 1;
        } else {
            return low;
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getAddressSlot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getBytes32Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) {
        bytes32 slot;
        // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr`
        // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays.

        /// @solidity memory-safe-assembly
        assembly {
            mstore(0, arr.slot)
            slot := add(keccak256(0, 0x20), pos)
        }
        return slot.getUint256Slot();
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }

    /**
     * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check.
     *
     * WARNING: Only use if you are certain `pos` is lower than the array length.
     */
    function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) {
        assembly {
            res := mload(add(add(arr, 0x20), mul(pos, 0x20)))
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

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

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

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

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

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant HEX_DIGITS = "0123456789abcdef";
    uint8 private constant ADDRESS_LENGTH = 20;

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        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_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        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);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

import './interfaces/IBlast.sol';

contract BlastManager {
  IBlast public BLAST;
  IBlastPoints public BLAST_POINTS;

  constructor(address _blastAddress, address _blastPointsAddress, address _blastPointsOperator) {
    BLAST = IBlast(_blastAddress);
    BLAST.configureClaimableYield();
    BLAST.configureClaimableGas();
    BLAST_POINTS = IBlastPoints(_blastPointsAddress);
    BLAST_POINTS.configurePointsOperator(_blastPointsOperator);
  }

  function claimYield(address recipient, uint256 amount) public virtual {
    BLAST.claimYield(address(this), recipient, amount);
  }

  function claimAllYield(address recipient) public virtual {
    BLAST.claimAllYield(address(this), recipient);
  }

  function claimAllGas(address recipient) public virtual {
    BLAST.claimAllGas(address(this), recipient);
  }

  function readClaimableYield() public view virtual returns (uint256) {
    return BLAST.readClaimableYield(address(this));
  }

  function configurePointsOperatorOnBehalf(address contractAddress, address operator) public {
    BLAST_POINTS.configurePointsOperatorOnBehalf(contractAddress, operator);
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/token/ERC1155/ERC1155.sol';
import '@openzeppelin/contracts/utils/Strings.sol';

/**
 * @title ERC1155Tradable
 * ERC1155Tradable - ERC1155 contract that whitelists an operator address, has create and mint functionality,
 * and supports useful standards from OpenZeppelin, like _exists(), name(), symbol(), and totalSupply()
 */
contract ERC1155Tradable is ERC1155, Ownable {
  using Strings for string;

  string public name;
  string public symbol;

  mapping(uint256 => address) public creators;
  mapping(uint256 => uint256) public tokenSupply;
  mapping(uint256 => string) customUri;

  mapping(address => bool) public serviceAccounts;

  /**
   * @dev Require msg.sender to be the creator of the token id
   */
  modifier creatorOnly(uint256 _id) {
    require(creators[_id] == msg.sender, 'ERC1155Tradable#creatorOnly: ONLY_CREATOR_ALLOWED');
    _;
  }

  constructor(string memory _name, string memory _symbol, string memory _uri) ERC1155(_uri) Ownable(msg.sender) {
    name = _name;
    symbol = _symbol;
  }

  function uri(uint256 _id) public view override returns (string memory) {
    require(_exists(_id), 'ERC1155Tradable#uri: NONEXISTENT_TOKEN');
    // We have to convert string to bytes to check for existence
    bytes memory customUriBytes = bytes(customUri[_id]);
    if (customUriBytes.length > 0) {
      return customUri[_id];
    } else {
      return super.uri(_id);
    }
  }

  /**
   * @dev Returns the total quantity for a token ID
   * @param _id uint256 ID of the token to query
   * @return amount of token in existence
   */
  function totalSupply(uint256 _id) public view returns (uint256) {
    return tokenSupply[_id];
  }

  /**
   * @dev Sets a new URI for all token types, by relying on the token type ID
   * substitution mechanism
   * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
   * @param _newURI New URI for all tokens
   */
  function setURI(string memory _newURI) public onlyOwner {
    _setURI(_newURI);
  }

  /**
   * @dev Will update the base URI for the token
   * @param _tokenId The token to update. msg.sender must be its creator.
   * @param _newURI New URI for the token.
   */
  function setCustomURI(uint256 _tokenId, string memory _newURI) public creatorOnly(_tokenId) {
    customUri[_tokenId] = _newURI;
    emit URI(_newURI, _tokenId);
  }

  /**
   * @dev Creates a new token type and assigns _initialSupply to an address
   * NOTE: remove onlyOwner if you want third parties to create new tokens on
   *       your contract (which may change your IDs)
   * NOTE: The token id must be passed. This allows lazy creation of tokens or
   *       creating NFTs by setting the id's high bits with the method
   *       described in ERC1155 or to use ids representing values other than
   *       successive small integers. If you wish to create ids as successive
   *       small integers you can either subclass this class to count onchain
   *       or maintain the offchain cache of identifiers recommended in
   *       ERC1155 and calculate successive ids from that.
   * @param _initialOwner address of the first owner of the token
   * @param _id The id of the token to create (must not currenty exist).
   * @param _initialSupply amount to supply the first owner
   * @param _uri Optional URI for this token type
   * @param _data Data to pass if receiver is contract
   * @return The newly created token ID
   */
  function create(
    address _initialOwner,
    uint256 _id,
    uint256 _initialSupply,
    string memory _uri,
    bytes memory _data
  ) public returns (uint256) {
    require(
      owner() == msg.sender || serviceAccounts[msg.sender],
      'ERC1155Tradable#create: CALLER_NOT_OWNER_NOR_SERVICE_ACCOUNT'
    );
    require(!_exists(_id), 'token _id already exists');
    creators[_id] = msg.sender;

    if (bytes(_uri).length > 0) {
      customUri[_id] = _uri;
      emit URI(_uri, _id);
    }

    _mint(_initialOwner, _id, _initialSupply, _data);

    tokenSupply[_id] = _initialSupply;
    return _id;
  }

  /**
   * @dev Mints some amount of tokens to an address
   * @param _to          Address of the future owner of the token
   * @param _id          Token ID to mint
   * @param _quantity    Amount of tokens to mint
   * @param _data        Data to pass if receiver is contract
   */
  function mint(address _to, uint256 _id, uint256 _quantity, bytes memory _data) public {
    require(
      creators[_id] == msg.sender || serviceAccounts[msg.sender],
      'ERC1155Tradable#mint: CALLER_IS_NOT_CREATOR_NOR_SERVICE_ACCOUNT'
    );
    _mint(_to, _id, _quantity, _data);
    tokenSupply[_id] = tokenSupply[_id] + _quantity;
  }

  /**
   * @dev Mint tokens for each id in _ids
   * @param _to          The address to mint tokens to
   * @param _ids         Array of ids to mint
   * @param _quantities  Array of amounts of tokens to mint per id
   * @param _data        Data to pass if receiver is contract
   */
  function batchMint(address _to, uint256[] memory _ids, uint256[] memory _quantities, bytes memory _data) public {
    for (uint256 i = 0; i < _ids.length; i++) {
      uint256 _id = _ids[i];
      require(
        creators[_id] == msg.sender || serviceAccounts[msg.sender],
        'ERC1155Tradable#batchMint: ONLY_CREATOR_ALLOWED'
      );
      uint256 quantity = _quantities[i];
      tokenSupply[_id] = tokenSupply[_id] + quantity;
    }
    _mintBatch(_to, _ids, _quantities, _data);
  }

  /**
   * @dev Change the creator address for given tokens
   * @param _to   Address of the new creator
   * @param _ids  Array of Token IDs to change creator
   */
  function setCreator(address _to, uint256[] memory _ids) public {
    require(_to != address(0), 'ERC1155Tradable#setCreator: INVALID_ADDRESS.');
    for (uint256 i = 0; i < _ids.length; i++) {
      uint256 id = _ids[i];
      _setCreator(_to, id);
    }
  }

  /**
   * @dev Change the creator address for given token
   * @param _to   Address of the new creator
   * @param _id  Token IDs to change creator of
   */
  function _setCreator(address _to, uint256 _id) internal creatorOnly(_id) {
    creators[_id] = _to;
  }

  /**
   * @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 creators[_id] != address(0);
  }

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

  /**
   * @dev Adds a single address to the serviceAccounts.
   * @param _address Address to be added to the serviceAccounts
   */
  function addServiceAccount(address _address) public onlyOwner {
    serviceAccounts[_address] = true;
  }

  /**
   * @dev Removes a single address from the serviceAccounts.
   * @param _address Address to be removed from the serviceAccounts
   */
  function removeServiceAccount(address _address) public onlyOwner {
    serviceAccounts[_address] = false;
  }

  /**
   * @dev Returns true if the address is on the serviceAccounts.
   * @param _address Address to be checked
   */
  function isServiceAccount(address _address) public view returns (bool) {
    return serviceAccounts[_address];
  }

  function updateOwner(address _newOwner) public onlyOwner {
    transferOwnership(_newOwner);
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

import './interfaces/IGrade.sol';

import './ERC1155Tradable.sol';
import './BlastManager.sol';

/**
 * @title Fish
 * Fish - a contract for Fish semi-fungible tokens.
 */
contract Fish is ERC1155Tradable, BlastManager {
  constructor(
    address _blastAddress,
    address _blastPointsAddress,
    address _blastPointsOperator
  )
    ERC1155Tradable('FP Fish', 'FISH', 'https://game.fortunepike.xyz/api/nft/fish/{id}')
    BlastManager(_blastAddress, _blastPointsAddress, _blastPointsOperator)
  {}

  function generateTokenId(string memory name, Grade grade) public pure returns (uint256) {
    return uint256(keccak256(abi.encodePacked(name, grade)));
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/ReentrancyGuard.sol';

import './interfaces/IFactoryERC1155.sol';
import './interfaces/IGrade.sol';

import './Fish.sol';
import './BlastManager.sol';

/**
 * @title FishFactory
 * Fish - a factory contract for Fish semi-fungible tokens.
 */
contract FishFactory is FactoryERC1155, Ownable, ReentrancyGuard, BlastManager {
  using Strings for string;

  string internal constant baseMetadataURI = 'https://game.fortunepike.xyz/api/nft/fish/';
  address public fishAddress;
  uint256 constant UINT256_MAX = ~uint256(0);

  /*
   * Optionally set this to a small integer to enforce limited existence per option/token ID
   * (Otherwise rely on sell orders on OpenSea, which can only be made by the factory owner.)
   */
  uint256 constant SUPPLY_PER_TOKEN_ID = UINT256_MAX;

  // The number of fish grades (basic, bronze, silver, gold)
  uint256 constant NUM_FISH_TYPES = 4;

  constructor(
    address _fishAddress,
    address _blastAddress,
    address _blastPointsAddress,
    address _blastPointsOperator
  ) Ownable(msg.sender) BlastManager(_blastAddress, _blastPointsAddress, _blastPointsOperator) {
    fishAddress = _fishAddress;
  }

  /////
  // FACTORY INTERFACE METHODS
  /////

  function name() external pure override returns (string memory) {
    return 'FP Fish Factory';
  }

  function symbol() external pure override returns (string memory) {
    return 'FPFF';
  }

  function supportsFactoryInterface() external pure override returns (bool) {
    return true;
  }

  function factorySchemaName() external pure override returns (string memory) {
    return 'ERC1155';
  }

  function numOptions() external pure override returns (uint256) {
    return NUM_FISH_TYPES;
  }

  function uri(uint256 _fishId) external pure override returns (string memory) {
    return string(abi.encodePacked(baseMetadataURI, Strings.toString(_fishId)));
  }

  function canMint(uint256 _fishId, uint256 _amount) external view returns (bool) {
    return _canMint(msg.sender, _fishId, _amount);
  }

  function mint(
    uint256 _fishId,
    address _toAddress,
    uint256 _amount,
    bytes calldata _data
  ) external override nonReentrant {
    _mint(_fishId, _toAddress, _amount, _data);
  }

  /**
   * @dev Main minting logic implemented here!
   */
  function _mint(uint256 _fishId, address _toAddress, uint256 _amount, bytes memory _data) internal {
    require(owner() == msg.sender, 'Caller cannot mint fish');
    require(_canMint(msg.sender, _fishId, _amount), 'FishFactory#_mint: CANNOT_MINT_MORE');

    Fish fish = Fish(fishAddress);
    if (!fish.exists(_fishId)) {
      fish.create(_toAddress, _fishId, _amount, '', _data);
    } else {
      fish.mint(_toAddress, _fishId, _amount, _data);
    }
  }

  /*
   * Note: make sure code that calls this is non-reentrant.
   * Note: this is the token _id *within* the ERC1155 contract, not the fish id from this contract.
   */
  function _createOrMint(
    address _erc1155Address,
    address _to,
    uint256 _id,
    uint256 _amount,
    bytes memory _data
  ) internal {
    Fish fish = Fish(_erc1155Address);
    // Lazily create the token
    if (!fish.exists(_id)) {
      fish.create(_to, _id, _amount, '', _data);
    } else {
      fish.mint(_to, _id, _amount, _data);
    }
  }

  /**
   * Get the factory's ownership of Fish.
   * Should be the amount it can still mint.
   * NOTE: Called by `canMint`
   */
  function balanceOf(address _owner, uint256 _fishId) public view override returns (uint256) {
    if (owner() != _owner) {
      // Only the factory owner or owner's proxy can have supply
      return 0;
    }
    if (_fishId < NUM_FISH_TYPES) {
      // The pre-minted balance belongs to the address that minted this contract
      // fishId is used as a token ID here
      uint256 currentSupply = Fish(fishAddress).balanceOf(owner(), _fishId);
      return currentSupply;
    } else {
      // We explicitly calculate the token ID here
      uint256 tokenId = (_fishId - NUM_FISH_TYPES);
      uint256 currentSupply = Fish(fishAddress).totalSupply(tokenId);
      // We can mint up to a balance of SUPPLY_PER_TOKEN_ID
      return SUPPLY_PER_TOKEN_ID - currentSupply;
    }
  }

  function _canMint(address _fromAddress, uint256 _fishId, uint256 _amount) internal view returns (bool) {
    return _amount > 0 && balanceOf(_fromAddress, _fishId) >= _amount;
  }

  function claimYield(uint256 amount) public onlyOwner {
    super.claimYield(msg.sender, amount);
    Fish(fishAddress).claimYield(msg.sender, amount);
  }

  function claimAllYield() public onlyOwner {
    super.claimAllYield(msg.sender);
    Fish(fishAddress).claimAllYield(msg.sender);
  }

  function claimAllGas() public onlyOwner {
    super.claimAllGas(msg.sender);
    Fish(fishAddress).claimAllGas(msg.sender);
  }

  function readClaimableYield() public view override returns (uint256) {
    return Fish(fishAddress).readClaimableYield() + super.readClaimableYield(); // Combine results
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

enum YieldMode {
  AUTOMATIC,
  VOID,
  CLAIMABLE
}

enum GasMode {
  VOID,
  CLAIMABLE
}

interface IBlast {
  // configure
  function configureContract(address contractAddress, YieldMode _yield, GasMode gasMode, address governor) external;

  function configure(YieldMode _yield, GasMode gasMode, address governor) external;

  // base configuration options
  function configureClaimableYield() external;

  function configureClaimableYieldOnBehalf(address contractAddress) external;

  function configureAutomaticYield() external;

  function configureAutomaticYieldOnBehalf(address contractAddress) external;

  function configureVoidYield() external;

  function configureVoidYieldOnBehalf(address contractAddress) external;

  function configureClaimableGas() external;

  function configureClaimableGasOnBehalf(address contractAddress) external;

  function configureVoidGas() external;

  function configureVoidGasOnBehalf(address contractAddress) external;

  function configureGovernor(address _governor) external;

  function configureGovernorOnBehalf(address _newGovernor, address contractAddress) external;

  // claim yield
  function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256);

  function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256);

  // claim gas
  function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256);

  function claimGasAtMinClaimRate(
    address contractAddress,
    address recipientOfGas,
    uint256 minClaimRateBips
  ) external returns (uint256);

  function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256);

  function claimGas(
    address contractAddress,
    address recipientOfGas,
    uint256 gasToClaim,
    uint256 gasSecondsToConsume
  ) external returns (uint256);

  // read functions
  function readClaimableYield(address contractAddress) external view returns (uint256);

  function readYieldConfiguration(address contractAddress) external view returns (uint8);

  function readGasParams(
    address contractAddress
  ) external view returns (uint256 etherSeconds, uint256 etherBalance, uint256 lastUpdated, GasMode);
}

interface IBlastPoints {
  function configurePointsOperator(address operator) external;

  function configurePointsOperatorOnBehalf(address contractAddress, address operator) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

/**
 * This is a generic factory contract that can be used to mint tokens. The configuration
 * for minting is specified by an _optionId, which can be used to delineate various
 * ways of minting.
 */
interface FactoryERC1155 {
  /**
   * Returns the name of this factory.
   */
  function name() external view returns (string memory);

  /**
   * Returns the symbol for this factory.
   */
  function symbol() external view returns (string memory);

  /**
   * Number of options the factory supports.
   */
  function numOptions() external view returns (uint256);

  /**
   * @dev Returns a URL specifying some metadata about the option. This metadata can be of the
   * same structure as the ERC1155 metadata.
   */
  function uri(uint256 _optionId) external view returns (string memory);

  /**
   * Indicates that this is a factory contract. Ideally would use EIP 165 supportsInterface()
   */
  function supportsFactoryInterface() external view returns (bool);

  /**
   * Indicates the Wyvern schema name for assets in this lootbox, e.g. "ERC1155"
   */
  function factorySchemaName() external view returns (string memory);

  /**
   * @dev Mints asset(s) in accordance to a specific address with a particular "option". This should be
   * callable only by the contract owner or the owner's Wyvern Proxy (later universal login will solve this).
   * Options should also be delineated 0 - (numOptions() - 1) for convenient indexing.
   * @param _optionId the option id
   * @param _toAddress address of the future owner of the asset(s)
   * @param _amount amount of the option to mint
   * @param _data Extra data to pass during safeTransferFrom
   */
  function mint(uint256 _optionId, address _toAddress, uint256 _amount, bytes calldata _data) external;

  ///////
  // Get things to work on OpenSea with mock methods below
  ///////

  //function safeTransferFrom(address _from, address _to, uint256 _optionId, uint256 _amount, bytes calldata _data) external;

  function balanceOf(address _owner, uint256 _optionId) external view returns (uint256);

  //function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

enum Grade {
  BASIC,
  BRONZE,
  SILVER,
  GOLD
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

enum TicketType {
  BRONZE,
  SILVER,
  GOLD,
  EVENT
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.24;

import '@openzeppelin/contracts/access/Ownable.sol';
import '@openzeppelin/contracts/utils/Strings.sol';
import '@openzeppelin/contracts/utils/ReentrancyGuard.sol';
import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

import './interfaces/IFactoryERC1155.sol';
import './interfaces/ITicketType.sol';

import './Ticket.sol';
import './BlastManager.sol';

/**
 * @title TicketFactory
 * Ticket - a factory contract for Ticket semi-fungible tokens.
 */
contract TicketFactory is FactoryERC1155, Ownable, ReentrancyGuard, BlastManager {
  IERC20 public USDB;

  using Strings for string;

  string internal constant baseMetadataURI = 'https://game.fortunepike.xyz/api/nft/ticket/';
  address payable public treasuryAddress;
  address public ticketAddress;
  uint256 public eventTicketPrice = 1e18;

  // The number of ticket types (bronze, silver, gold, event)
  uint256 constant NUM_TICKET_TYPES = 4;

  event EventTicketPurchased(address indexed buyer, uint256 amount);
  event EventTicketPriceChanged(uint256 newPrice);
  event USDBWithdrawal(address target, uint amount);

  constructor(
    address _ticketAddress,
    address _usdbAddress,
    address _blastAddress,
    address _blastPointsAddress,
    address _blastPointsOperator,
    address payable _treasuryAddress
  ) Ownable(msg.sender) BlastManager(_blastAddress, _blastPointsAddress, _blastPointsOperator) {
    ticketAddress = _ticketAddress;
    treasuryAddress = _treasuryAddress;
    USDB = IERC20(_usdbAddress);
  }

  /////
  // FACTORY INTERFACE METHODS
  /////

  function name() external pure override returns (string memory) {
    return 'FP Ticket Factory';
  }

  function symbol() external pure override returns (string memory) {
    return 'FPTF';
  }

  function supportsFactoryInterface() external pure override returns (bool) {
    return true;
  }

  function factorySchemaName() external pure override returns (string memory) {
    return 'ERC1155';
  }

  function numOptions() external pure override returns (uint256) {
    return NUM_TICKET_TYPES;
  }

  function uri(uint256 _tokenId) external pure override returns (string memory) {
    return string(abi.encodePacked(baseMetadataURI, Strings.toString(_tokenId)));
  }

  function mint(
    uint256 _ticketType,
    address _toAddress,
    uint256 _amount,
    bytes calldata _data
  ) external override nonReentrant {
    _mint(_ticketType, _toAddress, _amount, _data);
  }

  /**
   * @dev Main minting logic implemented here!
   */
  function _mint(uint256 _ticketType, address _toAddress, uint256 _amount, bytes memory _data) internal {
    require(_amount > 0, 'TicketFactory#_mint: AMOUNT_LESS_THAN_ONE');
    require(owner() == msg.sender || Ticket(ticketAddress).isServiceAccount(msg.sender), 'Caller cannot mint ticket');

    _createOrMint(_ticketType, _toAddress, _amount, _data);
  }

  function balanceOf(address _address, uint256 _tokenId) public view override returns (uint256) {
    uint256 currentSupply = Ticket(ticketAddress).balanceOf(_address, _tokenId);
    return currentSupply;
  }

  /*
   * Note: make sure code that calls this is non-reentrant.
   * Note: this is the token _id *within* the ERC1155 contract, not the ticket id from this contract.
   */
  function _createOrMint(uint256 _ticketType, address _toAddress, uint256 _amount, bytes memory _data) internal {
    uint256 tokenId = generateTokenId(_ticketType);
    Ticket ticket = Ticket(ticketAddress);

    if (!ticket.exists(tokenId)) ticket.create(_toAddress, tokenId, _amount, '', _data);
    else ticket.mint(_toAddress, tokenId, _amount, _data);
  }

  function generateTokenId(uint256 ticketType) public pure returns (uint256) {
    require(ticketType < NUM_TICKET_TYPES, 'TicketFactory: Invalid ticket type');

    return uint256(keccak256(abi.encodePacked(ticketType)));
  }

  function buyEventTicket(uint256 numOfTickets) external payable nonReentrant {
    require(numOfTickets > 0, 'Invalid number of tickets');
    require(
      USDB.transferFrom(msg.sender, address(this), numOfTickets * eventTicketPrice),
      'Failed to transfer USDB for ticket purchase'
    );

    uint256 eventTicketType = uint256(TicketType.EVENT);
    _createOrMint(eventTicketType, msg.sender, numOfTickets, '');

    emit EventTicketPurchased(msg.sender, numOfTickets);
  }

  function setEventTicketPrice(uint256 price) external onlyOwner {
    require(price > 0, 'TicketFactory: Price must be greater than zero');

    eventTicketPrice = price * 1e18;
    emit EventTicketPriceChanged(eventTicketPrice);
  }

  function withdrawUSDB() external onlyOwner {
    uint256 value = USDB.balanceOf(address(this));
    require(value > 0, 'TicketFactory: No USDB to withdraw');

    bool success = USDB.transfer(treasuryAddress, value);
    require(success, 'TicketFactory: USDB Transfer failed');

    emit USDBWithdrawal(treasuryAddress, value);
  }

  function addServiceAccount(address _address) external onlyOwner {
    Ticket(ticketAddress).addServiceAccount(_address);
  }

  function removeServiceAccount(address _address) external onlyOwner {
    Ticket(ticketAddress).removeServiceAccount(_address);
  }

  function claimYield(uint256 amount) public onlyOwner {
    super.claimYield(msg.sender, amount);
    Ticket(ticketAddress).claimYield(msg.sender, amount);
  }

  function updateTicketAddress(address _newTicketAddress) external onlyOwner {
    ticketAddress = _newTicketAddress;
  }

  function updateTicketOwner(address _newOwner) external onlyOwner {
    require(ticketAddress != address(0), 'TicketFactory: Ticket address is not set');
    Ticket(ticketAddress).updateOwner(_newOwner);
  }

  function claimAllYield() public onlyOwner {
    super.claimAllYield(msg.sender);
    Ticket(ticketAddress).claimAllYield(msg.sender);
  }

  function claimAllGas() public onlyOwner {
    super.claimAllGas(msg.sender);
    Ticket(ticketAddress).claimAllGas(msg.sender);
  }

  function readClaimableYield() public view override returns (uint256) {
    return Ticket(ticketAddress).readClaimableYield() + super.readClaimableYield(); // Combine results
  }
}

{
  "metadata": {
    "bytecodeHash": "none"
  },
  "optimizer": {
    "enabled": true,
    "runs": 800
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_blastAddress","type":"address"},{"internalType":"address","name":"_blastPointsAddress","type":"address"},{"internalType":"address","name":"_blastPointsOperator","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC1155InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC1155InvalidApprover","type":"error"},{"inputs":[{"internalType":"uint256","name":"idsLength","type":"uint256"},{"internalType":"uint256","name":"valuesLength","type":"uint256"}],"name":"ERC1155InvalidArrayLength","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC1155InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC1155InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC1155InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC1155MissingApprovalForAll","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"ticketId","type":"uint256"}],"name":"TicketUsed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"BLAST","outputs":[{"internalType":"contract IBlast","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BLAST_POINTS","outputs":[{"internalType":"contract IBlastPoints","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"addServiceAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"},{"internalType":"uint256[]","name":"_quantities","type":"uint256[]"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"batchMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"claimAllGas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"claimAllYield","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claimYield","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"configurePointsOperatorOnBehalf","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_initialOwner","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_initialSupply","type":"uint256"},{"internalType":"string","name":"_uri","type":"string"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"create","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"creators","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"isServiceAccount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_quantity","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"readClaimableYield","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeServiceAccount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"serviceAccounts","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"}],"name":"setCreator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"string","name":"_newURI","type":"string"}],"name":"setCustomURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newURI","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newOwner","type":"address"}],"name":"updateOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"ticketId","type":"uint256"}],"name":"useTicket","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040523480156200001157600080fd5b5060405162002abc38038062002abc8339810160408190526200003491620002d6565b82828260405180604001604052806009815260200168119408151a58dad95d60ba1b81525060405180604001604052806006815260200165151250d2d15560d21b81525060405180606001604052806030815260200162002a8c6030913933816200009f8162000255565b506001600160a01b038116620000cf57604051631e4fbdf760e01b81526000600482015260240160405180910390fd5b620000da8162000267565b506004620000e98482620003c7565b506005620000f88382620003c7565b5050600a80546001600160a01b0319166001600160a01b0387169081179091556040805163784c3b3d60e11b8152905191935063f098767a925060048082019260009290919082900301818387803b1580156200015457600080fd5b505af115801562000169573d6000803e3d6000fd5b50505050600a60009054906101000a90046001600160a01b03166001600160a01b0316634e606c476040518163ffffffff1660e01b8152600401600060405180830381600087803b158015620001be57600080fd5b505af1158015620001d3573d6000803e3d6000fd5b5050600b80546001600160a01b0319166001600160a01b038681169182179092556040516336b91f2b60e01b8152918516600483015292506336b91f2b9150602401600060405180830381600087803b1580156200023057600080fd5b505af115801562000245573d6000803e3d6000fd5b5050505050505050505062000493565b6002620002638282620003c7565b5050565b600380546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b80516001600160a01b0381168114620002d157600080fd5b919050565b600080600060608486031215620002ec57600080fd5b620002f784620002b9565b92506200030760208501620002b9565b91506200031760408501620002b9565b90509250925092565b634e487b7160e01b600052604160045260246000fd5b600181811c908216806200034b57607f821691505b6020821081036200036c57634e487b7160e01b600052602260045260246000fd5b50919050565b601f821115620003c2576000816000526020600020601f850160051c810160208610156200039d5750805b601f850160051c820191505b81811015620003be57828155600101620003a9565b5050505b505050565b81516001600160401b03811115620003e357620003e362000320565b620003fb81620003f4845462000336565b8462000372565b602080601f8311600181146200043357600084156200041a5750858301515b600019600386901b1c1916600185901b178555620003be565b600085815260208120601f198616915b82811015620004645788860151825594840194600190910190840162000443565b5085821015620004835787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b6125e980620004a36000396000f3fe608060405234801561001057600080fd5b506004361061025b5760003560e01c8063880cdc3111610145578063c2d94aec116100bd578063e22dc81d1161008c578063f242432a11610071578063f242432a1461057e578063f2fde38b14610591578063ff1fd8ba146105a457600080fd5b8063e22dc81d1461052f578063e985e9c51461054257600080fd5b8063c2d94aec146104d8578063cd53d08e146104eb578063d2a6b51a14610514578063d39dd6841461052757600080fd5b8063a22cb46511610114578063b30080ac116100f9578063b30080ac14610492578063b48ab8b6146104a5578063bd85b039146104b857600080fd5b8063a22cb46514610453578063aaad98ab1461046657600080fd5b8063880cdc31146104145780638da5cb5b1461042757806395d89b411461043857806397d757761461044057600080fd5b80632eb2c2d6116101d85780634e1273f4116101a7578063715018a61161018c578063715018a6146103d6578063731133e9146103de5780637cb662bc146103f157600080fd5b80634e1273f4146103a35780634f558e79146103c357600080fd5b80632eb2c2d61461033f57806336a100d5146103525780633adf80b4146103655780634b8f90251461037857600080fd5b80630e89341c1161022f578063266064481161021457806326606448146102f95780632693ebf21461030c578063272b13231461032c57600080fd5b80630e89341c146102d35780631869ebda146102e657600080fd5b8062fdd58e1461026057806301ffc9a71461028657806302fe5305146102a957806306fdde03146102be575b600080fd5b61027361026e366004611c9f565b6105b7565b6040519081526020015b60405180910390f35b610299610294366004611cdf565b6105df565b604051901515815260200161027d565b6102bc6102b7366004611db3565b61062f565b005b6102c6610643565b60405161027d9190611e36565b6102c66102e1366004611e49565b6106d1565b6102bc6102f4366004611c9f565b6108bb565b6102bc610307366004611e49565b61093d565b61027361031a366004611e49565b60076020526000908152604090205481565b6102bc61033a366004611e62565b6109d2565b6102bc61034d366004611f10565b610a4d565b610273610360366004611fba565b610ad3565b6102bc610373366004612012565b610c8a565b600b5461038b906001600160a01b031681565b6040516001600160a01b03909116815260200161027d565b6103b66103b1366004612059565b610d6e565b60405161027d919061214b565b6102996103d1366004611e49565b610e3b565b6102bc610e5a565b6102bc6103ec36600461215e565b610e6e565b6102996103ff366004611e62565b60096020526000908152604090205460ff1681565b6102bc610422366004611e62565b610f52565b6003546001600160a01b031661038b565b6102c6610f63565b600a5461038b906001600160a01b031681565b6102bc6104613660046121bf565b610f70565b610299610474366004611e62565b6001600160a01b031660009081526009602052604090205460ff1690565b6102bc6104a03660046121fb565b610f7b565b6102bc6104b336600461222e565b610fde565b6102736104c6366004611e49565b60009081526007602052604090205490565b6102bc6104e6366004611e62565b611120565b61038b6104f9366004611e49565b6006602052600090815260409020546001600160a01b031681565b6102bc6105223660046122bb565b611158565b610273611211565b6102bc61053d366004611e62565b611283565b6102996105503660046121fb565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205460ff1690565b6102bc61058c3660046122ff565b6112ac565b6102bc61059f366004611e62565b61132a565b6102bc6105b2366004611e62565b611365565b6000818152602081815260408083206001600160a01b03861684529091529020545b92915050565b60006001600160e01b03198216636cdb3d1360e11b148061061057506001600160e01b031982166303a24d0760e21b145b806105d957506301ffc9a760e01b6001600160e01b03198316146105d9565b610637611391565b610640816113be565b50565b6004805461065090612364565b80601f016020809104026020016040519081016040528092919081815260200182805461067c90612364565b80156106c95780601f1061069e576101008083540402835291602001916106c9565b820191906000526020600020905b8154815290600101906020018083116106ac57829003601f168201915b505050505081565b6000818152600660205260409020546060906001600160a01b03166107635760405162461bcd60e51b815260206004820152602660248201527f455243313135355472616461626c65237572693a204e4f4e4558495354454e5460448201527f5f544f4b454e000000000000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b6000828152600860205260408120805461077c90612364565b80601f01602080910402602001604051908101604052809291908181526020018280546107a890612364565b80156107f55780601f106107ca576101008083540402835291602001916107f5565b820191906000526020600020905b8154815290600101906020018083116107d857829003601f168201915b505050505090506000815111156108a5576000838152600860205260409020805461081f90612364565b80601f016020809104026020016040519081016040528092919081815260200182805461084b90612364565b80156108985780601f1061086d57610100808354040283529160200191610898565b820191906000526020600020905b81548152906001019060200180831161087b57829003601f168201915b5050505050915050919050565b6108ae836113ca565b9392505050565b50919050565b600a54604051637cb8cb3160e11b81523060048201526001600160a01b038481166024830152604482018490529091169063f9719662906064016020604051808303816000875af1158015610914573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109389190612398565b505050565b600061094933836105b7565b116109965760405162461bcd60e51b815260206004820152601a60248201527f596f7520646f206e6f74206f776e2074686973207469636b6574000000000000604482015260640161075a565b6109a23382600161145e565b604051819033907f108a46e5e0e67b88292a0674cb6edf9da3b41ad04c8cd52a738ff591ce32443a90600090a350565b600a54604051634aa7d2f760e11b81523060048201526001600160a01b0383811660248301529091169063954fa5ee906044015b6020604051808303816000875af1158015610a25573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a499190612398565b5050565b336001600160a01b0386168114801590610a8d57506001600160a01b0380871660009081526001602090815260408083209385168352929052205460ff16155b15610abe5760405163711bec9160e11b81526001600160a01b0380831660048301528716602482015260440161075a565b610acb86868686866114cd565b505050505050565b600033610ae86003546001600160a01b031690565b6001600160a01b03161480610b0c57503360009081526009602052604090205460ff165b610b7e5760405162461bcd60e51b815260206004820152603c60248201527f455243313135355472616461626c65236372656174653a2043414c4c45525f4e60448201527f4f545f4f574e45525f4e4f525f534552564943455f4143434f554e5400000000606482015260840161075a565b6000858152600660205260409020546001600160a01b031615610be35760405162461bcd60e51b815260206004820152601860248201527f746f6b656e205f696420616c7265616479206578697374730000000000000000604482015260640161075a565b6000858152600660205260409020805473ffffffffffffffffffffffffffffffffffffffff191633179055825115610c67576000858152600860205260409020610c2d84826123f9565b50847f6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b84604051610c5e9190611e36565b60405180910390a25b610c738686868561152d565b505050600082815260076020526040902055919050565b60008281526006602052604090205482906001600160a01b03163314610d185760405162461bcd60e51b815260206004820152603160248201527f455243313135355472616461626c652363726561746f724f6e6c793a204f4e4c60448201527f595f43524541544f525f414c4c4f574544000000000000000000000000000000606482015260840161075a565b6000838152600860205260409020610d3083826123f9565b50827f6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b83604051610d619190611e36565b60405180910390a2505050565b60608151835114610d9f5781518351604051635b05999160e01b81526004810192909252602482015260440161075a565b6000835167ffffffffffffffff811115610dbb57610dbb611cfc565b604051908082528060200260200182016040528015610de4578160200160208202803683370190505b50905060005b8451811015610e3357602080820286010151610e0e906020808402870101516105b7565b828281518110610e2057610e206124b9565b6020908102919091010152600101610dea565b509392505050565b6000818152600660205260408120546001600160a01b031615156105d9565b610e62611391565b610e6c600061158a565b565b6000838152600660205260409020546001600160a01b0316331480610ea257503360009081526009602052604090205460ff165b610f145760405162461bcd60e51b815260206004820152603f60248201527f455243313135355472616461626c65236d696e743a2043414c4c45525f49535f60448201527f4e4f545f43524541544f525f4e4f525f534552564943455f4143434f554e5400606482015260840161075a565b610f208484848461152d565b600083815260076020526040902054610f3a9083906124cf565b60009384526007602052604090932092909255505050565b610f5a611391565b6106408161132a565b6005805461065090612364565b610a493383836115e9565b600b54604051632cc0202b60e21b81526001600160a01b03848116600483015283811660248301529091169063b30080ac90604401600060405180830381600087803b158015610fca57600080fd5b505af1158015610acb573d6000803e3d6000fd5b60005b835181101561110d576000848281518110610ffe57610ffe6124b9565b602090810291909101810151600081815260069092526040909120549091506001600160a01b031633148061104257503360009081526009602052604090205460ff165b6110b45760405162461bcd60e51b815260206004820152602f60248201527f455243313135355472616461626c652362617463684d696e743a204f4e4c595f60448201527f43524541544f525f414c4c4f5745440000000000000000000000000000000000606482015260840161075a565b60008483815181106110c8576110c86124b9565b602002602001015190508060076000848152602001908152602001600020546110f191906124cf565b6000928352600760205260409092209190915550600101610fe1565b5061111a8484848461167f565b50505050565b600a5460405163430021db60e11b81523060048201526001600160a01b0383811660248301529091169063860043b690604401610a06565b6001600160a01b0382166111d45760405162461bcd60e51b815260206004820152602c60248201527f455243313135355472616461626c652373657443726561746f723a20494e564160448201527f4c49445f414444524553532e0000000000000000000000000000000000000000606482015260840161075a565b60005b81518110156109385760008282815181106111f4576111f46124b9565b6020026020010151905061120884826116b7565b506001016111d7565b600a54604051631d864f1d60e31b81523060048201526000916001600160a01b03169063ec3278e890602401602060405180830381865afa15801561125a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061127e9190612398565b905090565b61128b611391565b6001600160a01b03166000908152600960205260409020805460ff19169055565b336001600160a01b03861681148015906112ec57506001600160a01b0380871660009081526001602090815260408083209385168352929052205460ff16155b1561131d5760405163711bec9160e11b81526001600160a01b0380831660048301528716602482015260440161075a565b610acb8686868686611781565b611332611391565b6001600160a01b03811661135c57604051631e4fbdf760e01b81526000600482015260240161075a565b6106408161158a565b61136d611391565b6001600160a01b03166000908152600960205260409020805460ff19166001179055565b6003546001600160a01b03163314610e6c5760405163118cdaa760e01b815233600482015260240161075a565b6002610a4982826123f9565b6060600280546113d990612364565b80601f016020809104026020016040519081016040528092919081815260200182805461140590612364565b80156114525780601f1061142757610100808354040283529160200191611452565b820191906000526020600020905b81548152906001019060200180831161143557829003601f168201915b50505050509050919050565b6001600160a01b03831661148757604051626a0d4560e21b81526000600482015260240161075a565b604080516001808252602082018590528183019081526060820184905260a082019092526000608082018181529192916114c69187918590859061180f565b5050505050565b6001600160a01b0384166114f757604051632bfa23e760e11b81526000600482015260240161075a565b6001600160a01b03851661152057604051626a0d4560e21b81526000600482015260240161075a565b6114c6858585858561180f565b6001600160a01b03841661155757604051632bfa23e760e11b81526000600482015260240161075a565b60408051600180825260208201869052818301908152606082018590526080820190925290610acb60008784848761180f565b600380546001600160a01b0383811673ffffffffffffffffffffffffffffffffffffffff19831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6001600160a01b0382166116125760405162ced3e160e81b81526000600482015260240161075a565b6001600160a01b03838116600081815260016020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b6001600160a01b0384166116a957604051632bfa23e760e11b81526000600482015260240161075a565b61111a60008585858561180f565b60008181526006602052604090205481906001600160a01b031633146117455760405162461bcd60e51b815260206004820152603160248201527f455243313135355472616461626c652363726561746f724f6e6c793a204f4e4c60448201527f595f43524541544f525f414c4c4f574544000000000000000000000000000000606482015260840161075a565b506000908152600660205260409020805473ffffffffffffffffffffffffffffffffffffffff19166001600160a01b0392909216919091179055565b6001600160a01b0384166117ab57604051632bfa23e760e11b81526000600482015260240161075a565b6001600160a01b0385166117d457604051626a0d4560e21b81526000600482015260240161075a565b60408051600180825260208201869052818301908152606082018590526080820190925290611806878784848761180f565b50505050505050565b61181b85858585611862565b6001600160a01b038416156114c65782513390600103611854576020848101519084015161184d838989858589611a76565b5050610acb565b610acb818787878787611b9a565b80518251146118915781518151604051635b05999160e01b81526004810192909252602482015260440161075a565b3360005b8351811015611997576020818102858101820151908501909101516001600160a01b03881615611948576000828152602081815260408083206001600160a01b038c16845290915290205481811015611921576040516303dee4c560e01b81526001600160a01b038a16600482015260248101829052604481018390526064810184905260840161075a565b6000838152602081815260408083206001600160a01b038d16845290915290209082900390555b6001600160a01b0387161561198d576000828152602081815260408083206001600160a01b038b168452909152812080548392906119879084906124cf565b90915550505b5050600101611895565b508251600103611a185760208301516000906020840151909150856001600160a01b0316876001600160a01b0316846001600160a01b03167fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f628585604051611a09929190918252602082015260400190565b60405180910390a450506114c6565b836001600160a01b0316856001600160a01b0316826001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb8686604051611a679291906124f0565b60405180910390a45050505050565b6001600160a01b0384163b15610acb5760405163f23a6e6160e01b81526001600160a01b0385169063f23a6e6190611aba908990899088908890889060040161251e565b6020604051808303816000875af1925050508015611af5575060408051601f3d908101601f19168201909252611af291810190612561565b60015b611b5e573d808015611b23576040519150601f19603f3d011682016040523d82523d6000602084013e611b28565b606091505b508051600003611b5657604051632bfa23e760e11b81526001600160a01b038616600482015260240161075a565b805181602001fd5b6001600160e01b0319811663f23a6e6160e01b1461180657604051632bfa23e760e11b81526001600160a01b038616600482015260240161075a565b6001600160a01b0384163b15610acb5760405163bc197c8160e01b81526001600160a01b0385169063bc197c8190611bde908990899088908890889060040161257e565b6020604051808303816000875af1925050508015611c19575060408051601f3d908101601f19168201909252611c1691810190612561565b60015b611c47573d808015611b23576040519150601f19603f3d011682016040523d82523d6000602084013e611b28565b6001600160e01b0319811663bc197c8160e01b1461180657604051632bfa23e760e11b81526001600160a01b038616600482015260240161075a565b80356001600160a01b0381168114611c9a57600080fd5b919050565b60008060408385031215611cb257600080fd5b611cbb83611c83565b946020939093013593505050565b6001600160e01b03198116811461064057600080fd5b600060208284031215611cf157600080fd5b81356108ae81611cc9565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff81118282101715611d3b57611d3b611cfc565b604052919050565b600082601f830112611d5457600080fd5b813567ffffffffffffffff811115611d6e57611d6e611cfc565b611d81601f8201601f1916602001611d12565b818152846020838601011115611d9657600080fd5b816020850160208301376000918101602001919091529392505050565b600060208284031215611dc557600080fd5b813567ffffffffffffffff811115611ddc57600080fd5b611de884828501611d43565b949350505050565b6000815180845260005b81811015611e1657602081850181015186830182015201611dfa565b506000602082860101526020601f19601f83011685010191505092915050565b6020815260006108ae6020830184611df0565b600060208284031215611e5b57600080fd5b5035919050565b600060208284031215611e7457600080fd5b6108ae82611c83565b600067ffffffffffffffff821115611e9757611e97611cfc565b5060051b60200190565b600082601f830112611eb257600080fd5b81356020611ec7611ec283611e7d565b611d12565b8083825260208201915060208460051b870101935086841115611ee957600080fd5b602086015b84811015611f055780358352918301918301611eee565b509695505050505050565b600080600080600060a08688031215611f2857600080fd5b611f3186611c83565b9450611f3f60208701611c83565b9350604086013567ffffffffffffffff80821115611f5c57600080fd5b611f6889838a01611ea1565b94506060880135915080821115611f7e57600080fd5b611f8a89838a01611ea1565b93506080880135915080821115611fa057600080fd5b50611fad88828901611d43565b9150509295509295909350565b600080600080600060a08688031215611fd257600080fd5b611fdb86611c83565b94506020860135935060408601359250606086013567ffffffffffffffff8082111561200657600080fd5b611f8a89838a01611d43565b6000806040838503121561202557600080fd5b82359150602083013567ffffffffffffffff81111561204357600080fd5b61204f85828601611d43565b9150509250929050565b6000806040838503121561206c57600080fd5b823567ffffffffffffffff8082111561208457600080fd5b818501915085601f83011261209857600080fd5b813560206120a8611ec283611e7d565b82815260059290921b840181019181810190898411156120c757600080fd5b948201945b838610156120ec576120dd86611c83565b825294820194908201906120cc565b9650508601359250508082111561210257600080fd5b5061204f85828601611ea1565b60008151808452602080850194506020840160005b8381101561214057815187529582019590820190600101612124565b509495945050505050565b6020815260006108ae602083018461210f565b6000806000806080858703121561217457600080fd5b61217d85611c83565b93506020850135925060408501359150606085013567ffffffffffffffff8111156121a757600080fd5b6121b387828801611d43565b91505092959194509250565b600080604083850312156121d257600080fd5b6121db83611c83565b9150602083013580151581146121f057600080fd5b809150509250929050565b6000806040838503121561220e57600080fd5b61221783611c83565b915061222560208401611c83565b90509250929050565b6000806000806080858703121561224457600080fd5b61224d85611c83565b9350602085013567ffffffffffffffff8082111561226a57600080fd5b61227688838901611ea1565b9450604087013591508082111561228c57600080fd5b61229888838901611ea1565b935060608701359150808211156122ae57600080fd5b506121b387828801611d43565b600080604083850312156122ce57600080fd5b6122d783611c83565b9150602083013567ffffffffffffffff8111156122f357600080fd5b61204f85828601611ea1565b600080600080600060a0868803121561231757600080fd5b61232086611c83565b945061232e60208701611c83565b93506040860135925060608601359150608086013567ffffffffffffffff81111561235857600080fd5b611fad88828901611d43565b600181811c9082168061237857607f821691505b6020821081036108b557634e487b7160e01b600052602260045260246000fd5b6000602082840312156123aa57600080fd5b5051919050565b601f821115610938576000816000526020600020601f850160051c810160208610156123da5750805b601f850160051c820191505b81811015610acb578281556001016123e6565b815167ffffffffffffffff81111561241357612413611cfc565b612427816124218454612364565b846123b1565b602080601f83116001811461245c57600084156124445750858301515b600019600386901b1c1916600185901b178555610acb565b600085815260208120601f198616915b8281101561248b5788860151825594840194600190910190840161246c565b50858210156124a95787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b634e487b7160e01b600052603260045260246000fd5b808201808211156105d957634e487b7160e01b600052601160045260246000fd5b604081526000612503604083018561210f565b8281036020840152612515818561210f565b95945050505050565b60006001600160a01b03808816835280871660208401525084604083015283606083015260a0608083015261255660a0830184611df0565b979650505050505050565b60006020828403121561257357600080fd5b81516108ae81611cc9565b60006001600160a01b03808816835280871660208401525060a060408301526125aa60a083018661210f565b82810360608401526125bc818661210f565b905082810360808401526125d08185611df0565b9897505050505050505056fea164736f6c6343000818000a68747470733a2f2f67616d652e666f7274756e6570696b652e78797a2f6170692f6e66742f7469636b65742f7b69647d00000000000000000000000043000000000000000000000000000000000000020000000000000000000000002536fe9ab3f511540f2f9e2ec2a805005c3dd80000000000000000000000000004657b4b1b37cd1707bf82600bf5e1b3fcde5e17

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

00000000000000000000000043000000000000000000000000000000000000020000000000000000000000002536fe9ab3f511540f2f9e2ec2a805005c3dd80000000000000000000000000004657b4b1b37cd1707bf82600bf5e1b3fcde5e17

-----Decoded View---------------
Arg [0] : _blastAddress (address): 0x4300000000000000000000000000000000000002
Arg [1] : _blastPointsAddress (address): 0x2536FE9ab3F511540F2f9e2eC2A805005C3Dd800
Arg [2] : _blastPointsOperator (address): 0x04657B4B1B37cD1707bF82600Bf5E1B3fCDE5e17

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000004300000000000000000000000000000000000002
Arg [1] : 0000000000000000000000002536fe9ab3f511540f2f9e2ec2a805005c3dd800
Arg [2] : 00000000000000000000000004657b4b1b37cd1707bf82600bf5e1b3fcde5e17

202:774:20:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2247:132:2;;;;;;:::i;:::-;;:::i;:::-;;;620:25:26;;;608:2;593:18;2247:132:2;;;;;;;;1380:305;;;;;;:::i;:::-;;:::i;:::-;;;1207:14:26;;1200:22;1182:41;;1170:2;1155:18;1380:305:2;1042:187:26;2045:83:17;;;;;;:::i;:::-;;:::i;:::-;;551:18;;;:::i;:::-;;;;;;;:::i;1167:381::-;;;;;;:::i;:::-;;:::i;508:131:16:-;;;;;;:::i;:::-;;:::i;765:209:20:-;;;;;;:::i;:::-;;:::i;645:46:17:-;;;;;;:::i;:::-;;;;;;;;;;;;;;760:109:16;;;;;;:::i;:::-;;:::i;4014:429:2:-;;;;;;:::i;:::-;;:::i;3556:615:17:-;;;;;;:::i;:::-;;:::i;2310:165::-;;;;;;:::i;:::-;;:::i;143:32:16:-;;;;;-1:-1:-1;;;;;143:32:16;;;;;;-1:-1:-1;;;;;6687:55:26;;;6669:74;;6657:2;6642:18;143:32:16;6502:247:26;2536:552:2;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;6598:88:17:-;;;;;;:::i;:::-;;:::i;2293:101:0:-;;;:::i;4459:341:17:-;;;;;;:::i;:::-;;:::i;736:47::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;7423:96;;;;;;:::i;:::-;;:::i;1638:85:0:-;1710:6;;-1:-1:-1;;;;;1710:6:0;1638:85;;573:20:17;;;:::i;120:19:16:-;;;;;-1:-1:-1;;;;;120:19:16;;;3156:144:2;;;;;;:::i;:::-;;:::i;7305:114:17:-;;;;;;:::i;:::-;-1:-1:-1;;;;;7389:25:17;7370:4;7389:25;;;:15;:25;;;;;;;;;7305:114;1002:173:16;;;;;;:::i;:::-;;:::i;5088:492:17:-;;;;;;:::i;:::-;;:::i;1707:98::-;;;;;;:::i;:::-;1762:7;1784:16;;;:11;:16;;;;;;;1707:98;643:113:16;;;;;;:::i;:::-;;:::i;598:43:17:-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;598:43:17;;;5750:258;;;;;;:::i;:::-;;:::i;873:125:16:-;;;:::i;7072:109:17:-;;;;;;:::i;:::-;;:::i;3367:157:2:-;;;;;;:::i;:::-;-1:-1:-1;;;;;3480:27:2;;;3457:4;3480:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;3367:157;3591:351;;;;;;:::i;:::-;;:::i;2543:215:0:-;;;;;;:::i;:::-;;:::i;6822:105:17:-;;;;;;:::i;:::-;;:::i;2247:132:2:-;2324:7;2350:13;;;;;;;;;;;-1:-1:-1;;;;;2350:22:2;;;;;;;;;;2247:132;;;;;:::o;1380:305::-;1482:4;-1:-1:-1;;;;;;1517:41:2;;-1:-1:-1;;;1517:41:2;;:109;;-1:-1:-1;;;;;;;1574:52:2;;-1:-1:-1;;;1574:52:2;1517:109;:161;;;-1:-1:-1;;;;;;;;;;861:40:12;;;1642:36:2;762:146:12;2045:83:17;1531:13:0;:11;:13::i;:::-;2107:16:17::1;2115:7;2107;:16::i;:::-;2045:83:::0;:::o;551:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1167:381::-;6543:4;6562:13;;;:8;:13;;;;;;1223;;-1:-1:-1;;;;;6562:13:17;1244:63;;;;-1:-1:-1;;;1244:63:17;;12746:2:26;1244:63:17;;;12728:21:26;12785:2;12765:18;;;12758:30;12824:34;12804:18;;;12797:62;12895:8;12875:18;;;12868:36;12921:19;;1244:63:17;;;;;;;;;1378:27;1414:14;;;:9;:14;;;;;1378:51;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1463:1;1439:14;:21;:25;1435:109;;;1481:14;;;;:9;:14;;;;;1474:21;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1167:381;;;:::o;1435:109::-;1523:14;1533:3;1523:9;:14::i;:::-;1516:21;1167:381;-1:-1:-1;;;1167:381:17:o;1435:109::-;1238:310;1167:381;;;:::o;508:131:16:-;584:5;;:50;;-1:-1:-1;;;584:50:16;;609:4;584:50;;;13214:34:26;-1:-1:-1;;;;;13284:15:26;;;13264:18;;;13257:43;13316:18;;;13309:34;;;584:5:16;;;;:16;;13126:18:26;;584:50:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;508:131;;:::o;765:209:20:-;857:1;823:31;833:10;845:8;823:9;:31::i;:::-;:35;815:74;;;;-1:-1:-1;;;815:74:20;;13745:2:26;815:74:20;;;13727:21:26;13784:2;13764:18;;;13757:30;13823:28;13803:18;;;13796:56;13869:18;;815:74:20;13543:350:26;815:74:20;896:30;902:10;914:8;924:1;896:5;:30::i;:::-;937:32;;960:8;;948:10;;937:32;;;;;765:209;:::o;760:109:16:-;821:5;;:43;;-1:-1:-1;;;821:43:16;;847:4;821:43;;;14133:34:26;-1:-1:-1;;;;;14203:15:26;;;14183:18;;;14176:43;821:5:16;;;;:17;;14045:18:26;;821:43:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;760:109;:::o;4014:429:2:-;735:10:8;-1:-1:-1;;;;;4251:14:2;;;;;;;:49;;-1:-1:-1;;;;;;3480:27:2;;;3457:4;3480:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;4269:31;4251:49;4247:129;;;4323:42;;-1:-1:-1;;;4323:42:2;;-1:-1:-1;;;;;14151:15:26;;;4323:42:2;;;14133:34:26;14203:15;;14183:18;;;14176:43;14045:18;;4323:42:2;13898:327:26;4247:129:2;4385:51;4408:4;4414:2;4418:3;4423:6;4431:4;4385:22;:51::i;:::-;4198:245;4014:429;;;;;:::o;3556:615:17:-;3712:7;3753:10;3742:7;1710:6:0;;-1:-1:-1;;;;;1710:6:0;;1638:85;3742:7:17;-1:-1:-1;;;;;3742:21:17;;:52;;;-1:-1:-1;3783:10:17;3767:27;;;;:15;:27;;;;;;;;3742:52;3727:143;;;;-1:-1:-1;;;3727:143:17;;14432:2:26;3727:143:17;;;14414:21:26;14471:2;14451:18;;;14444:30;14510:34;14490:18;;;14483:62;14581:30;14561:18;;;14554:58;14629:19;;3727:143:17;14230:424:26;3727:143:17;6543:4;6562:13;;;:8;:13;;;;;;-1:-1:-1;;;;;6562:13:17;:27;3876:50;;;;-1:-1:-1;;;3876:50:17;;14861:2:26;3876:50:17;;;14843:21:26;14900:2;14880:18;;;14873:30;14939:26;14919:18;;;14912:54;14983:18;;3876:50:17;14659:348:26;3876:50:17;3932:13;;;;:8;:13;;;;;:26;;-1:-1:-1;;3932:26:17;3948:10;3932:26;;;3969:18;;:22;3965:91;;4001:14;;;;:9;:14;;;;;:21;4018:4;4001:14;:21;:::i;:::-;;4045:3;4035:14;4039:4;4035:14;;;;;;:::i;:::-;;;;;;;;3965:91;4062:48;4068:13;4083:3;4088:14;4104:5;4062;:48::i;:::-;-1:-1:-1;;;4117:16:17;;;;:11;:16;;;;;:33;:16;3556:615;-1:-1:-1;3556:615:17:o;2310:165::-;911:13;;;;:8;:13;;;;;;2392:8;;-1:-1:-1;;;;;911:13:17;928:10;911:27;903:89;;;;-1:-1:-1;;;903:89:17;;17409:2:26;903:89:17;;;17391:21:26;17448:2;17428:18;;;17421:30;17487:34;17467:18;;;17460:62;17558:19;17538:18;;;17531:47;17595:19;;903:89:17;17207:413:26;903:89:17;2408:19:::1;::::0;;;:9:::1;:19;::::0;;;;:29:::1;2430:7:::0;2408:19;:29:::1;:::i;:::-;;2461:8;2448:22;2452:7;2448:22;;;;;;:::i;:::-;;;;;;;;2310:165:::0;;;:::o;2536:552:2:-;2660:16;2711:3;:10;2692:8;:15;:29;2688:121;;2770:10;;2782:15;;2744:54;;-1:-1:-1;;;2744:54:2;;;;;17799:25:26;;;;17840:18;;;17833:34;17772:18;;2744:54:2;17625:248:26;2688:121:2;2819:30;2866:8;:15;2852:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2852:30:2;;2819:63;;2898:9;2893:158;2917:8;:15;2913:1;:19;2893:158;;;4777:4:7;4768:14;;;4748:35;;;4742:42;2972:68:2;;4777:4:7;4768:14;;;4748:35;;;4742:42;2247:132:2;:::i;2972:68::-;2953:13;2967:1;2953:16;;;;;;;;:::i;:::-;;;;;;;;;;:87;2934:3;;2893:158;;;-1:-1:-1;3068:13:2;2536:552;-1:-1:-1;;;2536:552:2:o;6598:88:17:-;6650:4;6562:13;;;:8;:13;;;;;;-1:-1:-1;;;;;6562:13:17;:27;;6669:12;6490:104;2293:101:0;1531:13;:11;:13::i;:::-;2357:30:::1;2384:1;2357:18;:30::i;:::-;2293:101::o:0;4459:341:17:-;4566:13;;;;:8;:13;;;;;;-1:-1:-1;;;;;4566:13:17;4583:10;4566:27;;:58;;-1:-1:-1;4613:10:17;4597:27;;;;:15;:27;;;;;;;;4566:58;4551:152;;;;-1:-1:-1;;;4551:152:17;;18212:2:26;4551:152:17;;;18194:21:26;18251:2;18231:18;;;18224:30;18290:34;18270:18;;;18263:62;18361:33;18341:18;;;18334:61;18412:19;;4551:152:17;18010:427:26;4551:152:17;4709:33;4715:3;4720;4725:9;4736:5;4709;:33::i;:::-;4767:16;;;;:11;:16;;;;;;:28;;4786:9;;4767:28;:::i;:::-;4748:16;;;;:11;:16;;;;;;:47;;;;-1:-1:-1;;;4459:341:17:o;7423:96::-;1531:13:0;:11;:13::i;:::-;7486:28:17::1;7504:9;7486:17;:28::i;573:20::-:0;;;;;;;:::i;3156:144:2:-;3241:52;735:10:8;3274:8:2;3284;3241:18;:52::i;1002:173:16:-;1099:12;;:71;;-1:-1:-1;;;1099:71:16;;-1:-1:-1;;;;;14151:15:26;;;1099:71:16;;;14133:34:26;14203:15;;;14183:18;;;14176:43;1099:12:16;;;;:44;;14045:18:26;;1099:71:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5088:492:17;5211:9;5206:323;5230:4;:11;5226:1;:15;5206:323;;;5256:11;5270:4;5275:1;5270:7;;;;;;;;:::i;:::-;;;;;;;;;;;;5302:13;;;;:8;:13;;;;;;;;5270:7;;-1:-1:-1;;;;;;5302:13:17;5319:10;5302:27;;:58;;-1:-1:-1;5349:10:17;5333:27;;;;:15;:27;;;;;;;;5302:58;5285:142;;;;-1:-1:-1;;;5285:142:17;;18871:2:26;5285:142:17;;;18853:21:26;18910:2;18890:18;;;18883:30;18949:34;18929:18;;;18922:62;19020:17;19000:18;;;18993:45;19055:19;;5285:142:17;18669:411:26;5285:142:17;5435:16;5454:11;5466:1;5454:14;;;;;;;;:::i;:::-;;;;;;;5435:33;;5514:8;5495:11;:16;5507:3;5495:16;;;;;;;;;;;;:27;;;;:::i;:::-;5476:16;;;;:11;:16;;;;;;:46;;;;-1:-1:-1;5243:3:17;;5206:323;;;;5534:41;5545:3;5550:4;5556:11;5569:5;5534:10;:41::i;:::-;5088:492;;;;:::o;643:113:16:-;706:5;;:45;;-1:-1:-1;;;706:45:16;;734:4;706:45;;;14133:34:26;-1:-1:-1;;;;;14203:15:26;;;14183:18;;;14176:43;706:5:16;;;;:19;;14045:18:26;;706:45:16;13898:327:26;5750:258:17;-1:-1:-1;;;;;5827:17:17;;5819:74;;;;-1:-1:-1;;;5819:74:17;;19287:2:26;5819:74:17;;;19269:21:26;19326:2;19306:18;;;19299:30;19365:34;19345:18;;;19338:62;19436:14;19416:18;;;19409:42;19468:19;;5819:74:17;19085:408:26;5819:74:17;5904:9;5899:105;5923:4;:11;5919:1;:15;5899:105;;;5949:10;5962:4;5967:1;5962:7;;;;;;;;:::i;:::-;;;;;;;5949:20;;5977;5989:3;5994:2;5977:11;:20::i;:::-;-1:-1:-1;5936:3:17;;5899:105;;873:125:16;954:5;;:39;;-1:-1:-1;;;954:39:16;;987:4;954:39;;;6669:74:26;932:7:16;;-1:-1:-1;;;;;954:5:16;;:24;;6642:18:26;;954:39:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;947:46;;873:125;:::o;7072:109:17:-;1531:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;7143:25:17::1;7171:5;7143:25:::0;;;:15:::1;:25;::::0;;;;:33;;-1:-1:-1;;7143:33:17::1;::::0;;7072:109::o;3591:351:2:-;735:10:8;-1:-1:-1;;;;;3757:14:2;;;;;;;:49;;-1:-1:-1;;;;;;3480:27:2;;;3457:4;3480:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;3775:31;3757:49;3753:129;;;3829:42;;-1:-1:-1;;;3829:42:2;;-1:-1:-1;;;;;14151:15:26;;;3829:42:2;;;14133:34:26;14203:15;;14183:18;;;14176:43;14045:18;;3829:42:2;13898:327:26;3753:129:2;3891:44;3909:4;3915:2;3919;3923:5;3930:4;3891:17;:44::i;2543:215:0:-;1531:13;:11;:13::i;:::-;-1:-1:-1;;;;;2627:22:0;::::1;2623:91;;2672:31;::::0;-1:-1:-1;;;2672:31:0;;2700:1:::1;2672:31;::::0;::::1;6669:74:26::0;6642:18;;2672:31:0::1;6502:247:26::0;2623:91:0::1;2723:28;2742:8;2723:18;:28::i;6822:105:17:-:0;1531:13:0;:11;:13::i;:::-;-1:-1:-1;;;;;6890:25:17::1;;::::0;;;:15:::1;:25;::::0;;;;:32;;-1:-1:-1;;6890:32:17::1;6918:4;6890:32;::::0;;6822:105::o;1796:162:0:-;1710:6;;-1:-1:-1;;;;;1710:6:0;735:10:8;1855:23:0;1851:101;;1901:40;;-1:-1:-1;;;1901:40:0;;735:10:8;1901:40:0;;;6669:74:26;6642:18;;1901:40:0;6502:247:26;10282:86:2;10348:4;:13;10355:6;10348:4;:13;:::i;2084:103::-;2144:13;2176:4;2169:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2084:103;;;:::o;12099:329::-;-1:-1:-1;;;;;12178:18:2;;12174:88;;12219:32;;-1:-1:-1;;;12219:32:2;;12248:1;12219:32;;;6669:74:26;6642:18;;12219:32:2;6502:247:26;12174:88:2;16374:4;16368:11;;16444:1;16429:17;;;16575:4;16563:17;;16556:35;;;16692:17;;;16722;;;16188:23;16759:17;;16752:35;;;12360:61;;;;;;-1:-1:-1;16895:17:2;;;12360:61;;;16368:11;;16692:17;12360:61;;12387:4;;16368:11;;16692:17;;12360:26;:61::i;:::-;12164:264;;12099:329;;;:::o;9015:445::-;-1:-1:-1;;;;;9208:16:2;;9204:88;;9247:34;;-1:-1:-1;;;9247:34:2;;9278:1;9247:34;;;6669:74:26;6642:18;;9247:34:2;6502:247:26;9204:88:2;-1:-1:-1;;;;;9305:18:2;;9301:88;;9346:32;;-1:-1:-1;;;9346:32:2;;9375:1;9346:32;;;6669:74:26;6642:18;;9346:32:2;6502:247:26;9301:88:2;9398:55;9425:4;9431:2;9435:3;9440:6;9448:4;9398:26;:55::i;10746:346::-;-1:-1:-1;;;;;10842:16:2;;10838:88;;10881:34;;-1:-1:-1;;;10881:34:2;;10912:1;10881:34;;;6669:74:26;6642:18;;10881:34:2;6502:247:26;10838:88:2;16374:4;16368:11;;16444:1;16429:17;;;16575:4;16563:17;;16556:35;;;16692:17;;;16722;;;16188:23;16759:17;;16752:35;;;16895:17;;;16882:31;;;16368:11;11024:61;-1:-1:-1;11063:2:2;16368:11;16692:17;11080:4;11024:26;:61::i;2912:187:0:-;3004:6;;;-1:-1:-1;;;;;3020:17:0;;;-1:-1:-1;;3020:17:0;;;;;;;3052:40;;3004:6;;;3020:17;3004:6;;3052:40;;2985:16;;3052:40;2975:124;2912:187;:::o;13268:315:2:-;-1:-1:-1;;;;;13375:22:2;;13371:94;;13420:34;;-1:-1:-1;;;13420:34:2;;13451:1;13420:34;;;6669:74:26;6642:18;;13420:34:2;6502:247:26;13371:94:2;-1:-1:-1;;;;;13474:25:2;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;13474:46:2;;;;;;;;;;13535:41;;1182::26;;;13535::2;;1155:18:26;13535:41:2;;;;;;;13268:315;;;:::o;11523:282::-;-1:-1:-1;;;;;11644:16:2;;11640:88;;11683:34;;-1:-1:-1;;;11683:34:2;;11714:1;11683:34;;;6669:74:26;6642:18;;11683:34:2;6502:247:26;11640:88:2;11737:61;11772:1;11776:2;11780:3;11785:6;11793:4;11737:26;:61::i;6170:103:17:-;911:13;;;;:8;:13;;;;;;6238:3;;-1:-1:-1;;;;;911:13:17;928:10;911:27;903:89;;;;-1:-1:-1;;;903:89:17;;17409:2:26;903:89:17;;;17391:21:26;17448:2;17428:18;;;17421:30;17487:34;17467:18;;;17460:62;17558:19;17538:18;;;17531:47;17595:19;;903:89:17;17207:413:26;903:89:17;-1:-1:-1;6249:13:17::1;::::0;;;:8:::1;:13;::::0;;;;:19;;-1:-1:-1;;6249:19:17::1;-1:-1:-1::0;;;;;6249:19:17;;;::::1;::::0;;;::::1;::::0;;6170:103::o;8151:463:2:-;-1:-1:-1;;;;;8273:16:2;;8269:88;;8312:34;;-1:-1:-1;;;8312:34:2;;8343:1;8312:34;;;6669:74:26;6642:18;;8312:34:2;6502:247:26;8269:88:2;-1:-1:-1;;;;;8370:18:2;;8366:88;;8411:32;;-1:-1:-1;;;8411:32:2;;8440:1;8411:32;;;6669:74:26;6642:18;;8411:32:2;6502:247:26;8366:88:2;16374:4;16368:11;;16444:1;16429:17;;;16575:4;16563:17;;16556:35;;;16692:17;;;16722;;;16188:23;16759:17;;16752:35;;;16895:17;;;16882:31;;;16368:11;8552:55;8579:4;8585:2;16368:11;16692:17;8602:4;8552:26;:55::i;:::-;8259:355;;8151:463;;;;;:::o;7004:690::-;7205:30;7213:4;7219:2;7223:3;7228:6;7205:7;:30::i;:::-;-1:-1:-1;;;;;7249:16:2;;;7245:443;;7330:10;;735::8;;7344:1:2;7330:15;7326:352;;4777:4:7;4748:35;;;4742:42;4748:35;;;4742:42;7483:67:2;7514:8;7524:4;7530:2;4742:42:7;;7545:4:2;7483:30;:67::i;:::-;7347:218;;7326:352;;;7589:74;7625:8;7635:4;7641:2;7645:3;7650:6;7658:4;7589:35;:74::i;5144:1281::-;5279:6;:13;5265:3;:10;:27;5261:117;;5341:10;;5353:13;;5315:52;;-1:-1:-1;;;5315:52:2;;;;;17799:25:26;;;;17840:18;;;17833:34;17772:18;;5315:52:2;17625:248:26;5261:117:2;735:10:8;5388:16:2;5430:691;5454:3;:10;5450:1;:14;5430:691;;;4777:4:7;4768:14;;;4748:35;;;;;4742:42;4748:35;;;;;;4742:42;-1:-1:-1;;;;;5600:18:2;;;5596:420;;5638:19;5660:13;;;;;;;;;;;-1:-1:-1;;;;;5660:19:2;;;;;;;;;;5701;;;5697:129;;;5751:56;;-1:-1:-1;;;5751:56:2;;-1:-1:-1;;;;;19747:55:26;;5751:56:2;;;19729:74:26;19819:18;;;19812:34;;;19862:18;;;19855:34;;;19905:18;;;19898:34;;;19701:19;;5751:56:2;19498:440:26;5697:129:2;5942:9;:13;;;;;;;;;;;-1:-1:-1;;;;;5942:19:2;;;;;;;;;5964;;;;5942:41;;5596:420;-1:-1:-1;;;;;6034:16:2;;;6030:81;;6070:9;:13;;;;;;;;;;;-1:-1:-1;;;;;6070:17:2;;;;;;;;;:26;;6091:5;;6070:9;:26;;6091:5;;6070:26;:::i;:::-;;;;-1:-1:-1;;6030:81:2;-1:-1:-1;;5466:3:2;;5430:691;;;;6135:3;:10;6149:1;6135:15;6131:288;;4777:4:7;4748:35;;4742:42;6166:10:2;;4777:4:7;4748:35;;4742:42;6166:38:2;;-1:-1:-1;6312:2:2;-1:-1:-1;;;;;6281:45:2;6306:4;-1:-1:-1;;;;;6281:45:2;6296:8;-1:-1:-1;;;;;6281:45:2;;6316:2;6320:5;6281:45;;;;;;17799:25:26;;;17855:2;17840:18;;17833:34;17787:2;17772:18;;17625:248;6281:45:2;;;;;;;;6152:185;;6131:288;;;6392:2;-1:-1:-1;;;;;6362:46:2;6386:4;-1:-1:-1;;;;;6362:46:2;6376:8;-1:-1:-1;;;;;6362:46:2;;6396:3;6401:6;6362:46;;;;;;;:::i;:::-;;;;;;;;5251:1174;5144:1281;;;;:::o;13761:974::-;-1:-1:-1;;;;;13967:14:2;;;:18;13963:766;;14005:71;;-1:-1:-1;;;14005:71:2;;-1:-1:-1;;;;;14005:38:2;;;;;:71;;14044:8;;14054:4;;14060:2;;14064:5;;14071:4;;14005:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14005:71:2;;;;;;;;-1:-1:-1;;14005:71:2;;;;;;;;;;;;:::i;:::-;;;14001:718;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14360:6;:13;14377:1;14360:18;14356:349;;14464:26;;-1:-1:-1;;;14464:26:2;;-1:-1:-1;;;;;6687:55:26;;14464:26:2;;;6669:74:26;6642:18;;14464:26:2;6502:247:26;14356:349:2;14657:6;14651:13;14642:6;14638:2;14634:15;14627:38;14001:718;-1:-1:-1;;;;;;14125:55:2;;-1:-1:-1;;;14125:55:2;14121:174;;14250:26;;-1:-1:-1;;;14250:26:2;;-1:-1:-1;;;;;6687:55:26;;14250:26:2;;;6669:74:26;6642:18;;14250:26:2;6502:247:26;14923:1041:2;-1:-1:-1;;;;;15154:14:2;;;:18;15150:808;;15192:78;;-1:-1:-1;;;15192:78:2;;-1:-1:-1;;;;;15192:43:2;;;;;:78;;15236:8;;15246:4;;15252:3;;15257:6;;15265:4;;15192:78;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15192:78:2;;;;;;;;-1:-1:-1;;15192:78:2;;;;;;;;;;;;:::i;:::-;;;15188:760;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15349:60:2;;-1:-1:-1;;;15349:60:2;15345:179;;15479:26;;-1:-1:-1;;;15479:26:2;;-1:-1:-1;;;;;6687:55:26;;15479:26:2;;;6669:74:26;6642:18;;15479:26:2;6502:247:26;14:196;82:20;;-1:-1:-1;;;;;131:54:26;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:254::-;283:6;291;344:2;332:9;323:7;319:23;315:32;312:52;;;360:1;357;350:12;312:52;383:29;402:9;383:29;:::i;:::-;373:39;459:2;444:18;;;;431:32;;-1:-1:-1;;;215:254:26:o;656:131::-;-1:-1:-1;;;;;;730:32:26;;720:43;;710:71;;777:1;774;767:12;792:245;850:6;903:2;891:9;882:7;878:23;874:32;871:52;;;919:1;916;909:12;871:52;958:9;945:23;977:30;1001:5;977:30;:::i;1234:127::-;1295:10;1290:3;1286:20;1283:1;1276:31;1326:4;1323:1;1316:15;1350:4;1347:1;1340:15;1366:275;1437:2;1431:9;1502:2;1483:13;;-1:-1:-1;;1479:27:26;1467:40;;1537:18;1522:34;;1558:22;;;1519:62;1516:88;;;1584:18;;:::i;:::-;1620:2;1613:22;1366:275;;-1:-1:-1;1366:275:26:o;1646:531::-;1689:5;1742:3;1735:4;1727:6;1723:17;1719:27;1709:55;;1760:1;1757;1750:12;1709:55;1796:6;1783:20;1822:18;1818:2;1815:26;1812:52;;;1844:18;;:::i;:::-;1888:55;1931:2;1912:13;;-1:-1:-1;;1908:27:26;1937:4;1904:38;1888:55;:::i;:::-;1968:2;1959:7;1952:19;2014:3;2007:4;2002:2;1994:6;1990:15;1986:26;1983:35;1980:55;;;2031:1;2028;2021:12;1980:55;2096:2;2089:4;2081:6;2077:17;2070:4;2061:7;2057:18;2044:55;2144:1;2119:16;;;2137:4;2115:27;2108:38;;;;2123:7;1646:531;-1:-1:-1;;;1646:531:26:o;2182:322::-;2251:6;2304:2;2292:9;2283:7;2279:23;2275:32;2272:52;;;2320:1;2317;2310:12;2272:52;2360:9;2347:23;2393:18;2385:6;2382:30;2379:50;;;2425:1;2422;2415:12;2379:50;2448;2490:7;2481:6;2470:9;2466:22;2448:50;:::i;:::-;2438:60;2182:322;-1:-1:-1;;;;2182:322:26:o;2509:423::-;2551:3;2589:5;2583:12;2616:6;2611:3;2604:19;2641:1;2651:162;2665:6;2662:1;2659:13;2651:162;;;2727:4;2783:13;;;2779:22;;2773:29;2755:11;;;2751:20;;2744:59;2680:12;2651:162;;;2655:3;2858:1;2851:4;2842:6;2837:3;2833:16;2829:27;2822:38;2921:4;2914:2;2910:7;2905:2;2897:6;2893:15;2889:29;2884:3;2880:39;2876:50;2869:57;;;2509:423;;;;:::o;2937:220::-;3086:2;3075:9;3068:21;3049:4;3106:45;3147:2;3136:9;3132:18;3124:6;3106:45;:::i;3162:180::-;3221:6;3274:2;3262:9;3253:7;3249:23;3245:32;3242:52;;;3290:1;3287;3280:12;3242:52;-1:-1:-1;3313:23:26;;3162:180;-1:-1:-1;3162:180:26:o;3347:186::-;3406:6;3459:2;3447:9;3438:7;3434:23;3430:32;3427:52;;;3475:1;3472;3465:12;3427:52;3498:29;3517:9;3498:29;:::i;3538:183::-;3598:4;3631:18;3623:6;3620:30;3617:56;;;3653:18;;:::i;:::-;-1:-1:-1;3698:1:26;3694:14;3710:4;3690:25;;3538:183::o;3726:668::-;3780:5;3833:3;3826:4;3818:6;3814:17;3810:27;3800:55;;3851:1;3848;3841:12;3800:55;3887:6;3874:20;3913:4;3937:60;3953:43;3993:2;3953:43;:::i;:::-;3937:60;:::i;:::-;4019:3;4043:2;4038:3;4031:15;4071:4;4066:3;4062:14;4055:21;;4128:4;4122:2;4119:1;4115:10;4107:6;4103:23;4099:34;4085:48;;4156:3;4148:6;4145:15;4142:35;;;4173:1;4170;4163:12;4142:35;4209:4;4201:6;4197:17;4223:142;4239:6;4234:3;4231:15;4223:142;;;4305:17;;4293:30;;4343:12;;;;4256;;4223:142;;;-1:-1:-1;4383:5:26;3726:668;-1:-1:-1;;;;;;3726:668:26:o;4399:944::-;4553:6;4561;4569;4577;4585;4638:3;4626:9;4617:7;4613:23;4609:33;4606:53;;;4655:1;4652;4645:12;4606:53;4678:29;4697:9;4678:29;:::i;:::-;4668:39;;4726:38;4760:2;4749:9;4745:18;4726:38;:::i;:::-;4716:48;;4815:2;4804:9;4800:18;4787:32;4838:18;4879:2;4871:6;4868:14;4865:34;;;4895:1;4892;4885:12;4865:34;4918:61;4971:7;4962:6;4951:9;4947:22;4918:61;:::i;:::-;4908:71;;5032:2;5021:9;5017:18;5004:32;4988:48;;5061:2;5051:8;5048:16;5045:36;;;5077:1;5074;5067:12;5045:36;5100:63;5155:7;5144:8;5133:9;5129:24;5100:63;:::i;:::-;5090:73;;5216:3;5205:9;5201:19;5188:33;5172:49;;5246:2;5236:8;5233:16;5230:36;;;5262:1;5259;5252:12;5230:36;;5285:52;5329:7;5318:8;5307:9;5303:24;5285:52;:::i;:::-;5275:62;;;4399:944;;;;;;;;:::o;5348:754::-;5462:6;5470;5478;5486;5494;5547:3;5535:9;5526:7;5522:23;5518:33;5515:53;;;5564:1;5561;5554:12;5515:53;5587:29;5606:9;5587:29;:::i;:::-;5577:39;;5663:2;5652:9;5648:18;5635:32;5625:42;;5714:2;5703:9;5699:18;5686:32;5676:42;;5769:2;5758:9;5754:18;5741:32;5792:18;5833:2;5825:6;5822:14;5819:34;;;5849:1;5846;5839:12;5819:34;5872:50;5914:7;5905:6;5894:9;5890:22;5872:50;:::i;6107:390::-;6185:6;6193;6246:2;6234:9;6225:7;6221:23;6217:32;6214:52;;;6262:1;6259;6252:12;6214:52;6298:9;6285:23;6275:33;;6359:2;6348:9;6344:18;6331:32;6386:18;6378:6;6375:30;6372:50;;;6418:1;6415;6408:12;6372:50;6441;6483:7;6474:6;6463:9;6459:22;6441:50;:::i;:::-;6431:60;;;6107:390;;;;;:::o;6754:1146::-;6872:6;6880;6933:2;6921:9;6912:7;6908:23;6904:32;6901:52;;;6949:1;6946;6939:12;6901:52;6989:9;6976:23;7018:18;7059:2;7051:6;7048:14;7045:34;;;7075:1;7072;7065:12;7045:34;7113:6;7102:9;7098:22;7088:32;;7158:7;7151:4;7147:2;7143:13;7139:27;7129:55;;7180:1;7177;7170:12;7129:55;7216:2;7203:16;7238:4;7262:60;7278:43;7318:2;7278:43;:::i;7262:60::-;7356:15;;;7438:1;7434:10;;;;7426:19;;7422:28;;;7387:12;;;;7462:19;;;7459:39;;;7494:1;7491;7484:12;7459:39;7518:11;;;;7538:148;7554:6;7549:3;7546:15;7538:148;;;7620:23;7639:3;7620:23;:::i;:::-;7608:36;;7571:12;;;;7664;;;;7538:148;;;7705:5;-1:-1:-1;;7748:18:26;;7735:32;;-1:-1:-1;;7779:16:26;;;7776:36;;;7808:1;7805;7798:12;7776:36;;7831:63;7886:7;7875:8;7864:9;7860:24;7831:63;:::i;7905:439::-;7958:3;7996:5;7990:12;8023:6;8018:3;8011:19;8049:4;8078;8073:3;8069:14;8062:21;;8117:4;8110:5;8106:16;8140:1;8150:169;8164:6;8161:1;8158:13;8150:169;;;8225:13;;8213:26;;8259:12;;;;8294:15;;;;8186:1;8179:9;8150:169;;;-1:-1:-1;8335:3:26;;7905:439;-1:-1:-1;;;;;7905:439:26:o;8349:261::-;8528:2;8517:9;8510:21;8491:4;8548:56;8600:2;8589:9;8585:18;8577:6;8548:56;:::i;8615:532::-;8710:6;8718;8726;8734;8787:3;8775:9;8766:7;8762:23;8758:33;8755:53;;;8804:1;8801;8794:12;8755:53;8827:29;8846:9;8827:29;:::i;:::-;8817:39;;8903:2;8892:9;8888:18;8875:32;8865:42;;8954:2;8943:9;8939:18;8926:32;8916:42;;9009:2;8998:9;8994:18;8981:32;9036:18;9028:6;9025:30;9022:50;;;9068:1;9065;9058:12;9022:50;9091;9133:7;9124:6;9113:9;9109:22;9091:50;:::i;:::-;9081:60;;;8615:532;;;;;;;:::o;9629:347::-;9694:6;9702;9755:2;9743:9;9734:7;9730:23;9726:32;9723:52;;;9771:1;9768;9761:12;9723:52;9794:29;9813:9;9794:29;:::i;:::-;9784:39;;9873:2;9862:9;9858:18;9845:32;9920:5;9913:13;9906:21;9899:5;9896:32;9886:60;;9942:1;9939;9932:12;9886:60;9965:5;9955:15;;;9629:347;;;;;:::o;9981:260::-;10049:6;10057;10110:2;10098:9;10089:7;10085:23;10081:32;10078:52;;;10126:1;10123;10116:12;10078:52;10149:29;10168:9;10149:29;:::i;:::-;10139:39;;10197:38;10231:2;10220:9;10216:18;10197:38;:::i;:::-;10187:48;;9981:260;;;;;:::o;10246:869::-;10391:6;10399;10407;10415;10468:3;10456:9;10447:7;10443:23;10439:33;10436:53;;;10485:1;10482;10475:12;10436:53;10508:29;10527:9;10508:29;:::i;:::-;10498:39;;10588:2;10577:9;10573:18;10560:32;10611:18;10652:2;10644:6;10641:14;10638:34;;;10668:1;10665;10658:12;10638:34;10691:61;10744:7;10735:6;10724:9;10720:22;10691:61;:::i;:::-;10681:71;;10805:2;10794:9;10790:18;10777:32;10761:48;;10834:2;10824:8;10821:16;10818:36;;;10850:1;10847;10840:12;10818:36;10873:63;10928:7;10917:8;10906:9;10902:24;10873:63;:::i;:::-;10863:73;;10989:2;10978:9;10974:18;10961:32;10945:48;;11018:2;11008:8;11005:16;11002:36;;;11034:1;11031;11024:12;11002:36;;11057:52;11101:7;11090:8;11079:9;11075:24;11057:52;:::i;11120:422::-;11213:6;11221;11274:2;11262:9;11253:7;11249:23;11245:32;11242:52;;;11290:1;11287;11280:12;11242:52;11313:29;11332:9;11313:29;:::i;:::-;11303:39;;11393:2;11382:9;11378:18;11365:32;11420:18;11412:6;11409:30;11406:50;;;11452:1;11449;11442:12;11406:50;11475:61;11528:7;11519:6;11508:9;11504:22;11475:61;:::i;11547:607::-;11651:6;11659;11667;11675;11683;11736:3;11724:9;11715:7;11711:23;11707:33;11704:53;;;11753:1;11750;11743:12;11704:53;11776:29;11795:9;11776:29;:::i;:::-;11766:39;;11824:38;11858:2;11847:9;11843:18;11824:38;:::i;:::-;11814:48;;11909:2;11898:9;11894:18;11881:32;11871:42;;11960:2;11949:9;11945:18;11932:32;11922:42;;12015:3;12004:9;12000:19;11987:33;12043:18;12035:6;12032:30;12029:50;;;12075:1;12072;12065:12;12029:50;12098;12140:7;12131:6;12120:9;12116:22;12098:50;:::i;12159:380::-;12238:1;12234:12;;;;12281;;;12302:61;;12356:4;12348:6;12344:17;12334:27;;12302:61;12409:2;12401:6;12398:14;12378:18;12375:38;12372:161;;12455:10;12450:3;12446:20;12443:1;12436:31;12490:4;12487:1;12480:15;12518:4;12515:1;12508:15;13354:184;13424:6;13477:2;13465:9;13456:7;13452:23;13448:32;13445:52;;;13493:1;13490;13483:12;13445:52;-1:-1:-1;13516:16:26;;13354:184;-1:-1:-1;13354:184:26:o;15138:543::-;15240:2;15235:3;15232:11;15229:446;;;15276:1;15300:5;15297:1;15290:16;15344:4;15341:1;15331:18;15414:2;15402:10;15398:19;15395:1;15391:27;15385:4;15381:38;15450:4;15438:10;15435:20;15432:47;;;-1:-1:-1;15473:4:26;15432:47;15528:2;15523:3;15519:12;15516:1;15512:20;15506:4;15502:31;15492:41;;15583:82;15601:2;15594:5;15591:13;15583:82;;;15646:17;;;15627:1;15616:13;15583:82;;15857:1345;15983:3;15977:10;16010:18;16002:6;15999:30;15996:56;;;16032:18;;:::i;:::-;16061:97;16151:6;16111:38;16143:4;16137:11;16111:38;:::i;:::-;16105:4;16061:97;:::i;:::-;16213:4;;16270:2;16259:14;;16287:1;16282:663;;;;16989:1;17006:6;17003:89;;;-1:-1:-1;17058:19:26;;;17052:26;17003:89;-1:-1:-1;;15814:1:26;15810:11;;;15806:24;15802:29;15792:40;15838:1;15834:11;;;15789:57;17105:81;;16252:944;;16282:663;15085:1;15078:14;;;15122:4;15109:18;;-1:-1:-1;;16318:20:26;;;16436:236;16450:7;16447:1;16444:14;16436:236;;;16539:19;;;16533:26;16518:42;;16631:27;;;;16599:1;16587:14;;;;16466:19;;16436:236;;;16440:3;16700:6;16691:7;16688:19;16685:201;;;16761:19;;;16755:26;-1:-1:-1;;16844:1:26;16840:14;;;16856:3;16836:24;16832:37;16828:42;16813:58;16798:74;;16685:201;-1:-1:-1;;;;;16932:1:26;16916:14;;;16912:22;16899:36;;-1:-1:-1;15857:1345:26:o;17878:127::-;17939:10;17934:3;17930:20;17927:1;17920:31;17970:4;17967:1;17960:15;17994:4;17991:1;17984:15;18442:222;18507:9;;;18528:10;;;18525:133;;;18580:10;18575:3;18571:20;18568:1;18561:31;18615:4;18612:1;18605:15;18643:4;18640:1;18633:15;19943:465;20200:2;20189:9;20182:21;20163:4;20226:56;20278:2;20267:9;20263:18;20255:6;20226:56;:::i;:::-;20330:9;20322:6;20318:22;20313:2;20302:9;20298:18;20291:50;20358:44;20395:6;20387;20358:44;:::i;:::-;20350:52;19943:465;-1:-1:-1;;;;;19943:465:26:o;20413:584::-;20635:4;-1:-1:-1;;;;;20745:2:26;20737:6;20733:15;20722:9;20715:34;20797:2;20789:6;20785:15;20780:2;20769:9;20765:18;20758:43;;20837:6;20832:2;20821:9;20817:18;20810:34;20880:6;20875:2;20864:9;20860:18;20853:34;20924:3;20918;20907:9;20903:19;20896:32;20945:46;20986:3;20975:9;20971:19;20963:6;20945:46;:::i;:::-;20937:54;20413:584;-1:-1:-1;;;;;;;20413:584:26:o;21002:249::-;21071:6;21124:2;21112:9;21103:7;21099:23;21095:32;21092:52;;;21140:1;21137;21130:12;21092:52;21172:9;21166:16;21191:30;21215:5;21191:30;:::i;21256:850::-;21578:4;-1:-1:-1;;;;;21688:2:26;21680:6;21676:15;21665:9;21658:34;21740:2;21732:6;21728:15;21723:2;21712:9;21708:18;21701:43;;21780:3;21775:2;21764:9;21760:18;21753:31;21807:57;21859:3;21848:9;21844:19;21836:6;21807:57;:::i;:::-;21912:9;21904:6;21900:22;21895:2;21884:9;21880:18;21873:50;21946:44;21983:6;21975;21946:44;:::i;:::-;21932:58;;22039:9;22031:6;22027:22;22021:3;22010:9;22006:19;21999:51;22067:33;22093:6;22085;22067:33;:::i;:::-;22059:41;21256:850;-1:-1:-1;;;;;;;;21256:850:26:o

none