Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

•    - function _msgSender()
•    - function _msgData()
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function _callOptionalReturn(IERC20 t ...
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•  contract ERC20 is Context, IERC20, ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(
•    - function _spendAllowance(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•    - function burn(uint256 amount)
•    - function burnFrom(address account, ui ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• interface IERC1155 is IERC165
•    - function balanceOf(address account, u ...
•    - function balanceOfBatch(address[] cal ...
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address acc ...
•    - function safeTransferFrom(
•    - function safeBatchTransferFrom(
• interface IERC1155MetadataURI is IERC ...
•    - function uri(uint256 id)
• interface IERC1155Receiver is IERC165
•    - function onERC1155Received(
•    - function onERC1155BatchReceived(
•  contract ERC1155 is Context, ERC16 ...
•    - function supportsInterface(bytes4 int ...
•    - function uri(uint256)
•    - function balanceOf(address account, u ...
•    - function balanceOfBatch(address[] mem ...
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address acc ...
•    - function safeTransferFrom(
•    - function safeBatchTransferFrom(
•    - function _safeTransferFrom(
•    - function _safeBatchTransferFrom(
•    - function _setURI(string memory newuri ...
•    - function _mint(
•    - function _mintBatch(
•    - function _burn(
•    - function _burnBatch(
•    - function _setApprovalForAll(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•    - function _doSafeTransferAcceptanceChe ...
•    - function _doSafeBatchTransferAcceptan ...
•    - function _asSingletonArray(uint256 el ...
•    - function burn(
•    - function burnBatch(
•  contract MagicFarm is Ownable,Reen ... *
•    - function stakeNFT(address _Staker,uin ...
•    - function onERC1155Received(
•    - function onERC1155BatchReceived(
•    - function unstake(address _Staker,uint ...
•    - function StakingSlot_Price (uint256 n ...
•    - function UnlockAccessorySlot (uint256 ...
•    - function boostAccessorySlot (uint256[ ...
•    - function ClaimRewards()
•    - function CheckRewards()
•    - function startTheFarm()
•    - function updatepoolbalance()

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at cronoscan.com on 2023-11-29
*/

// SPDX-License-Identifier: MIT

/*

███╗░░░███╗░█████╗░░██████╗░██╗░█████╗░██╗░░░██╗███████╗██████╗░░██████╗███████╗
████╗░████║██╔══██╗██╔════╝░██║██╔══██╗██║░░░██║██╔════╝██╔══██╗██╔════╝██╔════╝
██╔████╔██║███████║██║░░██╗░██║██║░░╚═╝╚██╗░██╔╝█████╗░░██████╔╝╚█████╗░█████╗░░
██║╚██╔╝██║██╔══██║██║░░╚██╗██║██║░░██╗░╚████╔╝░██╔══╝░░██╔══██╗░╚═══██╗██╔══╝░░
██║░╚═╝░██║██║░░██║╚██████╔╝██║╚█████╔╝░░╚██╔╝░░███████╗██║░░██║██████╔╝███████╗
╚═╝░░░░░╚═╝╚═╝░░╚═╝░╚═════╝░╚═╝░╚════╝░░░░╚═╝░░░╚══════╝╚═╝░░╚═╝╚═════╝░╚══════╝

*/

pragma solidity ^0.8.18;

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

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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.
     *
     * _Available since v3.4._
     */
    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 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) {
        return a + b;
    }

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

    /**
     * @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) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting 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 a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

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;

    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() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}
/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        return batchBalances;
    }

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

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

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

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

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

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

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

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

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

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

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

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

        address operator = _msgSender();

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

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

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

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

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

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

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

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

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

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

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

        return array;
    }
}

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

        _burn(account, id, value);
    }

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

        _burnBatch(account, ids, values);
    }
}



contract MagicFarm is Ownable,ReentrancyGuard {
  using SafeERC20 for IERC20;
  IERC1155 public MagicAssets;
  ERC1155Burnable public BMagicAssets;
  IERC20 public Orb;
  uint256 public price = 20*10**18;

 address payable private Wallet_Burn = payable(0x000000000000000000000000000000000000dEaD); 

  constructor(address _MagicAssets, address _Orb) {
     MagicAssets = IERC1155(_MagicAssets);
     BMagicAssets = ERC1155Burnable(_MagicAssets);
     Orb = IERC20(_Orb);
 }
  receive() external payable{}
  
  uint256 public AccumulatedRewardsPerShare;
  uint256 public TotalRewardsHarvested;
  uint256 public OldBalance;
  uint256 public StakingSlotPrice = 1000000*1e18;
  uint256 public TotalMintingPower;
  uint256 public TotalNFTStaked;
  bool public FarmStarted;
  mapping(address => mapping(uint256 => uint256)) public StakeSlot;


  struct Staker {
      uint256 MintingPower;
      uint256 totalRewards;
      uint256 totalstaked;
      uint256 rewardDebt;
      uint256 RewardsToHarvest;
      uint256 Ultimum;
      uint BirthRuneSlot;
      uint PowerRuneSlot;
      uint HarvestRuneSlot;
      uint WealthRuneSlot;
      uint SunRuneSlot;
  }
  
   mapping (address => Staker) public Stakers;
   
   function stakeNFT(address _Staker,uint256 [] memory nftids) public nonReentrant{

        Staker storage staker = Stakers[_Staker];

        for(uint i=0;i<nftids.length;i++){
         require (nftids[i]<5);
         require (MagicAssets.balanceOf(_Staker,nftids[i])>0);
        }

        ClaimRewards();  
        
        uint256[] memory Idamounts = new uint256[](nftids.length);
        uint256 addedMintingPower;
        for(uint y=0;y<nftids.length;y++){
           require (StakeSlot[_Staker][nftids[y]]<1, "NFT Asset already staked");    
           StakeSlot[_Staker][nftids[y]] = 1;
           Idamounts[y] = 1;
           if(nftids[y] == 0){
               require(staker.BirthRuneSlot>0);
               addedMintingPower = addedMintingPower + (staker.BirthRuneSlot*100);
           }
           if(nftids[y] == 1){
               require(staker.PowerRuneSlot>0);
               addedMintingPower = addedMintingPower + (staker.PowerRuneSlot*300);
           }
           if(nftids[y] == 2){
               require(staker.HarvestRuneSlot>0);
               addedMintingPower = addedMintingPower + (staker.HarvestRuneSlot*600);
           }
           if(nftids[y] == 3){
               require(staker.WealthRuneSlot>0);
               addedMintingPower = addedMintingPower + (staker.WealthRuneSlot*1500);
           }
           if(nftids[y] == 4){
               require(staker.SunRuneSlot>0);
               addedMintingPower = addedMintingPower + (staker.SunRuneSlot*5000);
           }
          }
        
        if (staker.Ultimum < 1){
            if (StakeSlot[_Staker][0]>0 && StakeSlot[_Staker][1]>0 && StakeSlot[_Staker][2]>0 && StakeSlot[_Staker][3]>0 && StakeSlot[_Staker][4]>0){
                staker.Ultimum = 1;
                addedMintingPower = addedMintingPower + 2500;
            }
        }

         for(uint k=0;k<nftids.length;k++){
         MagicAssets.safeTransferFrom(msg.sender, address(this), nftids[k], 1, "");
        }
        
        uint Current_MintingPower = staker.MintingPower + addedMintingPower;

        staker.rewardDebt = Current_MintingPower*AccumulatedRewardsPerShare;    

        staker.MintingPower = Current_MintingPower;
        TotalMintingPower = TotalMintingPower + addedMintingPower;

        staker.totalstaked = staker.totalstaked + nftids.length;
        TotalNFTStaked = TotalNFTStaked + nftids.length;

          
       
   }

   function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4) {
        return bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"));
    }
   
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4){
        return bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"));
    }
    
   function unstake(address _Staker,uint256 [] memory nftids) public nonReentrant{
        Staker storage staker = Stakers[_Staker];
        
         for(uint i=0;i<nftids.length;i++){
         require (nftids[i]<5);
        }

        ClaimRewards();
        
        uint256[] memory Idamounts = new uint256[](nftids.length);
        uint256 removedMintingPower;
        
        for(uint y=0;y<nftids.length;y++){
        require (StakeSlot[_Staker][nftids[y]]>0, "NFT Asset is not staked"); 
        StakeSlot[_Staker][nftids[y]] = 0;   
        Idamounts[y] = 1;
           nftids[y] == 0 ? removedMintingPower = removedMintingPower + (staker.BirthRuneSlot*100) :
           nftids[y] == 1 ? removedMintingPower = removedMintingPower + (staker.PowerRuneSlot*300) :
           nftids[y] == 2 ? removedMintingPower = removedMintingPower + (staker.HarvestRuneSlot*600) :
           nftids[y] == 3 ? removedMintingPower = removedMintingPower + (staker.WealthRuneSlot*1500) :
           nftids[y] == 4 ? removedMintingPower = removedMintingPower + (staker.SunRuneSlot*5000) : 0;
         }
        if (staker.Ultimum > 0){
            if (StakeSlot[_Staker][0] < 1 || StakeSlot[_Staker][1] < 1 || StakeSlot[_Staker][2] < 1 || StakeSlot[_Staker][3] < 1 || StakeSlot[_Staker][4] < 1){
                staker.Ultimum = 0;
                removedMintingPower = removedMintingPower + 2500;
            }
        }

        
        staker.MintingPower = staker.MintingPower - removedMintingPower;
        TotalMintingPower = TotalMintingPower - removedMintingPower;
        
        staker.totalstaked = staker.totalstaked - nftids.length;
        TotalNFTStaked = TotalNFTStaked - nftids.length;
        
        staker.rewardDebt = staker.MintingPower*AccumulatedRewardsPerShare;  
        
        for(uint k=0;k<nftids.length;k++){
         MagicAssets.safeTransferFrom(address(this), msg.sender, nftids[k], 1, "");
        }
   }

   function StakingSlot_Price (uint256 newStakingSlotPrice) public onlyOwner{
         StakingSlotPrice = newStakingSlotPrice;
   }

   //Unlocking stakingslots
   function UnlockAccessorySlot (uint256[] memory slotnumbers) public nonReentrant{
       require (slotnumbers.length<=5, "5 slots");
       uint256 priceToUnlock;
       Staker storage staker = Stakers[msg.sender];
       for(uint i=0;i<slotnumbers.length;i++){ 

        if (slotnumbers[i] == 1){
         require (staker.BirthRuneSlot == 0);
         priceToUnlock = priceToUnlock + (StakingSlotPrice*slotnumbers[i]);  
         staker.BirthRuneSlot = 1;  
        }
        if (slotnumbers[i] == 2){
         require (staker.PowerRuneSlot == 0);
         priceToUnlock = priceToUnlock + (StakingSlotPrice*slotnumbers[i]); 
         staker.PowerRuneSlot = 1;
        }
        if (slotnumbers[i] == 3){
         require (staker.HarvestRuneSlot == 0);
         priceToUnlock = priceToUnlock + (StakingSlotPrice*slotnumbers[i]); 
         staker.HarvestRuneSlot = 1;
        }
        if (slotnumbers[i] == 4){
         require (staker.WealthRuneSlot == 0);
         priceToUnlock = priceToUnlock + (StakingSlotPrice*slotnumbers[i]); 
         staker.WealthRuneSlot = 1;
        }
        if (slotnumbers[i] == 5){
         require (staker.SunRuneSlot == 0);
         priceToUnlock = priceToUnlock + (StakingSlotPrice*slotnumbers[i]);
         staker.SunRuneSlot = 1;
        }
     }
     require(Orb.balanceOf(msg.sender) >= priceToUnlock, "Not enough Orb tokens");
     Orb.safeTransferFrom(msg.sender,Wallet_Burn, priceToUnlock);
   }
   //boosting Accessory Slots with Magic Shards
   function boostAccessorySlot (uint256[] memory slotnumbers,uint256[] memory boostTimes) public nonReentrant{
       
       Staker storage staker = Stakers[msg.sender];

       ClaimRewards(); 
       
       uint shardsToBurn;
       uint addedMintingPower;
       for (uint i=0;i<slotnumbers.length;i++){
       if (slotnumbers[i] == 1){
           require(staker.BirthRuneSlot>0,"Slot is locked");
           require((staker.BirthRuneSlot+boostTimes[i]) <= 5);
           shardsToBurn = shardsToBurn + 10*boostTimes[i];
           if (StakeSlot[msg.sender][0]>0){
           addedMintingPower = addedMintingPower + (100*boostTimes[i]);
           }
           staker.BirthRuneSlot = staker.BirthRuneSlot + boostTimes[i];
       }
       if (slotnumbers[i] == 2){
           require(staker.PowerRuneSlot>0,"Slot is locked");
           require((staker.PowerRuneSlot+boostTimes[i]) <= 5);
           shardsToBurn = shardsToBurn + 30*boostTimes[i];
           if (StakeSlot[msg.sender][1]>0){
            addedMintingPower = addedMintingPower + (300*boostTimes[i]);
           }  
        staker.PowerRuneSlot = staker.PowerRuneSlot + boostTimes[i];
       }
       if (slotnumbers[i] == 3){
           require(staker.HarvestRuneSlot>0,"Slot is locked");
           require((staker.HarvestRuneSlot+boostTimes[i]) <= 5);
           shardsToBurn = shardsToBurn + 60*boostTimes[i];
           if (StakeSlot[msg.sender][2]>0){
             addedMintingPower = addedMintingPower + (600*boostTimes[i]);
           }  
           staker.HarvestRuneSlot = staker.HarvestRuneSlot + boostTimes[i];
       }
       if (slotnumbers[i] == 4){
           require(staker.WealthRuneSlot>0,"Slot is locked");
           require((staker.WealthRuneSlot+boostTimes[i]) <= 5);
           shardsToBurn = shardsToBurn + 150*boostTimes[i];
           if (StakeSlot[msg.sender][3]>0){
             addedMintingPower = addedMintingPower + (1500*boostTimes[i]);
           }   
           staker.WealthRuneSlot = staker.WealthRuneSlot + boostTimes[i];
       }
       if (slotnumbers[i] == 5){
           require(staker.SunRuneSlot>0,"Slot is locked");
           require((staker.SunRuneSlot+boostTimes[i]) <= 5);
           shardsToBurn = shardsToBurn + 500*boostTimes[i];
           if (StakeSlot[msg.sender][4]>0){
           addedMintingPower = addedMintingPower + (5000*boostTimes[i]);
        }  
        staker.SunRuneSlot = staker.SunRuneSlot + boostTimes[i];
       }
    }

    require (MagicAssets.balanceOf(msg.sender,5)>=shardsToBurn);

    BMagicAssets.burn(msg.sender,5,shardsToBurn);
    
    uint Current_MintingPower = staker.MintingPower + addedMintingPower;

    staker.rewardDebt = Current_MintingPower*AccumulatedRewardsPerShare;    

    staker.MintingPower = Current_MintingPower;
    TotalMintingPower = TotalMintingPower + addedMintingPower;
       
   }

   //User can claim his rewards
   function ClaimRewards() public payable {
      updatepoolbalance();
      Staker storage staker = Stakers[msg.sender];
      uint256 RewardsToHarvest = (staker.MintingPower*AccumulatedRewardsPerShare) - staker.rewardDebt;
       if (RewardsToHarvest == 0) {
            staker.rewardDebt = staker.MintingPower*AccumulatedRewardsPerShare;  
            return;
        }
      staker.rewardDebt = staker.MintingPower*AccumulatedRewardsPerShare;    
      TotalRewardsHarvested = TotalRewardsHarvested + RewardsToHarvest;
      staker.totalRewards = staker.totalRewards + RewardsToHarvest;
      payable(msg.sender).transfer(RewardsToHarvest);
   }

   //checking caller's rewards
   function CheckRewards() public view returns(uint256) {
      Staker storage staker = Stakers[msg.sender];
      uint256 newrewards = address(this).balance + TotalRewardsHarvested - OldBalance;
      uint256 newAccRewardsPerShare;
      if(TotalMintingPower>0 && FarmStarted == true){
        newAccRewardsPerShare = AccumulatedRewardsPerShare + (newrewards/TotalMintingPower);
      }
      uint256 RewardsToHarvest = (staker.MintingPower*newAccRewardsPerShare) - staker.rewardDebt;
      return RewardsToHarvest;     
   }
   
   function startTheFarm() public onlyOwner{
     FarmStarted = true;
   }

   //updates the pool prize balance and adds the claimable rewards
   function updatepoolbalance() private {
         if (TotalNFTStaked < 1 || FarmStarted == false) {
              return;
         }
         uint256 newrewards = address(this).balance + TotalRewardsHarvested - OldBalance;
         AccumulatedRewardsPerShare = AccumulatedRewardsPerShare + (newrewards/TotalMintingPower);
         OldBalance = OldBalance + newrewards;    
   }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_MagicAssets","type":"address"},{"internalType":"address","name":"_Orb","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"AccumulatedRewardsPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BMagicAssets","outputs":[{"internalType":"contract ERC1155Burnable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CheckRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ClaimRewards","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"FarmStarted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MagicAssets","outputs":[{"internalType":"contract IERC1155","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OldBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Orb","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"StakeSlot","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"Stakers","outputs":[{"internalType":"uint256","name":"MintingPower","type":"uint256"},{"internalType":"uint256","name":"totalRewards","type":"uint256"},{"internalType":"uint256","name":"totalstaked","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"RewardsToHarvest","type":"uint256"},{"internalType":"uint256","name":"Ultimum","type":"uint256"},{"internalType":"uint256","name":"BirthRuneSlot","type":"uint256"},{"internalType":"uint256","name":"PowerRuneSlot","type":"uint256"},{"internalType":"uint256","name":"HarvestRuneSlot","type":"uint256"},{"internalType":"uint256","name":"WealthRuneSlot","type":"uint256"},{"internalType":"uint256","name":"SunRuneSlot","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"StakingSlotPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newStakingSlotPrice","type":"uint256"}],"name":"StakingSlot_Price","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"TotalMintingPower","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TotalNFTStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TotalRewardsHarvested","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"slotnumbers","type":"uint256[]"}],"name":"UnlockAccessorySlot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"slotnumbers","type":"uint256[]"},{"internalType":"uint256[]","name":"boostTimes","type":"uint256[]"}],"name":"boostAccessorySlot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","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":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_Staker","type":"address"},{"internalType":"uint256[]","name":"nftids","type":"uint256[]"}],"name":"stakeNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTheFarm","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_Staker","type":"address"},{"internalType":"uint256[]","name":"nftids","type":"uint256[]"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000c6a22eef316a4aa3ae596f2fe0912b360805587a000000000000000000000000f06dfed9aa6d4206ebbc0ef2a93567e794592364

-----Decoded View---------------
Arg [0] : _MagicAssets (address): 0xC6a22Eef316a4aa3ae596f2FE0912b360805587a
Arg [1] : _Orb (address): 0xf06DFed9aA6D4206EBBC0eF2a93567e794592364

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000c6a22eef316a4aa3ae596f2fe0912b360805587a
Arg [1] : 000000000000000000000000f06dfed9aa6d4206ebbc0ef2a93567e794592364

69221:12759:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80206:658;;;:::i;:::-;;69793:36;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;69793:36:0;;;;;;;;75722:1471;;;;;;;;;;-1:-1:-1;75722:1471:0;;;;;:::i;:::-;;:::i;69303:27::-;;;;;;;;;;-1:-1:-1;69303:27:0;;;;-1:-1:-1;;;;;69303:27:0;;;;;;-1:-1:-1;;;;;1769:32:1;;;1751:51;;1739:2;1724:18;69303:27:0;1588:220:1;69986:23:0;;;;;;;;;;-1:-1:-1;69986:23:0;;;;;;;;;;;1978:14:1;;1971:22;1953:41;;1941:2;1926:18;69986:23:0;1813:187:1;80903:532:0;;;;;;;;;;;;;:::i;73581:1968::-;;;;;;;;;;-1:-1:-1;73581:1968:0;;;;;:::i;:::-;;:::i;69952:29::-;;;;;;;;;;;;;;;;81445:73;;;;;;;;;;;;;:::i;69375:17::-;;;;;;;;;;-1:-1:-1;69375:17:0;;;;-1:-1:-1;;;;;69375:17:0;;;23464:103;;;;;;;;;;;;;:::i;69915:32::-;;;;;;;;;;;;;;;;22813:87;;;;;;;;;;-1:-1:-1;22859:7:0;22886:6;-1:-1:-1;;;;;22886:6:0;22813:87;;70475:2464;;;;;;;;;;-1:-1:-1;70475:2464:0;;;;;:::i;:::-;;:::i;69335:35::-;;;;;;;;;;-1:-1:-1;69335:35:0;;;;-1:-1:-1;;;;;69335:35:0;;;69397:32;;;;;;;;;;;;;;;;69747:41;;;;;;;;;;;;;;;;70014:64;;;;;;;;;;-1:-1:-1;70014:64:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;73245:325;;;;;;;;;;-1:-1:-1;73245:325:0;;;;;:::i;:::-;73483:78;73245:325;;;;;;;;;;;;;;-1:-1:-1;;;;;;5632:33:1;;;5614:52;;5602:2;5587:18;73245:325:0;5470:202:1;69834:25:0;;;;;;;;;;;;;;;;75556:130;;;;;;;;;;-1:-1:-1;75556:130:0;;;;;:::i;:::-;;:::i;69864:46::-;;;;;;;;;;;;;;;;70422:42;;;;;;;;;;-1:-1:-1;70422:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6481:25:1;;;6537:2;6522:18;;6515:34;;;;6565:18;;;6558:34;;;;6623:2;6608:18;;6601:34;;;;6666:3;6651:19;;6644:35;;;;6710:3;6695:19;;6688:35;;;;6754:3;6739:19;;6732:35;6798:3;6783:19;;6776:35;6842:3;6827:19;;6820:35;6886:3;6871:19;;6864:35;6930:3;6915:19;;6908:36;6468:3;6453:19;70422:42:0;6053:897:1;72946:288:0;;;;;;;;;;-1:-1:-1;72946:288:0;;;;;:::i;:::-;73156:69;72946:288;;;;;;;;;23722:201;;;;;;;;;;-1:-1:-1;23722:201:0;;;;;:::i;:::-;;:::i;77247:2919::-;;;;;;;;;;-1:-1:-1;77247:2919:0;;;;;:::i;:::-;;:::i;80206:658::-;80254:19;:17;:19::i;:::-;80314:10;80282:21;80306:19;;;:7;:19;;;;;80412:17;;;;80382:26;;80362:19;;80306;;80282:21;80362:46;;80382:26;80362:46;:::i;:::-;80361:68;;;;:::i;:::-;80334:95;;80443:16;80463:1;80443:21;80439:143;;80521:26;;80501:19;;:46;;80521:26;80501:46;:::i;:::-;80481:6;:17;;:66;;;;80564:7;;80206:658::o;80439:143::-;80630:26;;80610:19;;:46;;80630:26;80610:46;:::i;:::-;80590:17;;;:66;80693:21;;:40;;80717:16;;80693:40;:::i;:::-;80669:21;:64;80764:19;;;;:38;;80786:16;;80764:38;:::i;:::-;80742:19;;;:60;80811:46;;80819:10;;80811:46;;;;;80840:16;;80811:46;;;;80840:16;80819:10;80811:46;;;;;;;;;;;;;;;;;;;;;80245:619;;80206:658::o;75722:1471::-;18234:1;18832:7;;:19;18824:63;;;;-1:-1:-1;;;18824:63:0;;;;;;;:::i;:::-;;;;;;;;;18234:1;18965:7;:18;75820;;75840:1:::1;-1:-1:-1::0;75820:21:0::1;75811:42;;;::::0;-1:-1:-1;;;75811:42:0;;9385:2:1;75811:42:0::1;::::0;::::1;9367:21:1::0;9424:1;9404:18;;;9397:29;-1:-1:-1;;;9442:18:1;;;9435:37;9489:18;;75811:42:0::1;9183:330:1::0;75811:42:0::1;75926:10;75863:21;75918:19:::0;;;:7:::1;:19;::::0;;;;75863:21;75947:1089:::1;75962:11;:18;75960:1;:20;75947:1089;;;76003:11;76015:1;76003:14;;;;;;;;:::i;:::-;;;;;;;76021:1;76003:19:::0;75999:200:::1;;76044:20;::::0;::::1;::::0;:25;76035:35:::1;;;::::0;::::1;;76132:11;76144:1;76132:14;;;;;;;;:::i;:::-;;;;;;;76115:16;;:31;;;;:::i;:::-;76098:49;::::0;:13;:49:::1;:::i;:::-;76184:1;76161:20;::::0;::::1;:24:::0;76082:65;-1:-1:-1;75999:200:0::1;76213:11;76225:1;76213:14;;;;;;;;:::i;:::-;;;;;;;76231:1;76213:19:::0;76209:197:::1;;76254:20;::::0;::::1;::::0;:25;76245:35:::1;;;::::0;::::1;;76342:11;76354:1;76342:14;;;;;;;;:::i;:::-;;;;;;;76325:16;;:31;;;;:::i;:::-;76308:49;::::0;:13;:49:::1;:::i;:::-;76393:1;76370:20;::::0;::::1;:24:::0;76292:65;-1:-1:-1;76209:197:0::1;76420:11;76432:1;76420:14;;;;;;;;:::i;:::-;;;;;;;76438:1;76420:19:::0;76416:201:::1;;76461:22;::::0;::::1;::::0;:27;76452:37:::1;;;::::0;::::1;;76551:11;76563:1;76551:14;;;;;;;;:::i;:::-;;;;;;;76534:16;;:31;;;;:::i;:::-;76517:49;::::0;:13;:49:::1;:::i;:::-;76604:1;76579:22;::::0;::::1;:26:::0;76501:65;-1:-1:-1;76416:201:0::1;76631:11;76643:1;76631:14;;;;;;;;:::i;:::-;;;;;;;76649:1;76631:19:::0;76627:199:::1;;76672:21;::::0;::::1;::::0;:26;76663:36:::1;;;::::0;::::1;;76761:11;76773:1;76761:14;;;;;;;;:::i;:::-;;;;;;;76744:16;;:31;;;;:::i;:::-;76727:49;::::0;:13;:49:::1;:::i;:::-;76813:1;76789:21;::::0;::::1;:25:::0;76711:65;-1:-1:-1;76627:199:0::1;76840:11;76852:1;76840:14;;;;;;;;:::i;:::-;;;;;;;76858:1;76840:19:::0;76836:192:::1;;76881:18;::::0;::::1;::::0;:23;76872:33:::1;;;::::0;::::1;;76967:11;76979:1;76967:14;;;;;;;;:::i;:::-;;;;;;;76950:16;;:31;;;;:::i;:::-;76933:49;::::0;:13;:49:::1;:::i;:::-;77015:1;76994:18;::::0;::::1;:22:::0;76917:65;-1:-1:-1;76836:192:0::1;75981:3:::0;::::1;::::0;::::1;:::i;:::-;;;;75947:1089;;;-1:-1:-1::0;77051:3:0::1;::::0;;:25:::1;::::0;-1:-1:-1;;;77051:25:0;;77065:10:::1;77051:25:::0;;::::1;1751:51:1::0;;;;77080:13:0;;-1:-1:-1;;;;;77051:3:0;;::::1;::::0;:13:::1;::::0;1724:18:1;;77051:25:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:42;;77043:76;;;::::0;-1:-1:-1;;;77043:76:0;;10181:2:1;77043:76:0::1;::::0;::::1;10163:21:1::0;10220:2;10200:18;;;10193:30;-1:-1:-1;;;10239:18:1;;;10232:51;10300:18;;77043:76:0::1;9979:345:1::0;77043:76:0::1;77159:11;::::0;77127:3:::1;::::0;:59:::1;::::0;-1:-1:-1;;;;;77127:3:0;;::::1;::::0;77148:10:::1;::::0;77159:11:::1;77172:13:::0;77127:20:::1;:59::i;:::-;-1:-1:-1::0;;18190:1:0;19144:22;;-1:-1:-1;75722:1471:0:o;80903:532::-;80997:10;80947:7;80989:19;;;:7;:19;;;;;81086:10;;81062:21;;80947:7;;81086:10;81038:45;;:21;:45;:::i;:::-;:58;;;;:::i;:::-;81017:79;;81105:29;81164:1;81146:17;;:19;:42;;;;-1:-1:-1;81169:11:0;;;;:19;;:11;:19;81146:42;81143:150;;;81265:17;;81254:28;;:10;:28;:::i;:::-;81224:26;;:59;;;;:::i;:::-;81200:83;;81143:150;81301:24;81374:6;:17;;;81349:21;81329:6;:19;;;:41;;;;:::i;:::-;81328:63;;;;:::i;:::-;81301:90;80903:532;-1:-1:-1;;;;;80903:532:0:o;73581:1968::-;18234:1;18832:7;;:19;18824:63;;;;-1:-1:-1;;;18824:63:0;;;;;;;:::i;:::-;18234:1;18965:7;:18;-1:-1:-1;;;;;73694:16:0;::::1;73670:21;73694:16:::0;;;:7:::1;:16;::::0;;;;;73732:78:::1;73747:6;:13;73745:1;:15;73732:78;;;73796:1;73786:6;73793:1;73786:9;;;;;;;;:::i;:::-;;;;;;;:11;73777:21;;;::::0;::::1;;73761:3:::0;::::1;::::0;::::1;:::i;:::-;;;;73732:78;;;;73822:14;:12;:14::i;:::-;73857:26;73900:6;:13;73886:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;73886:28:0::1;-1:-1:-1::0;73857:57:0;-1:-1:-1;73925:27:0::1;::::0;73973:716:::1;73988:6;:13;73986:1;:15;73973:716;;;-1:-1:-1::0;;;;;74026:18:0;::::1;74056:1;74026:18:::0;;;:9:::1;:18;::::0;;;;74045:9;;74056:1;;74045:6;;74052:1;;74045:9;::::1;;;;;:::i;:::-;;;;;;;74026:29;;;;;;;;;;;;:31;74017:68;;;::::0;-1:-1:-1;;;74017:68:0;;10753:2:1;74017:68:0::1;::::0;::::1;10735:21:1::0;10792:2;10772:18;;;10765:30;10831:25;10811:18;;;10804:53;10874:18;;74017:68:0::1;10551:347:1::0;74017:68:0::1;-1:-1:-1::0;;;;;74097:18:0;::::1;74129:1;74097:18:::0;;;:9:::1;:18;::::0;;;;74116:9;;74129:1;;74116:6;;74123:1;;74116:9;::::1;;;;;:::i;:::-;;;;;;;74097:29;;;;;;;;;;;:33;;;;74159:1;74144:9;74154:1;74144:12;;;;;;;;:::i;:::-;;;;;;:16;;;::::0;::::1;74174:6;74181:1;74174:9;;;;;;;;:::i;:::-;;;;;;;74187:1;74174:14;:502;;74276:6;74283:1;74276:9;;;;;;;;:::i;:::-;;;;;;;74289:1;74276:14;:400;;74378:6;74385:1;74378:9;;;;;;;;:::i;:::-;;;;;;;74391:1;74378:14;:298;;74482:6;74489:1;74482:9;;;;;;;;:::i;:::-;;;;;;;74495:1;74482:14;:194;;74586:6;74593:1;74586:9;;;;;;;;:::i;:::-;;;;;;;74599:1;74586:14;:90;;74675:1;74174:502;;74586:90;74648:18;::::0;::::1;::::0;:23:::1;::::0;74667:4:::1;74648:23;:::i;:::-;74625:47;::::0;:19;:47:::1;:::i;:::-;74603:69;;;74174:502;;74482:194;74544:21;::::0;::::1;::::0;:26:::1;::::0;74566:4:::1;74544:26;:::i;74378:298::-;74440:22;::::0;::::1;::::0;:26:::1;::::0;74463:3:::1;74440:26;:::i;74276:400::-;74338:20;::::0;::::1;::::0;:24:::1;::::0;74359:3:::1;74338:24;:::i;74174:502::-;74236:20;::::0;::::1;::::0;:24:::1;::::0;74257:3:::1;74236:24;:::i;:::-;74213:48;::::0;:19;:48:::1;:::i;:::-;74191:70;;;74174:502;-1:-1:-1::0;74002:3:0;::::1;::::0;::::1;:::i;:::-;;;;73973:716;;;-1:-1:-1::0;74703:14:0::1;::::0;::::1;::::0;:18;74699:315:::1;;-1:-1:-1::0;;;;;74741:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;;;;:21;;;;;;;;;74765:1:::1;-1:-1:-1::0;74741:25:0;:54:::1;;-1:-1:-1::0;;;;;;74770:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;;;;74794:1:::1;74770:21:::0;;;;;;;;;:25:::1;74741:54;:83;;;-1:-1:-1::0;;;;;;74799:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;;;;74818:1:::1;74799:21:::0;;;;;;;;74823:1:::1;-1:-1:-1::0;74741:83:0::1;:112;;;-1:-1:-1::0;;;;;;74828:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;;;;74847:1:::1;74828:21:::0;;;;;;;;74852:1:::1;-1:-1:-1::0;74741:112:0::1;:141;;;-1:-1:-1::0;;;;;;74857:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;;;;74876:1:::1;74857:21:::0;;;;;;;;74881:1:::1;-1:-1:-1::0;74741:141:0::1;74737:266;;;74919:1;74902:14;::::0;::::1;:18:::0;74961:26:::1;:19:::0;74983:4:::1;74961:26;:::i;:::-;74939:48;;74737:266;75058:19:::0;;:41:::1;::::0;75080:19;;75058:41:::1;:::i;:::-;75036:63:::0;;75130:17:::1;::::0;:39:::1;::::0;75150:19;;75130:39:::1;:::i;:::-;75110:17;:59:::0;75232:13;;75211:18:::1;::::0;::::1;::::0;:34:::1;::::0;75232:13;75211:34:::1;:::i;:::-;75190:18;::::0;::::1;:55:::0;75290:13;;75273:14:::1;::::0;:30:::1;::::0;75290:13;75273:30:::1;:::i;:::-;75256:14;:47:::0;75364:26:::1;::::0;75344:19;;:46:::1;::::0;75364:26;75344:46:::1;:::i;:::-;75324:17;::::0;::::1;:66:::0;75417:6:::1;75413:130;75428:6;:13;75426:1;:15;75413:130;;;75458:11;::::0;75514:9;;-1:-1:-1;;;;;75458:11:0;;::::1;::::0;:28:::1;::::0;75495:4:::1;::::0;75502:10:::1;::::0;75514:6;;75521:1;;75514:9;::::1;;;;;:::i;:::-;;;;;;;75525:1;75458:73;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;75442:3;;;;;:::i;:::-;;;;75413:130;;;-1:-1:-1::0;;18190:1:0;19144:22;;-1:-1:-1;;;;73581:1968:0:o;81445:73::-;22859:7;22886:6;-1:-1:-1;;;;;22886:6:0;2149:10;23033:23;23025:68;;;;-1:-1:-1;;;23025:68:0;;;;;;;:::i;:::-;81493:11:::1;:18:::0;;-1:-1:-1;;81493:18:0::1;81507:4;81493:18;::::0;;81445:73::o;23464:103::-;22859:7;22886:6;-1:-1:-1;;;;;22886:6:0;2149:10;23033:23;23025:68;;;;-1:-1:-1;;;23025:68:0;;;;;;;:::i;:::-;23529:30:::1;23556:1;23529:18;:30::i;:::-;23464:103::o:0;70475:2464::-;18234:1;18832:7;;:19;18824:63;;;;-1:-1:-1;;;18824:63:0;;;;;;;:::i;:::-;18234:1;18965:7;:18;-1:-1:-1;;;;;70591:16:0;::::1;70567:21;70591:16:::0;;;:7:::1;:16;::::0;;;;;70620:142:::1;70635:6;:13;70633:1;:15;70620:142;;;70684:1;70674:6;70681:1;70674:9;;;;;;;;:::i;:::-;;;;;;;:11;70665:21;;;::::0;::::1;;70707:11;::::0;70737:9;;70748:1:::1;::::0;-1:-1:-1;;;;;70707:11:0::1;::::0;:21:::1;::::0;70729:7;;70737:6;;70744:1;;70737:9;::::1;;;;;:::i;:::-;;;;;;;70707:40;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;12096:32:1;;;;12078:51;;12160:2;12145:18;;12138:34;12066:2;12051:18;;11904:274;70707:40:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:42;70698:52;;;::::0;::::1;;70649:3:::0;::::1;::::0;::::1;:::i;:::-;;;;70620:142;;;;70774:14;:12;:14::i;:::-;70811:26;70854:6;:13;70840:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;70840:28:0::1;-1:-1:-1::0;70811:57:0;-1:-1:-1;70879:25:0::1;::::0;70915:1110:::1;70930:6;:13;70928:1;:15;70915:1110;;;-1:-1:-1::0;;;;;70971:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;70990:9;;71001:1:::1;::::0;70971:18;70990:6;;70997:1;;70990:9;::::1;;;;;:::i;:::-;;;;;;;70971:29;;;;;;;;;;;;:31;70962:69;;;::::0;-1:-1:-1;;;70962:69:0;;12385:2:1;70962:69:0::1;::::0;::::1;12367:21:1::0;12424:2;12404:18;;;12397:30;12463:26;12443:18;;;12436:54;12507:18;;70962:69:0::1;12183:348:1::0;70962:69:0::1;-1:-1:-1::0;;;;;71049:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;71068:9;;71081:1:::1;::::0;71049:18;71068:6;;71075:1;;71068:9;::::1;;;;;:::i;:::-;;;;;;;71049:29;;;;;;;;;;;:33;;;;71111:1;71096:9;71106:1;71096:12;;;;;;;;:::i;:::-;;;;;;:16;;;::::0;::::1;71129:6;71136:1;71129:9;;;;;;;;:::i;:::-;;;;;;;71142:1;71129:14:::0;71126:166:::1;;71191:1;71170:6;:20;;;:22;71162:31;;;::::0;::::1;;71252:20;::::0;::::1;::::0;:24:::1;::::0;71273:3:::1;71252:24;:::i;:::-;71231:46;::::0;:17;:46:::1;:::i;:::-;71211:66;;71126:166;71308:6;71315:1;71308:9;;;;;;;;:::i;:::-;;;;;;;71321:1;71308:14:::0;71305:166:::1;;71370:1;71349:6;:20;;;:22;71341:31;;;::::0;::::1;;71431:20;::::0;::::1;::::0;:24:::1;::::0;71452:3:::1;71431:24;:::i;:::-;71410:46;::::0;:17;:46:::1;:::i;:::-;71390:66;;71305:166;71487:6;71494:1;71487:9;;;;;;;;:::i;:::-;;;;;;;71500:1;71487:14:::0;71484:170:::1;;71551:1;71528:6;:22;;;:24;71520:33;;;::::0;::::1;;71612:22;::::0;::::1;::::0;:26:::1;::::0;71635:3:::1;71612:26;:::i;:::-;71591:48;::::0;:17;:48:::1;:::i;:::-;71571:68;;71484:170;71670:6;71677:1;71670:9;;;;;;;;:::i;:::-;;;;;;;71683:1;71670:14:::0;71667:169:::1;;71733:1;71711:6;:21;;;:23;71703:32;;;::::0;::::1;;71794:21;::::0;::::1;::::0;:26:::1;::::0;71816:4:::1;71794:26;:::i;:::-;71773:48;::::0;:17;:48:::1;:::i;:::-;71753:68;;71667:169;71852:6;71859:1;71852:9;;;;;;;;:::i;:::-;;;;;;;71865:1;71852:14:::0;71849:163:::1;;71912:1;71893:6;:18;;;:20;71885:29;;;::::0;::::1;;71973:18;::::0;::::1;::::0;:23:::1;::::0;71992:4:::1;71973:23;:::i;:::-;71952:45;::::0;:17;:45:::1;:::i;:::-;71932:65;;71849:163;70944:3:::0;::::1;::::0;::::1;:::i;:::-;;;;70915:1110;;;;72066:1;72049:6;:14;;;:18;72045:301;;;-1:-1:-1::0;;;;;72087:18:0;::::1;72109:1;72087:18:::0;;;:9:::1;:18;::::0;;;;;;;:21;;;;;;;;;:23;;;;:50:::1;;-1:-1:-1::0;;;;;;72114:18:0;::::1;72136:1;72114:18:::0;;;:9:::1;:18;::::0;;;;;;;72133:1:::1;72114:21:::0;;;;;;;;:23;;72087:50:::1;:77;;;;-1:-1:-1::0;;;;;;72141:18:0;::::1;72163:1;72141:18:::0;;;:9:::1;:18;::::0;;;;;;;72160:1:::1;72141:21:::0;;;;;;;;:23;;72087:77:::1;:104;;;;-1:-1:-1::0;;;;;;72168:18:0;::::1;72190:1;72168:18:::0;;;:9:::1;:18;::::0;;;;;;;72187:1:::1;72168:21:::0;;;;;;;;:23;;72087:104:::1;:131;;;;-1:-1:-1::0;;;;;;72195:18:0;::::1;72217:1;72195:18:::0;;;:9:::1;:18;::::0;;;;;;;72214:1:::1;72195:21:::0;;;;;;;;:23;;72087:131:::1;72083:252;;;72255:1;72238:14;::::0;::::1;:18:::0;72295:24:::1;:17:::0;72315:4:::1;72295:24;:::i;:::-;72275:44;;72083:252;72363:6;72359:130;72374:6;:13;72372:1;:15;72359:130;;;72404:11;::::0;72460:9;;-1:-1:-1;;;;;72404:11:0;;::::1;::::0;:28:::1;::::0;72433:10:::1;::::0;72453:4:::1;::::0;72460:6;;72467:1;;72460:9;::::1;;;;;:::i;:::-;;;;;;;72471:1;72404:73;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;72388:3;;;;;:::i;:::-;;;;72359:130;;;-1:-1:-1::0;72537:19:0;;72509:25:::1;::::0;72537:39:::1;::::0;72559:17;;72537:39:::1;:::i;:::-;72509:67;;72630:26;;72609:20;:47;;;;:::i;:::-;72589:17;::::0;::::1;:67:::0;72673:42;;;72746:17:::1;::::0;:37:::1;::::0;72766:17;;72746:37:::1;:::i;:::-;72726:17;:57:::0;72838:13;;72817:18:::1;::::0;::::1;::::0;:34:::1;::::0;72838:13;72817:34:::1;:::i;:::-;72796:18;::::0;::::1;:55:::0;72896:13;;72879:14:::1;::::0;:30:::1;::::0;72896:13;72879:30:::1;:::i;:::-;72862:14;:47:::0;-1:-1:-1;;18190:1:0;19144:22;;-1:-1:-1;;;;70475:2464:0:o;75556:130::-;22859:7;22886:6;-1:-1:-1;;;;;22886:6:0;2149:10;23033:23;23025:68;;;;-1:-1:-1;;;23025:68:0;;;;;;;:::i;:::-;75641:16:::1;:38:::0;75556:130::o;23722:201::-;22859:7;22886:6;-1:-1:-1;;;;;22886:6:0;2149:10;23033:23;23025:68;;;;-1:-1:-1;;;23025:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;23811:22:0;::::1;23803:73;;;::::0;-1:-1:-1;;;23803:73:0;;12738:2:1;23803:73:0::1;::::0;::::1;12720:21:1::0;12777:2;12757:18;;;12750:30;12816:34;12796:18;;;12789:62;-1:-1:-1;;;12867:18:1;;;12860:36;12913:19;;23803:73:0::1;12536:402:1::0;23803:73:0::1;23887:28;23906:8;23887:18;:28::i;:::-;23722:201:::0;:::o;77247:2919::-;18234:1;18832:7;;:19;18824:63;;;;-1:-1:-1;;;18824:63:0;;;;;;;:::i;:::-;18234:1;18965:7;:18;77404:10:::1;77372:21;77396:19:::0;;;:7:::1;:19;::::0;;;;77427:14:::1;:12;:14::i;:::-;77461:17;77488:22:::0;77525:6:::1;77520:2235;77536:11;:18;77534:1;:20;77520:2235;;;77573:11;77585:1;77573:14;;;;;;;;:::i;:::-;;;;;;;77591:1;77573:19:::0;77569:426:::1;;77636:1;77615:6;:20;;;:22;77607:48;;;;-1:-1:-1::0;;;77607:48:0::1;;;;;;;:::i;:::-;77717:1;77699:10;77710:1;77699:13;;;;;;;;:::i;:::-;;;;;;;77678:6;:20;;;:34;;;;:::i;:::-;77677:41;;77669:50;;;::::0;::::1;;77766:10;77777:1;77766:13;;;;;;;;:::i;:::-;;;;;;;77763:2;:16;;;;:::i;:::-;77748:31;::::0;:12;:31:::1;:::i;:::-;77807:10;77822:1;77797:21:::0;;;:9:::1;:21;::::0;;;;;;;:24;;;;;;;;;77733:46;;-1:-1:-1;77797:26:0;77793:119:::1;;77883:10;77894:1;77883:13;;;;;;;;:::i;:::-;;;;;;;77879:3;:17;;;;:::i;:::-;77858:39;::::0;:17;:39:::1;:::i;:::-;77838:59;;77793:119;77971:10;77982:1;77971:13;;;;;;;;:::i;:::-;;;;;;;77948:6;:20;;;:36;;;;:::i;:::-;77925:20;::::0;::::1;:59:::0;77569:426:::1;78008:11;78020:1;78008:14;;;;;;;;:::i;:::-;;;;;;;78026:1;78008:19:::0;78004:426:::1;;78071:1;78050:6;:20;;;:22;78042:48;;;;-1:-1:-1::0;;;78042:48:0::1;;;;;;;:::i;:::-;78152:1;78134:10;78145:1;78134:13;;;;;;;;:::i;:::-;;;;;;;78113:6;:20;;;:34;;;;:::i;:::-;78112:41;;78104:50;;;::::0;::::1;;78201:10;78212:1;78201:13;;;;;;;;:::i;:::-;;;;;;;78198:2;:16;;;;:::i;:::-;78183:31;::::0;:12;:31:::1;:::i;:::-;78242:10;78257:1;78232:21:::0;;;:9:::1;:21;::::0;;;;;;;78254:1:::1;78232:24:::0;;;;;;;;78168:46;;-1:-1:-1;78232:26:0;78228:120:::1;;78319:10;78330:1;78319:13;;;;;;;;:::i;:::-;;;;;;;78315:3;:17;;;;:::i;:::-;78294:39;::::0;:17;:39:::1;:::i;:::-;78274:59;;78228:120;78406:10;78417:1;78406:13;;;;;;;;:::i;:::-;;;;;;;78383:6;:20;;;:36;;;;:::i;:::-;78360:20;::::0;::::1;:59:::0;78004:426:::1;78443:11;78455:1;78443:14;;;;;;;;:::i;:::-;;;;;;;78461:1;78443:19:::0;78439:438:::1;;78508:1;78485:6;:22;;;:24;78477:50;;;;-1:-1:-1::0;;;78477:50:0::1;;;;;;;:::i;:::-;78591:1;78573:10;78584:1;78573:13;;;;;;;;:::i;:::-;;;;;;;78550:6;:22;;;:36;;;;:::i;:::-;78549:43;;78541:52;;;::::0;::::1;;78640:10;78651:1;78640:13;;;;;;;;:::i;:::-;;;;;;;78637:2;:16;;;;:::i;:::-;78622:31;::::0;:12;:31:::1;:::i;:::-;78681:10;78696:1;78671:21:::0;;;:9:::1;:21;::::0;;;;;;;78693:1:::1;78671:24:::0;;;;;;;;78607:46;;-1:-1:-1;78671:26:0;78667:121:::1;;78759:10;78770:1;78759:13;;;;;;;;:::i;:::-;;;;;;;78755:3;:17;;;;:::i;:::-;78734:39;::::0;:17;:39:::1;:::i;:::-;78714:59;;78667:121;78853:10;78864:1;78853:13;;;;;;;;:::i;:::-;;;;;;;78828:6;:22;;;:38;;;;:::i;:::-;78803:22;::::0;::::1;:63:::0;78439:438:::1;78890:11;78902:1;78890:14;;;;;;;;:::i;:::-;;;;;;;78908:1;78890:19:::0;78886:437:::1;;78954:1;78932:6;:21;;;:23;78924:49;;;;-1:-1:-1::0;;;78924:49:0::1;;;;;;;:::i;:::-;79036:1;79018:10;79029:1;79018:13;;;;;;;;:::i;:::-;;;;;;;78996:6;:21;;;:35;;;;:::i;:::-;78995:42;;78987:51;;;::::0;::::1;;79086:10;79097:1;79086:13;;;;;;;;:::i;:::-;;;;;;;79082:3;:17;;;;:::i;:::-;79067:32;::::0;:12;:32:::1;:::i;:::-;79127:10;79142:1;79117:21:::0;;;:9:::1;:21;::::0;;;;;;;79139:1:::1;79117:24:::0;;;;;;;;79052:47;;-1:-1:-1;79117:26:0;79113:122:::1;;79206:10;79217:1;79206:13;;;;;;;;:::i;:::-;;;;;;;79201:4;:18;;;;:::i;:::-;79180:40;::::0;:17;:40:::1;:::i;:::-;79160:60;;79113:122;79299:10;79310:1;79299:13;;;;;;;;:::i;:::-;;;;;;;79275:6;:21;;;:37;;;;:::i;:::-;79251:21;::::0;::::1;:61:::0;78886:437:::1;79336:11;79348:1;79336:14;;;;;;;;:::i;:::-;;;;;;;79354:1;79336:19:::0;79332:416:::1;;79397:1;79378:6;:18;;;:20;79370:46;;;;-1:-1:-1::0;;;79370:46:0::1;;;;;;;:::i;:::-;79476:1;79458:10;79469:1;79458:13;;;;;;;;:::i;:::-;;;;;;;79439:6;:18;;;:32;;;;:::i;:::-;79438:39;;79430:48;;;::::0;::::1;;79526:10;79537:1;79526:13;;;;;;;;:::i;:::-;;;;;;;79522:3;:17;;;;:::i;:::-;79507:32;::::0;:12;:32:::1;:::i;:::-;79567:10;79582:1;79557:21:::0;;;:9:::1;:21;::::0;;;;;;;79579:1:::1;79557:24:::0;;;;;;;;79492:47;;-1:-1:-1;79557:26:0;79553:117:::1;;79644:10;79655:1;79644:13;;;;;;;;:::i;:::-;;;;;;;79639:4;:18;;;;:::i;:::-;79618:40;::::0;:17;:40:::1;:::i;:::-;79598:60;;79553:117;79724:10;79735:1;79724:13;;;;;;;;:::i;:::-;;;;;;;79703:6;:18;;;:34;;;;:::i;:::-;79682:18;::::0;::::1;:55:::0;79332:416:::1;77555:3:::0;::::1;::::0;::::1;:::i;:::-;;;;77520:2235;;;-1:-1:-1::0;79772:11:0::1;::::0;:35:::1;::::0;-1:-1:-1;;;79772:35:0;;79794:10:::1;79772:35;::::0;::::1;12078:51:1::0;79805:1:0::1;12145:18:1::0;;;12138:34;79809:12:0;;-1:-1:-1;;;;;79772:11:0::1;::::0;:21:::1;::::0;12051:18:1;;79772:35:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;;79763:59;;;::::0;::::1;;79831:12;::::0;:44:::1;::::0;-1:-1:-1;;;79831:44:0;;79849:10:::1;79831:44;::::0;::::1;13783:51:1::0;79860:1:0::1;13850:18:1::0;;;13843:34;13893:18;;;13886:34;;;-1:-1:-1;;;;;79831:12:0;;::::1;::::0;:17:::1;::::0;13756:18:1;;79831:44:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;79916:19:0;;79888:25:::1;::::0;-1:-1:-1;79916:39:0::1;::::0;-1:-1:-1;79938:17:0;;79916:39:::1;:::i;:::-;79888:67;;80005:26;;79984:20;:47;;;;:::i;:::-;79964:17;::::0;::::1;:67:::0;80044:42;;;80113:17:::1;::::0;:37:::1;::::0;80133:17;;80113:37:::1;:::i;:::-;80093:17;:57:::0;-1:-1:-1;;18190:1:0;19144:22;;-1:-1:-1;;;;77247:2919:0:o;81593:382::-;81663:1;81646:14;;:18;:42;;;-1:-1:-1;81668:11:0;;;;:20;81646:42;81642:84;;;81593:382::o;81642:84::-;81737:18;81806:10;;81782:21;;81758;:45;;;;:::i;:::-;:58;;;;:::i;:::-;81737:79;;81898:17;;81887:10;:28;;;;:::i;:::-;81857:26;;:59;;;;:::i;:::-;81828:26;:88;81941:10;;:23;;81954:10;;81941:23;:::i;:::-;81928:10;:36;-1:-1:-1;81593:382:0:o;25026:248::-;25197:68;;;-1:-1:-1;;;;;14189:15:1;;;25197:68:0;;;14171:34:1;14241:15;;14221:18;;;14214:43;14273:18;;;;14266:34;;;25197:68:0;;;;;;;;;;14106:18:1;;;;25197:68:0;;;;;;;;-1:-1:-1;;;;;25197:68:0;-1:-1:-1;;;25197:68:0;;;25170:96;;25190:5;;25170:19;:96::i;:::-;25026:248;;;;:::o;24083:191::-;24157:16;24176:6;;-1:-1:-1;;;;;24193:17:0;;;-1:-1:-1;;;;;;24193:17:0;;;;;;24226:40;;24176:6;;;;;;;24226:40;;24157:16;24226:40;24146:128;24083:191;:::o;27380:716::-;27804:23;27830:69;27858:4;27830:69;;;;;;;;;;;;;;;;;27838:5;-1:-1:-1;;;;;27830:27:0;;;:69;;;;;:::i;:::-;27914:17;;27804:95;;-1:-1:-1;27914:21:0;27910:179;;28011:10;28000:30;;;;;;;;;;;;:::i;:::-;27992:85;;;;-1:-1:-1;;;27992:85:0;;14795:2:1;27992:85:0;;;14777:21:1;14834:2;14814:18;;;14807:30;14873:34;14853:18;;;14846:62;-1:-1:-1;;;14924:18:1;;;14917:40;14974:19;;27992:85:0;14593:406:1;6107:229:0;6244:12;6276:52;6298:6;6306:4;6312:1;6315:12;6276:21;:52::i;:::-;6269:59;;6107:229;;;;;;:::o;7227:510::-;7397:12;7455:5;7430:21;:30;;7422:81;;;;-1:-1:-1;;;7422:81:0;;15206:2:1;7422:81:0;;;15188:21:1;15245:2;15225:18;;;15218:30;15284:34;15264:18;;;15257:62;-1:-1:-1;;;15335:18:1;;;15328:36;15381:19;;7422:81:0;15004:402:1;7422:81:0;-1:-1:-1;;;;;3657:19:0;;;7514:60;;;;-1:-1:-1;;;7514:60:0;;15613:2:1;7514:60:0;;;15595:21:1;15652:2;15632:18;;;15625:30;15691:31;15671:18;;;15664:59;15740:18;;7514:60:0;15411:353:1;7514:60:0;7588:12;7602:23;7629:6;-1:-1:-1;;;;;7629:11:0;7648:5;7655:4;7629:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7587:73;;;;7678:51;7695:7;7704:10;7716:12;7678:16;:51::i;:::-;7671:58;7227:510;-1:-1:-1;;;;;;;7227:510:0:o;9913:712::-;10063:12;10092:7;10088:530;;;-1:-1:-1;10123:10:0;10116:17;;10088:530;10237:17;;:21;10233:374;;10435:10;10429:17;10496:15;10483:10;10479:2;10475:19;10468:44;10233:374;10578:12;10571:20;;-1:-1:-1;;;10571:20:0;;;;;;;;:::i;196:127:1:-;257:10;252:3;248:20;245:1;238:31;288:4;285:1;278:15;312:4;309:1;302:15;328:902;382:5;435:3;428:4;420:6;416:17;412:27;402:55;;453:1;450;443:12;402:55;489:6;476:20;515:4;538:18;575:2;571;568:10;565:36;;;581:18;;:::i;:::-;627:2;624:1;620:10;659:2;653:9;722:2;718:7;713:2;709;705:11;701:25;693:6;689:38;777:6;765:10;762:22;757:2;745:10;742:18;739:46;736:72;;;788:18;;:::i;:::-;824:2;817:22;874:18;;;950:15;;;946:24;;;908:15;;;;-1:-1:-1;982:15:1;;;979:35;;;1010:1;1007;1000:12;979:35;1046:2;1038:6;1034:15;1023:26;;1058:142;1074:6;1069:3;1066:15;1058:142;;;1140:17;;1128:30;;1178:12;;;;1091;;;;1058:142;;1235:348;1319:6;1372:2;1360:9;1351:7;1347:23;1343:32;1340:52;;;1388:1;1385;1378:12;1340:52;1428:9;1415:23;1461:18;1453:6;1450:30;1447:50;;;1493:1;1490;1483:12;1447:50;1516:61;1569:7;1560:6;1549:9;1545:22;1516:61;:::i;:::-;1506:71;1235:348;-1:-1:-1;;;;1235:348:1:o;2005:173::-;2073:20;;-1:-1:-1;;;;;2122:31:1;;2112:42;;2102:70;;2168:1;2165;2158:12;2102:70;2005:173;;;:::o;2183:422::-;2276:6;2284;2337:2;2325:9;2316:7;2312:23;2308:32;2305:52;;;2353:1;2350;2343:12;2305:52;2376:29;2395:9;2376:29;:::i;:::-;2366:39;;2456:2;2445:9;2441:18;2428:32;2483:18;2475:6;2472:30;2469:50;;;2515:1;2512;2505:12;2469:50;2538:61;2591:7;2582:6;2571:9;2567:22;2538:61;:::i;:::-;2528:71;;;2183:422;;;;;:::o;3272:254::-;3340:6;3348;3401:2;3389:9;3380:7;3376:23;3372:32;3369:52;;;3417:1;3414;3407:12;3369:52;3440:29;3459:9;3440:29;:::i;:::-;3430:39;3516:2;3501:18;;;;3488:32;;-1:-1:-1;;;3272:254:1:o;3531:367::-;3594:8;3604:6;3658:3;3651:4;3643:6;3639:17;3635:27;3625:55;;3676:1;3673;3666:12;3625:55;-1:-1:-1;3699:20:1;;3742:18;3731:30;;3728:50;;;3774:1;3771;3764:12;3728:50;3811:4;3803:6;3799:17;3787:29;;3871:3;3864:4;3854:6;3851:1;3847:14;3839:6;3835:27;3831:38;3828:47;3825:67;;;3888:1;3885;3878:12;3825:67;3531:367;;;;;:::o;3903:347::-;3954:8;3964:6;4018:3;4011:4;4003:6;3999:17;3995:27;3985:55;;4036:1;4033;4026:12;3985:55;-1:-1:-1;4059:20:1;;4102:18;4091:30;;4088:50;;;4134:1;4131;4124:12;4088:50;4171:4;4163:6;4159:17;4147:29;;4223:3;4216:4;4207:6;4199;4195:19;4191:30;4188:39;4185:59;;;4240:1;4237;4230:12;4255:1210;4415:6;4423;4431;4439;4447;4455;4463;4471;4524:3;4512:9;4503:7;4499:23;4495:33;4492:53;;;4541:1;4538;4531:12;4492:53;4564:29;4583:9;4564:29;:::i;:::-;4554:39;;4612:38;4646:2;4635:9;4631:18;4612:38;:::i;:::-;4602:48;;4701:2;4690:9;4686:18;4673:32;4724:18;4765:2;4757:6;4754:14;4751:34;;;4781:1;4778;4771:12;4751:34;4820:70;4882:7;4873:6;4862:9;4858:22;4820:70;:::i;:::-;4909:8;;-1:-1:-1;4794:96:1;-1:-1:-1;4997:2:1;4982:18;;4969:32;;-1:-1:-1;5013:16:1;;;5010:36;;;5042:1;5039;5032:12;5010:36;5081:72;5145:7;5134:8;5123:9;5119:24;5081:72;:::i;:::-;5172:8;;-1:-1:-1;5055:98:1;-1:-1:-1;5260:3:1;5245:19;;5232:33;;-1:-1:-1;5277:16:1;;;5274:36;;;5306:1;5303;5296:12;5274:36;;5345:60;5397:7;5386:8;5375:9;5371:24;5345:60;:::i;:::-;4255:1210;;;;-1:-1:-1;4255:1210:1;;-1:-1:-1;4255:1210:1;;;;;;5424:8;-1:-1:-1;;;4255:1210:1:o;5677:180::-;5736:6;5789:2;5777:9;5768:7;5764:23;5760:32;5757:52;;;5805:1;5802;5795:12;5757:52;-1:-1:-1;5828:23:1;;5677:180;-1:-1:-1;5677:180:1:o;5862:186::-;5921:6;5974:2;5962:9;5953:7;5949:23;5945:32;5942:52;;;5990:1;5987;5980:12;5942:52;6013:29;6032:9;6013:29;:::i;6955:695::-;7061:6;7069;7077;7085;7093;7101;7154:3;7142:9;7133:7;7129:23;7125:33;7122:53;;;7171:1;7168;7161:12;7122:53;7194:29;7213:9;7194:29;:::i;:::-;7184:39;;7242:38;7276:2;7265:9;7261:18;7242:38;:::i;:::-;7232:48;;7327:2;7316:9;7312:18;7299:32;7289:42;;7378:2;7367:9;7363:18;7350:32;7340:42;;7433:3;7422:9;7418:19;7405:33;7461:18;7453:6;7450:30;7447:50;;;7493:1;7490;7483:12;7447:50;7532:58;7582:7;7573:6;7562:9;7558:22;7532:58;:::i;:::-;6955:695;;;;-1:-1:-1;6955:695:1;;-1:-1:-1;6955:695:1;;7609:8;;6955:695;-1:-1:-1;;;6955:695:1:o;7655:595::-;7773:6;7781;7834:2;7822:9;7813:7;7809:23;7805:32;7802:52;;;7850:1;7847;7840:12;7802:52;7890:9;7877:23;7919:18;7960:2;7952:6;7949:14;7946:34;;;7976:1;7973;7966:12;7946:34;7999:61;8052:7;8043:6;8032:9;8028:22;7999:61;:::i;:::-;7989:71;;8113:2;8102:9;8098:18;8085:32;8069:48;;8142:2;8132:8;8129:16;8126:36;;;8158:1;8155;8148:12;8126:36;;8181:63;8236:7;8225:8;8214:9;8210:24;8181:63;:::i;8255:127::-;8316:10;8311:3;8307:20;8304:1;8297:31;8347:4;8344:1;8337:15;8371:4;8368:1;8361:15;8387:168;8460:9;;;8491;;8508:15;;;8502:22;;8488:37;8478:71;;8529:18;;:::i;:::-;8387:168;;;;:::o;8560:128::-;8627:9;;;8648:11;;;8645:37;;;8662:18;;:::i;8693:125::-;8758:9;;;8779:10;;;8776:36;;;8792:18;;:::i;8823:355::-;9025:2;9007:21;;;9064:2;9044:18;;;9037:30;9103:33;9098:2;9083:18;;9076:61;9169:2;9154:18;;8823:355::o;9518:127::-;9579:10;9574:3;9570:20;9567:1;9560:31;9610:4;9607:1;9600:15;9634:4;9631:1;9624:15;9650:135;9689:3;9710:17;;;9707:43;;9730:18;;:::i;:::-;-1:-1:-1;9777:1:1;9766:13;;9650:135::o;9790:184::-;9860:6;9913:2;9901:9;9892:7;9888:23;9884:32;9881:52;;;9929:1;9926;9919:12;9881:52;-1:-1:-1;9952:16:1;;9790:184;-1:-1:-1;9790:184:1:o;10329:217::-;10369:1;10395;10385:132;;10439:10;10434:3;10430:20;10427:1;10420:31;10474:4;10471:1;10464:15;10502:4;10499:1;10492:15;10385:132;-1:-1:-1;10531:9:1;;10329:217::o;10903:635::-;-1:-1:-1;;;;;11262:15:1;;;11244:34;;11314:15;;;;11309:2;11294:18;;11287:43;11361:2;11346:18;;11339:34;11404:2;11389:18;;11382:34;;;;11224:3;11447;11432:19;;11425:32;;;11187:4;11473:19;;;11466:30;11528:3;11513:19;;10903:635::o;11543:356::-;11745:2;11727:21;;;11764:18;;;11757:30;11823:34;11818:2;11803:18;;11796:62;11890:2;11875:18;;11543:356::o;12943:338::-;13145:2;13127:21;;;13184:2;13164:18;;;13157:30;-1:-1:-1;;;13218:2:1;13203:18;;13196:44;13272:2;13257:18;;12943:338::o;14311:277::-;14378:6;14431:2;14419:9;14410:7;14406:23;14402:32;14399:52;;;14447:1;14444;14437:12;14399:52;14479:9;14473:16;14532:5;14525:13;14518:21;14511:5;14508:32;14498:60;;14554:1;14551;14544:12;15769:250;15854:1;15864:113;15878:6;15875:1;15872:13;15864:113;;;15954:11;;;15948:18;15935:11;;;15928:39;15900:2;15893:10;15864:113;;;-1:-1:-1;;16011:1:1;15993:16;;15986:27;15769:250::o;16024:287::-;16153:3;16191:6;16185:13;16207:66;16266:6;16261:3;16254:4;16246:6;16242:17;16207:66;:::i;:::-;16289:16;;;;;16024:287;-1:-1:-1;;16024:287:1:o;16316:396::-;16465:2;16454:9;16447:21;16428:4;16497:6;16491:13;16540:6;16535:2;16524:9;16520:18;16513:34;16556:79;16628:6;16623:2;16612:9;16608:18;16603:2;16595:6;16591:15;16556:79;:::i;:::-;16696:2;16675:15;-1:-1:-1;;16671:29:1;16656:45;;;;16703:2;16652:54;;16316:396;-1:-1:-1;;16316:396:1:o

ipfs://cce348791211654ebe958b9867f91d87bb883214a23840a025ccd696a31da779