Contract 0xeFd7b1DC887b79568A59c39e6d35B6F2F2D18f02 1

/**
 *Submitted for verification at polygonscan.com on 2021-08-08
*/

pragma solidity ^0.7.6;


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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @dev interface of MomijiToken
 *
 */
interface IMomijiToken {
    function tokenQuantityWithId(uint256 tokenId) view external returns(uint256);
    function tokenMaxQuantityWithId(uint256 tokenId) view external returns(uint256);
    function mintManuallyQuantityWithId(uint256 tokenId) view external returns(uint256);
    function creators(uint256 tokenId) view external returns(address);
    function removeMintManuallyQuantity(uint256 tokenId, uint256 amount) external;
    function addMintManuallyQuantity(uint256 tokenId, uint256 amount) external;
    function mint(uint256 tokenId, address to, uint256 quantity, bytes memory data) external;
    function balanceOf(address account, uint256 id) external view returns (uint256);
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) external;
}

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

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

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

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

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


/**
 * _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {

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

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

/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    constructor() internal {
        _registerInterface(
            ERC1155Receiver(0).onERC1155Received.selector ^
            ERC1155Receiver(0).onERC1155BatchReceived.selector
        );
    }
}

/**
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(address, address, uint256[] memory, uint256[] memory, bytes memory) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

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

    struct Set {
        // Storage of set values
        bytes32[] _values;

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

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

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

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

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

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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


/*
 * @dev 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 GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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

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

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

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

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

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

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

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

interface IERC20 {
    function withdraw(uint256 amount) external;
    function burn(uint256 amount) external;
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 Author: DokiDoki Dev: Kaki Any questions? please contact Kaki
 Machine for matic. Machine version 2
 */
contract ChainbindersMachine is Ownable, ERC1155Holder {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableSet for EnumerableSet.AddressSet;

    /**
     * @dev Game round
     */
    struct Round {
        uint256 id; // request id.
        address player; // address of player.
        RoundStatus status; // status of the round.
        uint256 times; // how many times of this round;
        uint256 totalTimes; // total time of an account.
        uint256[20] cards; // Prize card ot this round.
    }
    enum RoundStatus { Pending, Finished } // status of this round
    mapping(address => Round) public gameRounds;
    uint256 public currentRoundIdCount; //until now, the total round of this Gamemachine.
    uint256 public totalRoundCount;

    // Configurations of this GameMachine
    uint256 public immutable machineId;
    string public machineTitle;
    string public machineDescription;
    string public machineUri;
    // machine type. 2 Chainbinders Machine.
    uint256 public immutable machineType = 2;
    bool public maintaining = true;
    bool public banned = false;

    // This is a set which contains cradID
    EnumerableSet.UintSet private _cardsSet;
    // This mapping contains cardId => amount
    mapping(uint256 => uint256) public amountWithId;
    // Prize pool with a random number to cardId
    mapping(uint256 => uint256) private _prizePool;
    // The amount of cards in this machine.
    uint256 public cardAmount;
    uint256 private _salt;
    uint256 public shuffleCount = 20;
    uint256 public totalAmountForBurn;
    IERC20 public immutable currencyToken;
    IMomijiToken public immutable momijiToken;

    uint256 public playOncePrice;
    address public administrator;

    event AddCard(uint256 cardId, uint256 amount, uint256 cardAmount);
    event RemoveCard(uint256 card, uint256 removeAmount, uint256 cardAmount);
    event RunMachineSuccessfully(address account, uint256 times, uint256 playFee);

    constructor(uint256 _machineId, //machine id
                string memory _machineTitle, // machine title. will be used to initial machine description.
                IMomijiToken _momijiToken, // momiji token address
                IERC20 _currencyToken // currency address
                ) {
        machineId = _machineId;
        momijiToken = _momijiToken;
        currencyToken = _currencyToken;
        administrator = msg.sender;
        _setupMachineTitle(_machineTitle);
        _salt = uint256(keccak256(abi.encodePacked(_momijiToken, _currencyToken, block.timestamp))).mod(10000);
    }

    //setup title
    function _setupMachineTitle(string memory _title) private {
        machineTitle = _title;
        machineDescription = _title;
    }

    /**
     * @dev Add cards which have been minted, and your owned cards
     * @param cardId. Card id you want to add.
     * @param amount. How many cards you want to add.
     */
    function addCard(uint256 cardId, uint256 amount) external onlyOwner unbanned {
        momijiToken.safeTransferFrom(msg.sender, address(this), cardId, amount, "Add Card");
        _cardsSet.add(cardId);
        amountWithId[cardId] = amountWithId[cardId].add(amount);
        for (uint256 i = 0; i < amount; i ++) {
            _prizePool[cardAmount + i] = cardId;
        }
        cardAmount = cardAmount.add(amount);
        emit AddCard(cardId, amount, cardAmount);
    }

    function runMachine(uint256 userProvidedSeed, uint256 times) external onlyHuman unbanned {
        require(!maintaining, "This machine is under maintenance");
        require(!banned, "This machine is banned.");
        require(cardAmount > 0, "There is no card in this machine anymore.");
        require(times > 0, "Times can not be 0");
        require(times <= 20, "Over times.");
        require(times <= cardAmount, "You play too many times.");
        _createARound(times);
        // get random seed with userProvidedSeed and address of sender.
        uint256 seed = uint256(keccak256(abi.encode(userProvidedSeed, msg.sender)));

        if (cardAmount > shuffleCount) {
            _shufflePrizePool(seed);
        }

        for (uint256 i = 0; i < times; i ++) {
            // get randomResult with seed and salt, then mod cardAmount.
            uint256 randomResult = _getRandomNumebr(seed, _salt, cardAmount);
            // update random salt.
            _salt = ((randomResult + cardAmount + _salt) * (i + 1) * block.timestamp).mod(cardAmount) + 1;
            // transfer the cards.
            uint256 result = (randomResult * _salt).mod(cardAmount);
            _updateRound(result, i);
        }

        totalRoundCount = totalRoundCount.add(times);
        uint256 playFee = playOncePrice.mul(times);
        _transferAndBurnToken(playFee);
        _distributePrize();

        emit RunMachineSuccessfully(msg.sender, times, playFee);
    }

    /**
     * @param amount how much token will be needed and will be burned.
     */
    function _transferAndBurnToken(uint256 amount) private {
        currencyToken.transferFrom(msg.sender, address(this), amount);
    }

    function _distributePrize() private {
        for (uint i = 0; i < gameRounds[msg.sender].times; i ++) {
            uint256 cardId = gameRounds[msg.sender].cards[i];
            require(amountWithId[cardId] > 0, "No enough cards of this kind in the Mchine.");

            momijiToken.safeTransferFrom(address(this), msg.sender, cardId, 1, 'Your prize from Degacha');

            amountWithId[cardId] = amountWithId[cardId].sub(1);
            if (amountWithId[cardId] == 0) {
                _removeCardId(cardId);
            }
        }
        gameRounds[msg.sender].status = RoundStatus.Finished;
    }

    function _updateRound(uint256 randomResult, uint256 rand) private {
        uint256 cardId = _prizePool[randomResult];
        cardAmount = cardAmount.sub(1);
        _prizePool[randomResult] = _prizePool[cardAmount];
        gameRounds[msg.sender].cards[rand] = cardId;
    }

    function _getRandomNumebr(uint256 seed, uint256 salt, uint256 mod) view private returns(uint256) {
        return uint256(keccak256(abi.encode(block.timestamp, block.difficulty, block.coinbase, block.gaslimit, seed, block.number))).mod(mod).add(seed).add(salt);
    }

    function _createARound(uint256 times) private {
        gameRounds[msg.sender].id = currentRoundIdCount + 1;
        gameRounds[msg.sender].player = msg.sender;
        gameRounds[msg.sender].status = RoundStatus.Pending;
        gameRounds[msg.sender].times = times;
        gameRounds[msg.sender].totalTimes = gameRounds[msg.sender].totalTimes.add(times);
        currentRoundIdCount = currentRoundIdCount.add(1);
    }

        // shuffle the prize pool again.
    function _shufflePrizePool(uint256 seed) private {
        for (uint256 i = 0; i < shuffleCount; i++) {
            uint256 randomResult = _getRandomNumebr(seed, _salt, cardAmount);
            _salt = ((randomResult + cardAmount + _salt) * (i + 1) * block.timestamp).mod(cardAmount);
            _swapPrize(i, _salt);
        }
    }

    function _swapPrize(uint256 a, uint256 b) private {
        uint256 temp = _prizePool[a];
        _prizePool[a] = _prizePool[b];
        _prizePool[b] = temp;
    }

    function _removeCardId(uint256 _cardId) private {
        _cardsSet.remove(_cardId);
    }

    function cardIdCount() view public returns(uint256) {
        return _cardsSet.length();
    }

    function cardIdWithIndex(uint256 index) view public returns(uint256) {
        return _cardsSet.at(index);
    }

    function changePlayOncePrice(uint256 newPrice) external onlyOwner {
        playOncePrice = newPrice;
    }

    function changeShuffleCount(uint256 _shuffleCount) external onlyAdministrator {
        shuffleCount = _shuffleCount;
    }

    function getResultCardId(address account, uint256 at) view external returns(uint256) {
        return gameRounds[account].cards[at];
    }

    function unlockMachine() external onlyOwner {
        maintaining = false;
    }

    function lockMachine() external onlyOwner {
        maintaining = true;
    }


    function transferAdministrator(address account) external onlyAdministrator {
        require(account != address(0), "Ownable: new owner is zero address");
        administrator = account;
    }

    // transfer this machine to artist
    function transferOwnership(address newOwner) public override onlyAdministrator {
        require(newOwner != address(0), "New account is zero address");
        super.transferOwnership(newOwner);
    }

    function banThisMachine() external onlyAdministrator {
        banned = true;
    }

    function unbanThisMachine() external onlyAdministrator {
        banned = false;
    }

    function changeMachineTitle(string memory title) external onlyOwner {
        machineTitle = title;
    }

    function changeMachineDescription(string memory description) external onlyOwner {
        machineDescription = description;
    }

    function changeMachineUri(string memory newUri) external onlyOwner {
        machineUri = newUri;
    }

    function cleanMachine() external {
        require(msg.sender == administrator || msg.sender == owner(), "Only for administrator.");
        maintaining = true;
        banned = true;

        for (uint256 i = 0; i < cardIdCount(); i ++) {
            uint256 cardId = cardIdWithIndex(i);
            _withdrawCard(cardId);
        }
    }

    // This is an emergency function. you should not always call this function.
    function emergencyWithdrawCard(uint256 cardId) external onlyOwner {
        _withdrawCard(cardId);
    }

    function _withdrawCard(uint256 cardId) private {
        // Checks
        if (amountWithId[cardId] > 0) {
            uint256 amount = amountWithId[cardId];
            // Effects
            cardAmount = cardAmount.sub(amountWithId[cardId]);
            amountWithId[cardId] = 0;
            // Interactions
            momijiToken.safeTransferFrom(address(this), owner(), cardId, amount, "Reset Machine");
        }
    }

    // Modifiers
    modifier onlyHuman() {
        require(tx.origin == msg.sender, "Only for human.");
        _;
    }

    modifier onlyAdministrator() {
        require(address(msg.sender) == administrator, "Only for administrator.");
        _;
    }

    modifier unbanned() {
        require(!banned, "This machine is banned.");
        _;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"_machineId","type":"uint256"},{"internalType":"string","name":"_machineTitle","type":"string"},{"internalType":"contract IMomijiToken","name":"_momijiToken","type":"address"},{"internalType":"contract IERC20","name":"_currencyToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"cardId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cardAmount","type":"uint256"}],"name":"AddCard","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"card","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"removeAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cardAmount","type":"uint256"}],"name":"RemoveCard","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"times","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"playFee","type":"uint256"}],"name":"RunMachineSuccessfully","type":"event"},{"inputs":[{"internalType":"uint256","name":"cardId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"addCard","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"administrator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"amountWithId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"banThisMachine","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"banned","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cardAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cardIdCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"cardIdWithIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"description","type":"string"}],"name":"changeMachineDescription","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"title","type":"string"}],"name":"changeMachineTitle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newUri","type":"string"}],"name":"changeMachineUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"changePlayOncePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shuffleCount","type":"uint256"}],"name":"changeShuffleCount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cleanMachine","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currencyToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentRoundIdCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"cardId","type":"uint256"}],"name":"emergencyWithdrawCard","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"gameRounds","outputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"player","type":"address"},{"internalType":"enum ChainbindersMachine.RoundStatus","name":"status","type":"uint8"},{"internalType":"uint256","name":"times","type":"uint256"},{"internalType":"uint256","name":"totalTimes","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"at","type":"uint256"}],"name":"getResultCardId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockMachine","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"machineDescription","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"machineId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"machineTitle","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"machineType","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"machineUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maintaining","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"momijiToken","outputs":[{"internalType":"contract IMomijiToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"playOncePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"userProvidedSeed","type":"uint256"},{"internalType":"uint256","name":"times","type":"uint256"}],"name":"runMachine","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shuffleCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAmountForBurn","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRoundCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"transferAdministrator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unbanThisMachine","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unlockMachine","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000800000000000000000000000002d0d9b4075e231bff33141d69df49ffcf3be7642000000000000000000000000032b3217241fe53ffadb334a9d06aacd2a9153d9000000000000000000000000000000000000000000000000000000000000000b424e44206d616368696e65000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _machineId (uint256): 12
Arg [1] : _machineTitle (string): BND machine
Arg [2] : _momijiToken (address): 0x2d0d9b4075e231bff33141d69df49ffcf3be7642
Arg [3] : _currencyToken (address): 0x032b3217241fe53ffadb334a9d06aacd2a9153d9

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 0000000000000000000000002d0d9b4075e231bff33141d69df49ffcf3be7642
Arg [3] : 000000000000000000000000032b3217241fe53ffadb334a9d06aacd2a9153d9
Arg [4] : 000000000000000000000000000000000000000000000000000000000000000b
Arg [5] : 424e44206d616368696e65000000000000000000000000000000000000000000

38886:10801:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15793:142;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;39936:24;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40531:32;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40097:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;39650:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;39897:32;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42478:1496;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;40570:33;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47865:88;;;:::i;:::-;;39600:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47961:107;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;40610:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;48076:131;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;31854:148;;;:::i;:::-;;46989:140;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;31212:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;48215:105;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46739:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;40654:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;47137:82;;;:::i;:::-;;40704:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;48765:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;40013:40;;;:::i;:::-;;;;;;;;;;;;;;;;;;;39864:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19505:203;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;47227:79;;;:::i;:::-;;40471:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46513:96;;;:::i;:::-;;;;;;;;;;;;;;;;;;;47316:196;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46856:125;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;46617:114;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;39741:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;48328:348;;;:::i;:::-;;40269:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;41986:484;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;19322:175;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;47560:204;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;39823:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;40739:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;40060:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;47772:85;;;:::i;:::-;;15793:142;15870:4;15894:20;:33;15915:11;15894:33;;;;;;;;;;;;;;;;;;;;;;;;;;;15887:40;;15793:142;;;:::o;39936:24::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;40531:32::-;;;;:::o;40097:26::-;;;;;;;;;;;;;:::o;39650:34::-;;;;:::o;39897:32::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;42478:1496::-;49392:10;49379:23;;:9;:23;;;49371:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49630:6:::1;;;;;;;;;;;49629:7;49621:43;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;42587:11:::2;;;;;;;;;;;42586:12;42578:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42656:6;;;;;;;;;;;42655:7;42647:43;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;42722:1;42709:10;;:14;42701:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42796:1;42788:5;:9;42780:40;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;42848:2;42839:5;:11;;42831:35;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;42894:10;;42885:5;:19;;42877:56;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;42944:20;42958:5;42944:13;:20::i;:::-;43048:12;43092:16;43110:10;43081:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43071:51;;;;;;43063:60;;43048:75;;43153:12;;43140:10;;:25;43136:81;;;43182:23;43200:4;43182:17;:23::i;:::-;43136:81;43234:9;43229:490;43253:5;43249:1;:9;43229:490;;;43355:20;43378:41;43395:4;43401:5;;43408:10;;43378:16;:41::i;:::-;43355:64;;43562:1;43478:81;43548:10;;43527:15;43522:1;43518;:5;43508;;43495:10;;43480:12;:25;:33;43479:45;:63;43478:69;;:81;;;;:::i;:::-;:85;43470:5;:93;;;;43614:14;43631:38;43658:10;;43647:5;;43632:12;:20;43631:26;;:38;;;;:::i;:::-;43614:55;;43684:23;43697:6;43705:1;43684:12;:23::i;:::-;43229:490;;43260:4;;;;;;;43229:490;;;;43749:26;43769:5;43749:15;;:19;;:26;;;;:::i;:::-;43731:15;:44;;;;43786:15;43804:24;43822:5;43804:13;;:17;;:24;;;;:::i;:::-;43786:42;;43839:30;43861:7;43839:21;:30::i;:::-;43880:18;:16;:18::i;:::-;43916:50;43939:10;43951:5;43958:7;43916:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49675:1;;42478:1496:::0;;:::o;40570:33::-;;;;:::o;47865:88::-;49521:13;;;;;;;;;;;49498:36;;49506:10;49498:36;;;49490:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47940:5:::1;47931:6;;:14;;;;;;;;;;;;;;;;;;47865:88::o:0;39600:43::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;47961:107::-;31434:12;:10;:12::i;:::-;31424:22;;:6;;;;;;;;;;:22;;;31416:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48055:5:::1;48040:12;:20;;;;;;;;;;;;:::i;:::-;;47961:107:::0;:::o;40610:37::-;;;:::o;48076:131::-;31434:12;:10;:12::i;:::-;31424:22;;:6;;;;;;;;;;:22;;;31416:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48188:11:::1;48167:18;:32;;;;;;;;;;;;:::i;:::-;;48076:131:::0;:::o;31854:148::-;31434:12;:10;:12::i;:::-;31424:22;;:6;;;;;;;;;;:22;;;31416:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31961:1:::1;31924:40;;31945:6;::::0;::::1;;;;;;;;31924:40;;;;;;;;;;;;31992:1;31975:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;31854:148::o:0;46989:140::-;47065:7;47092:10;:19;47103:7;47092:19;;;;;;;;;;;;;;;:25;;47118:2;47092:29;;;;;;;;;47085:36;;46989:140;;;;:::o;31212:79::-;31250:7;31277:6;;;;;;;;;;;31270:13;;31212:79;:::o;48215:105::-;31434:12;:10;:12::i;:::-;31424:22;;:6;;;;;;;;;;:22;;;31416:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48306:6:::1;48293:10;:19;;;;;;;;;;;;:::i;:::-;;48215:105:::0;:::o;46739:109::-;31434:12;:10;:12::i;:::-;31424:22;;:6;;;;;;;;;;:22;;;31416:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46832:8:::1;46816:13;:24;;;;46739:109:::0;:::o;40654:41::-;;;:::o;47137:82::-;31434:12;:10;:12::i;:::-;31424:22;;:6;;;;;;;;;;:22;;;31416:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47206:5:::1;47192:11;;:19;;;;;;;;;;;;;;;;;;47137:82::o:0;40704:28::-;;;;:::o;48765:106::-;31434:12;:10;:12::i;:::-;31424:22;;:6;;;;;;;;;;:22;;;31416:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48842:21:::1;48856:6;48842:13;:21::i;:::-;48765:106:::0;:::o;40013:40::-;;;:::o;39864:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;19505:203::-;19638:6;19664:36;;;19657:43;;19505:203;;;;;;;:::o;47227:79::-;31434:12;:10;:12::i;:::-;31424:22;;:6;;;;;;;;;;:22;;;31416:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47294:4:::1;47280:11;;:18;;;;;;;;;;;;;;;;;;47227:79::o:0;40471:25::-;;;;:::o;46513:96::-;46556:7;46583:18;:9;:16;:18::i;:::-;46576:25;;46513:96;:::o;47316:196::-;49521:13;;;;;;;;;;;49498:36;;49506:10;49498:36;;;49490:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47429:1:::1;47410:21;;:7;:21;;;;47402:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47497:7;47481:13;;:23;;;;;;;;;;;;;;;;;;47316:196:::0;:::o;46856:125::-;49521:13;;;;;;;;;;;49498:36;;49506:10;49498:36;;;49490:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46960:13:::1;46945:12;:28;;;;46856:125:::0;:::o;46617:114::-;46677:7;46704:19;46717:5;46704:9;:12;;:19;;;;:::i;:::-;46697:26;;46617:114;;;:::o;39741:30::-;;;;:::o;48328:348::-;48394:13;;;;;;;;;;;48380:27;;:10;:27;;;:52;;;;48425:7;:5;:7::i;:::-;48411:21;;:10;:21;;;48380:52;48372:88;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48485:4;48471:11;;:18;;;;;;;;;;;;;;;;;;48509:4;48500:6;;:13;;;;;;;;;;;;;;;;;;48531:9;48526:143;48550:13;:11;:13::i;:::-;48546:1;:17;48526:143;;;48586:14;48603:18;48619:1;48603:15;:18::i;:::-;48586:35;;48636:21;48650:6;48636:13;:21::i;:::-;48526:143;48565:4;;;;;;;48526:143;;;;48328:348::o;40269:47::-;;;;;;;;;;;;;;;;;:::o;41986:484::-;31434:12;:10;:12::i;:::-;31424:22;;:6;;;;;;;;;;:22;;;31416:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49630:6:::1;;;;;;;;;;;49629:7;49621:43;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;42074:11:::2;:28;;;42103:10;42123:4;42130:6;42138;42074:83;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;42168:21;42182:6;42168:9;:13;;:21;;;;:::i;:::-;;42223:32;42248:6;42223:12;:20;42236:6;42223:20;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;42200:12;:20;42213:6;42200:20;;;;;;;;;;;:55;;;;42271:9;42266:100;42290:6;42286:1;:10;42266:100;;;42348:6;42319:10;:26;42343:1;42330:10;;:14;42319:26;;;;;;;;;;;:35;;;;42298:4;;;;;;;42266:100;;;;42389:22;42404:6;42389:10;;:14;;:22;;;;:::i;:::-;42376:10;:35;;;;42427;42435:6;42443;42451:10;;42427:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41986:484:::0;;:::o;19322:175::-;19432:6;19458:31;;;19451:38;;19322:175;;;;;;;:::o;47560:204::-;49521:13;;;;;;;;;;;49498:36;;49506:10;49498:36;;;49490:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47678:1:::1;47658:22;;:8;:22;;;;47650:62;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;47723:33;47747:8;47723:23;:33::i;:::-;47560:204:::0;:::o;39823:34::-;;;:::o;40739:28::-;;;;;;;;;;;;;:::o;40060:30::-;;;;;;;;;;;;;:::o;47772:85::-;49521:13;;;;;;;;;;;49498:36;;49506:10;49498:36;;;49490:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47845:4:::1;47836:6;;:13;;;;;;;;;;;;;;;;;;47772:85::o:0;4541:130::-;4599:7;4626:37;4630:1;4633;4626:37;;;;;;;;;;;;;;;;;:3;:37::i;:::-;4619:44;;4541:130;;;;:::o;45411:428::-;45518:1;45496:19;;:23;45468:10;:22;45479:10;45468:22;;;;;;;;;;;;;;;:25;;:51;;;;45562:10;45530;:22;45541:10;45530:22;;;;;;;;;;;;;;;:29;;;:42;;;;;;;;;;;;;;;;;;45615:19;45583:10;:22;45594:10;45583:22;;;;;;;;;;;;;;;:29;;;:51;;;;;;;;;;;;;;;;;;;;;;;;45676:5;45645:10;:22;45656:10;45645:22;;;;;;;;;;;;;;;:28;;:36;;;;45728:44;45766:5;45728:10;:22;45739:10;45728:22;;;;;;;;;;;;;;;:33;;;:37;;:44;;;;:::i;:::-;45692:10;:22;45703:10;45692:22;;;;;;;;;;;;;;;:33;;:80;;;;45805:26;45829:1;45805:19;;:23;;:26;;;;:::i;:::-;45783:19;:48;;;;45411:428;:::o;45889:340::-;45954:9;45949:273;45973:12;;45969:1;:16;45949:273;;;46007:20;46030:41;46047:4;46053:5;;46060:10;;46030:16;:41::i;:::-;46007:64;;46094:81;46164:10;;46143:15;46138:1;46134;:5;46124;;46111:10;;46096:12;:25;:33;46095:45;:63;46094:69;;:81;;;;:::i;:::-;46086:5;:89;;;;46190:20;46201:1;46204:5;;46190:10;:20::i;:::-;45949:273;45987:3;;;;;;;45949:273;;;;45889:340;:::o;45134:269::-;45222:7;45249:146;45390:4;45249:136;45380:4;45249:126;45371:3;45278:15;45295:16;45313:14;45329;45345:4;45351:12;45267:97;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45257:108;;;;;;45249:117;;:121;;:126;;;;:::i;:::-;:130;;:136;;;;:::i;:::-;:140;;:146;;;;:::i;:::-;45242:153;;45134:269;;;;;:::o;44845:281::-;44922:14;44939:10;:24;44950:12;44939:24;;;;;;;;;;;;44922:41;;44987:17;45002:1;44987:10;;:14;;:17;;;;:::i;:::-;44974:10;:30;;;;45042:10;:22;45053:10;;45042:22;;;;;;;;;;;;45015:10;:24;45026:12;45015:24;;;;;;;;;;;:49;;;;45112:6;45075:10;:22;45086:10;45075:22;;;;;;;;;;;;;;;:28;;45104:4;45075:34;;;;;;;;:43;;;;44845:281;;;:::o;869:181::-;927:7;947:9;963:1;959;:5;947:17;;988:1;983;:6;;975:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1041:1;1034:8;;;869:181;;;;:::o;2223:471::-;2281:7;2531:1;2526;:6;2522:47;;;2556:1;2549:8;;;;2522:47;2581:9;2597:1;2593;:5;2581:17;;2626:1;2621;2617;:5;;;;;;:10;2609:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2685:1;2678:8;;;2223:471;;;;;:::o;44072:135::-;44138:13;:26;;;44165:10;44185:4;44192:6;44138:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44072:135;:::o;44215:622::-;44267:6;44262:505;44283:10;:22;44294:10;44283:22;;;;;;;;;;;;;;;:28;;;44279:1;:32;44262:505;;;44334:14;44351:10;:22;44362:10;44351:22;;;;;;;;;;;;;;;:28;;44380:1;44351:31;;;;;;;;;44334:48;;44428:1;44405:12;:20;44418:6;44405:20;;;;;;;;;;;;:24;44397:80;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44494:11;:28;;;44531:4;44538:10;44550:6;44558:1;44494:93;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44627:27;44652:1;44627:12;:20;44640:6;44627:20;;;;;;;;;;;;:24;;:27;;;;:::i;:::-;44604:12;:20;44617:6;44604:20;;;;;;;;;;;:50;;;;44697:1;44673:12;:20;44686:6;44673:20;;;;;;;;;;;;:25;44669:87;;;44719:21;44733:6;44719:13;:21::i;:::-;44669:87;44262:505;44313:4;;;;;;;44262:505;;;;44809:20;44777:10;:22;44788:10;44777:22;;;;;;;;;;;;;;;:29;;;:52;;;;;;;;;;;;;;;;;;;;;;;;44215:622::o;29841:106::-;29894:15;29929:10;29922:17;;29841:106;:::o;48879:434::-;48983:1;48960:12;:20;48973:6;48960:20;;;;;;;;;;;;:24;48956:350;;;49001:14;49018:12;:20;49031:6;49018:20;;;;;;;;;;;;49001:37;;49090:36;49105:12;:20;49118:6;49105:20;;;;;;;;;;;;49090:10;;:14;;:36;;;;:::i;:::-;49077:10;:49;;;;49164:1;49141:12;:20;49154:6;49141:20;;;;;;;;;;;:24;;;;49209:11;:28;;;49246:4;49253:7;:5;:7::i;:::-;49262:6;49270;49209:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48956:350;;48879:434;:::o;28694:114::-;28754:7;28781:19;28789:3;:10;;28781:7;:19::i;:::-;28774:26;;28694:114;;;:::o;29152:137::-;29223:7;29258:22;29262:3;:10;;29274:5;29258:3;:22::i;:::-;29250:31;;29243:38;;29152:137;;;;:::o;27932:131::-;27999:4;28023:32;28028:3;:10;;28048:5;28040:14;;28023:4;:32::i;:::-;28016:39;;27932:131;;;;:::o;32157:244::-;31434:12;:10;:12::i;:::-;31424:22;;:6;;;;;;;;;;:22;;;31416:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32266:1:::1;32246:22;;:8;:22;;;;32238:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32356:8;32327:38;;32348:6;::::0;::::1;;;;;;;;32327:38;;;;;;;;;;;;32385:8;32376:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;32157:244:::0;:::o;5156:166::-;5242:7;5275:1;5270;:6;;5278:12;5262:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5313:1;5309;:5;;;;;;5302:12;;5156:166;;;;;:::o;46237:168::-;46298:12;46313:10;:13;46324:1;46313:13;;;;;;;;;;;;46298:28;;46353:10;:13;46364:1;46353:13;;;;;;;;;;;;46337:10;:13;46348:1;46337:13;;;;;;;;;;;:29;;;;46393:4;46377:10;:13;46388:1;46377:13;;;;;;;;;;;:20;;;;46237:168;;;:::o;1333:136::-;1391:7;1418:43;1422:1;1425;1418:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1411:50;;1333:136;;;;:::o;46413:92::-;46472:25;46489:7;46472:9;:16;;:25;;;;:::i;:::-;;46413:92;:::o;23773:109::-;23829:7;23856:3;:11;;:18;;;;23849:25;;23773:109;;;:::o;24226:204::-;24293:7;24342:5;24321:3;:11;;:18;;;;:26;24313:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24404:3;:11;;24416:5;24404:18;;;;;;;;;;;;;;;;24397:25;;24226:204;;;;:::o;21338:414::-;21401:4;21423:21;21433:3;21438:5;21423:9;:21::i;:::-;21418:327;;21461:3;:11;;21478:5;21461:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21644:3;:11;;:18;;;;21622:3;:12;;:19;21635:5;21622:19;;;;;;;;;;;:40;;;;21684:4;21677:11;;;;21418:327;21728:5;21721:12;;21338:414;;;;;:::o;1772:192::-;1858:7;1891:1;1886;:6;;1894:12;1878:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1918:9;1934:1;1930;:5;1918:17;;1955:1;1948:8;;;1772:192;;;;;:::o;28239:137::-;28309:4;28333:35;28341:3;:10;;28361:5;28353:14;;28333:7;:35::i;:::-;28326:42;;28239:137;;;;:::o;23558:129::-;23631:4;23678:1;23655:3;:12;;:19;23668:5;23655:19;;;;;;;;;;;;:24;;23648:31;;23558:129;;;;:::o;21928:1544::-;21994:4;22112:18;22133:3;:12;;:19;22146:5;22133:19;;;;;;;;;;;;22112:40;;22183:1;22169:10;:15;22165:1300;;22531:21;22568:1;22555:10;:14;22531:38;;22584:17;22625:1;22604:3;:11;;:18;;;;:22;22584:42;;22871:17;22891:3;:11;;22903:9;22891:22;;;;;;;;;;;;;;;;22871:42;;23037:9;23008:3;:11;;23020:13;23008:26;;;;;;;;;;;;;;;:38;;;;23156:1;23140:13;:17;23114:3;:12;;:23;23127:9;23114:23;;;;;;;;;;;:43;;;;23266:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;23361:3;:12;;:19;23374:5;23361:19;;;;;;;;;;;23354:26;;;23404:4;23397:11;;;;;;;;22165:1300;23448:5;23441:12;;;21928:1544;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o

ipfs://a084179afb735ebc87d6de0a8313da09d1d25b9ec81a9008bf49f706616a8b90