Contract 0x408b2096f84f1a76e1E4Bc2b44971e87114210A7 2

/**
 *Submitted for verification at polygonscan.com on 2022-03-15
*/

// Sources flattened with hardhat v2.6.0 https://hardhat.org

// File contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.6 <0.8.0;

/**
 * @title ERC20 Token Standard, basic interface.
 * @dev See https://eips.ethereum.org/EIPS/eip-20
 * @dev Note: The ERC-165 identifier for this interface is 0x36372b07.
 */
interface IERC20 {
    /**
     * @dev Emitted when tokens are transferred, including zero value transfers.
     * @param _from The account where the transferred tokens are withdrawn from.
     * @param _to The account where the transferred tokens are deposited to.
     * @param _value The amount of tokens being transferred.
     */
    event Transfer(address indexed _from, address indexed _to, uint256 _value);

    /**
     * @dev Emitted when a successful call to {IERC20-approve(address,uint256)} is made.
     * @param _owner The account granting an allowance to `_spender`.
     * @param _spender The account being granted an allowance from `_owner`.
     * @param _value The allowance amount being granted.
     */
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);

    /**
     * @notice Returns the total token supply.
     * @return The total token supply.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @notice Returns the account balance of another account with address `owner`.
     * @param owner The account whose balance will be returned.
     * @return The account balance of another account with address `owner`.
     */
    function balanceOf(address owner) external view returns (uint256);

    /**
     * Transfers `value` amount of tokens to address `to`.
     * @dev Reverts if `to` is the zero address.
     * @dev Reverts if the sender does not have enough balance.
     * @dev Emits an {IERC20-Transfer} event.
     * @dev Transfers of 0 values are treated as normal transfers and fire the {IERC20-Transfer} event.
     * @param to The receiver account.
     * @param value The amount of tokens to transfer.
     * @return True if the transfer succeeds, false otherwise.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @notice Transfers `value` amount of tokens from address `from` to address `to`.
     * @dev Reverts if `to` is the zero address.
     * @dev Reverts if `from` does not have at least `value` of balance.
     * @dev Reverts if the sender is not `from` and has not been approved by `from` for at least `value`.
     * @dev Emits an {IERC20-Transfer} event.
     * @dev Transfers of 0 values are treated as normal transfers and fire the {IERC20-Transfer} event.
     * @param from The emitter account.
     * @param to The receiver account.
     * @param value The amount of tokens to transfer.
     * @return True if the transfer succeeds, false otherwise.
     */
    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    /**
     * Sets `value` as the allowance from the caller to `spender`.
     *  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
     * @dev Reverts if `spender` is the zero address.
     * @dev Emits the {IERC20-Approval} event.
     * @param spender The account being granted the allowance by the message caller.
     * @param value The allowance amount to grant.
     * @return True if the approval succeeds, false otherwise.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * Returns the amount which `spender` is allowed to spend on behalf of `owner`.
     * @param owner The account that has granted an allowance to `spender`.
     * @param spender The account that was granted an allowance by `owner`.
     * @return The amount which `spender` is allowed to spend on behalf of `owner`.
     */
    function allowance(address owner, address spender) external view returns (uint256);
}


// File contracts/math/SafeMath.sol



pragma solidity >=0.6.0 <=0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        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) {
        // 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) {
        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) {
        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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }
}


// File contracts/utils/Address.sol



pragma solidity >=0.6.2 <=0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.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");

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

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

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


// File contracts/token/ERC20/SafeERC20.sol



pragma solidity >=0.6.0 <=0.8.0;



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

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

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

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

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

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

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

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


// File contracts/introspection/IERC165.sol



pragma solidity >=0.7.6 <0.8.0;

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


// File contracts/token/ERC721/IERC721Receiver.sol



pragma solidity >=0.7.6 <0.8.0;

/**
 * @title ERC721 Non-Fungible Token Standard, Tokens Receiver.
 * Interface for any contract that wants to support safeTransfers from ERC721 asset contracts.
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 * @dev Note: The ERC-165 identifier for this interface is 0x150b7a02.
 */
interface IERC721Receiver {
    /**
     * Handles the receipt of an NFT.
     * @dev The ERC721 smart contract calls this function on the recipient
     *  after a {IERC721-safeTransferFrom}. This function MUST return the function selector,
     *  otherwise the caller will revert the transaction. The selector to be
     *  returned can be obtained as `this.onERC721Received.selector`. This
     *  function MAY throw to revert and reject the transfer.
     * @dev Note: the ERC721 contract address is always the message sender.
     * @param operator The address which called `safeTransferFrom` function
     * @param from The address which previously owned the token
     * @param tokenId The NFT identifier which is being transferred
     * @param data Additional data with no specified format
     * @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


// File contracts/token/ERC721/ERC721Receiver.sol



pragma solidity >=0.7.6 <0.8.0;


/**
 * @title ERC721 Safe Transfers Receiver Contract.
 * @dev The function `onERC721Received(address,address,uint256,bytes)` needs to be implemented by a child contract.
 */
abstract contract ERC721Receiver is IERC165, IERC721Receiver {
    bytes4 internal constant _ERC721_RECEIVED = type(IERC721Receiver).interfaceId;
    bytes4 internal constant _ERC721_REJECTED = 0xffffffff;

    //======================================================= ERC165 ========================================================//

    /// @inheritdoc IERC165
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId || interfaceId == type(IERC721Receiver).interfaceId;
    }
}


// File contracts/metatx/ManagedIdentity.sol



pragma solidity >=0.7.6 <0.8.0;

/*
 * 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.
 */
abstract contract ManagedIdentity {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(msg.sender);
    }

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


// File contracts/interfaces/IGBotInventory.sol



pragma solidity >=0.7.6 <0.8.0;

interface IGBotInventory {
    function mintGBot(address to, uint256 nftId, uint256 metadata, bytes memory data) external;
    function getMetadata(uint256 tokenId) external view returns (uint256 metadata);
    function upgradeGBot(uint256 tokenId, uint256 newMetadata) external;

    /**
     * Gets the balance of the specified address
     * @param owner address to query the balance of
     * @return balance uint256 representing the amount owned by the passed address
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * Gets the owner of the specified ID
     * @param tokenId uint256 ID to query the owner of
     * @return owner address currently marked as the owner of the given ID
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

        /**
     * Safely transfers the ownership of a given token ID to another address
     *
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     *
     * @dev Requires the msg sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;
}


// File contracts/utils/access/IERC173.sol



pragma solidity >=0.7.6 <0.8.0;

/**
 * @title ERC-173 Contract Ownership Standard
 * Note: the ERC-165 identifier for this interface is 0x7f5828d0
 */
interface IERC173 {
    /**
     * Event emited when ownership of a contract changes.
     * @param previousOwner the previous owner.
     * @param newOwner the new owner.
     */
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * Get the address of the owner
     * @return The address of the owner.
     */
    function owner() external view returns (address);

    /**
     * Set the address of the new owner of the contract
     * Set newOwner to address(0) to renounce any ownership.
     * @dev Emits an {OwnershipTransferred} event.
     * @param newOwner The address of the new owner of the contract. Using the zero address means renouncing ownership.
     */
    function transferOwnership(address newOwner) external;
}


// File contracts/utils/access/Ownable.sol



pragma solidity >=0.7.6 <0.8.0;


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

    /**
     * Initializes the contract, setting the deployer as the initial owner.
     * @dev Emits an {IERC173-OwnershipTransferred(address,address)} event.
     */
    constructor(address owner_) {
        _owner = owner_;
        emit OwnershipTransferred(address(0), owner_);
    }

    /**
     * Gets the address of the current contract owner.
     */
    function owner() public view virtual override returns (address) {
        return _owner;
    }

    /**
     * See {IERC173-transferOwnership(address)}
     * @dev Reverts if the sender is not the current contract owner.
     * @param newOwner the address of the new owner. Use the zero address to renounce the ownership.
     */
    function transferOwnership(address newOwner) public virtual override {
        _requireOwnership(_msgSender());
        _owner = newOwner;
        emit OwnershipTransferred(_owner, newOwner);
    }

    /**
     * @dev Reverts if `account` is not the contract owner.
     * @param account the account to test.
     */
    function _requireOwnership(address account) internal virtual {
        require(account == this.owner(), "Ownable: not the owner");
    }

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


// File contracts/math/Math.sol



pragma solidity >=0.6.0 <=0.8.0;

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

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

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


// File contracts/game/GBotStaking/GBotStaking_V2/ERC721Stakeable.sol


pragma solidity >=0.7.6 <0.8.0;



abstract contract ERC721Stakeable is Ownable{

    using SafeMath for uint256;

    /**
    * @dev Constructor since this contract is not meant to be used without inheritance
    * push once to stakeholders for it to work proplerly
     */
    constructor(address owner) Ownable(owner) {
        // This push is needed so we avoid index 0 causing bug of index-1
        stakeholders.push();
    }

    /**
    * @dev
    * The duration of the staking event, this will be initiated in days
    */
    uint256 internal _periodFinish;

    /**
    * @dev
    * Reward points in the pool
    */
    uint256 internal _totalWeight;

    /**
    * @dev
    * Total rewards in the pool
    */
    uint256 internal _totalRewardsPool;

    uint256 public rewardRate = 0;
    uint256 public rewardPerTokenStored;
    uint256 public lastUpdateTime;

    /**
    * @dev
    * GBots Rarity
    */
    uint256 internal constant GBOT_RARITY_STARTER = 0;
    uint256 internal constant GBOT_RARITY_COMMON = 1;
    uint256 internal constant GBOT_RARITY_RARE = 2;
    uint256 internal constant GBOT_RARITY_EPIC = 3;
    uint256 internal constant GBOT_RARITY_LEGENDARY = 4;
    uint256 internal constant GBOT_RARITY_MYTHICAL = 5;
    uint256 internal constant GBOT_RARITY_ULTIMATE = 6;

    /**
    * @dev
    * Rarity points per rarity
    */
    uint256 internal constant RARITY_POINTS_COMMON = 1;
    uint256 internal constant RARITY_POINTS_RARE = 5;
    uint256 internal constant RARITY_POINTS_EPIC = 20;
    uint256 internal constant RARITY_POINTS_LEGENDARY = 50;
    uint256 internal constant RARITY_POINTS_MYTHICAL = 100;
    uint256 internal constant RARITY_POINTS_ULTIMATE = 0; // N/A

    /**
     * @dev
     * A stake struct is used to represent the way we store stakes, 
     * A Stake will contain the users address, the amount staked and a timestamp, 
     * Since which is when the stake was made
     */
    struct Stake{
        address user;
        uint256 tokenId;
        uint256 since;
        uint256 rarity;
    }
    /**
    * @dev Stakeholder is a staker that has active stakes
     */
    struct Stakeholder{
        address user;
        Stake[] address_stakes;
    }
    /**
    * @dev 
    *   This is an array where we store all Stakes that are performed on the Contract
    *   The stakes for each address are stored at a certain index, the index can be found using the stakes mapping
    */
    Stakeholder[] internal stakeholders;
    /**
    * @dev 
    * stakes is used to keep track of the INDEX for the stakers in the stakes array
     */
    mapping(address => uint256) internal stakes;

 
    mapping(address => uint256) internal rewards;
    mapping(address => uint256) internal unclaimedPrizes;
    mapping(address => uint256) internal claimedPrizes;
    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) internal _balances;


    function rewardPerToken() public view returns (uint256) {
        if (_totalWeight == 0) {
            return rewardPerTokenStored;
        }
        return
            rewardPerTokenStored.add(                                         
                lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).div(_totalWeight)
            );
    }

    function earned(address owner) internal view returns (uint256) {                      
        return _balances[owner].mul(rewardPerToken().sub(userRewardPerTokenPaid[owner])).add(rewards[owner]);
    }

     function updateReward(address account) internal {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateTime = lastTimeRewardApplicable();
        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
    }

    /**
     * @dev _addStakeholder takes care of adding a stakeholder to the stakeholders array
     */
    function _addStakeholder(address staker) internal returns (uint256){
        // Push a empty item to the Array to make space for our new stakeholder
        stakeholders.push();
        // Calculate the index of the last item in the array by Len-1
        uint256 userIndex = stakeholders.length - 1;
        // Assign the address to the new index
        stakeholders[userIndex].user = staker;
        // Add index to the stakeHolders
        stakes[staker] = userIndex;
        return userIndex; 
    }

    /**
    * @dev
    * _Stake is used to make a stake for an sender. It will remove the amount staked from the stakers account and place those tokens inside a stake container
    * StakeID 
    */
    function _stake(uint256 tokenId, uint256 rarity) internal returns (uint256) {        
        uint256 index = stakes[_msgSender()];
        uint256 timestamp = block.timestamp;
        // See if the staker already has a staked index or if its the first time
        if(index == 0){
            index = _addStakeholder(_msgSender());
        }
        stakeholders[index].address_stakes.push(Stake(_msgSender(), tokenId, timestamp, rarity));
        // Calculate Reward Points and add to the total supply
        uint256 stakeWeight = _calculateStakeWeight(rarity);
        _totalWeight += stakeWeight;
        _balances[_msgSender()] += stakeWeight;
        return index;
    }

    /**
     * @dev
     * withdrawStake takes in an amount and a index of the stake and will remove tokens from that stake
     * Notice index of the stake is the users stake counter, starting at 0 for the first stake
    */
    function _withdrawStake(uint256 tokenId, address owner) internal {
         // Grab user_index which is the index to use to grab the Stake[]
        uint256 user_index = stakes[owner];
        // Grab the index for the stake
        uint256 index = _getStakeIndex(owner, tokenId);
        Stake memory current_stake = stakeholders[user_index].address_stakes[index];

        // On completion remove the stake from the stakeholders
         delete stakeholders[user_index].address_stakes[index];
        // Remove weight from total weight
        uint256 stakeWeight = _calculateStakeWeight(current_stake.rarity);
        _totalWeight -= stakeWeight;
        _balances[owner] -= stakeWeight;
    }

    /**
     * @dev
     * _saveUnclaimedPrizes saves prizes from previous periods
     * It will save the unclaimed prices for users, to use in other periods
    */
    function _saveUnclaimedPrizes() internal {
        uint256 totalStakes = stakeholders.length;
        for (uint256 s = 0; s < totalStakes; s += 1) {
            address user = stakeholders[s].user;
            updateReward(user);
            unclaimedPrizes[user] += rewards[user];
            rewards[user] = 0;
            userRewardPerTokenPaid[user] = 0;
        }
    }


    /**
    * @dev
    * isRightfulOwner is used to check if an account was the true owner before staking
    */
    function _isRightfulOwner(address owner, uint256 tokenId) internal view returns(bool) {
        // Get user stakes
        Stake[] memory existingStakes = stakeholders[stakes[owner]].address_stakes;
        uint256 sumStakes = existingStakes.length;
        for (uint256 s = 0; s < sumStakes; s += 1) {
            if (tokenId == existingStakes[s].tokenId) {
                return true;
            }
       }
        return false;
    }

    /**
    * @dev
    * _getStakeIndex gets the index of the stake we need to withdraw
    * @notice This function must be called after _isRightfulOwner, to check if the tokenId exists at all
    * otherwise, it will return 0
    */
    function _getStakeIndex(address owner, uint256 tokenId) internal view returns(uint256) {
        // Get user stakes
        Stake[] memory existingStakes = stakeholders[stakes[owner]].address_stakes;
        uint256 sumStakes = existingStakes.length;
        for (uint256 s = 0; s < sumStakes; s += 1) {
            if (tokenId == existingStakes[s].tokenId) {
                return s;
            }
       }
        return 0;
    }

    /**
    * @dev
    * Based on rarity, calculate Reward points for G-Bot
    *  
    */
    function _calculateStakeWeight(uint256 rarity) internal pure returns (uint256 rewardPoints) {
        if (rarity == GBOT_RARITY_COMMON) {
          return RARITY_POINTS_COMMON;
        }
        if (rarity == GBOT_RARITY_RARE) {
          return RARITY_POINTS_RARE;         
        }
        if (rarity == GBOT_RARITY_EPIC) {
          return RARITY_POINTS_EPIC;
        }
        if (rarity == GBOT_RARITY_LEGENDARY) {
          return RARITY_POINTS_LEGENDARY;
        }
        if (rarity == GBOT_RARITY_MYTHICAL) {
          return RARITY_POINTS_MYTHICAL;
        }
        if (rarity == GBOT_RARITY_ULTIMATE) {
          return RARITY_POINTS_ULTIMATE;
        }
    }

    function _ownerTokenIds(address owner) internal view returns(uint256[] memory) {
        // Keep a summary in memory since we need to calculate this
        Stake[] memory existingStakes = stakeholders[stakes[owner]].address_stakes;
        uint256[] memory tokenIds = new uint256[](existingStakes.length);

        for (uint256 s = 0; s < existingStakes.length; s += 1) {
            tokenIds[s] = (existingStakes[s].tokenId);
       }
        return tokenIds;
    }

    function lastTimeRewardApplicable() public view returns (uint256) {
        return block.timestamp < _periodFinish ? block.timestamp : _periodFinish;
    }

    modifier stakingNotFinished() {
        require(block.timestamp < _periodFinish, "ERC721Stakeable: Event is finished");
        _;
    }

    modifier stakingFinished() {
        require(block.timestamp > _periodFinish, "ERC721Stakeable: Event is not finished");
        _;
    }

}


// File contracts/utils/ReentrancyGuard.sol



pragma solidity >=0.6.2 <0.8.0;

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

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

    uint256 private _status;

    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 make 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;
    }
}


// File contracts/game/GBotStaking/GBotStaking_V2/GBotStaking_V2.sol


pragma solidity >=0.7.6 <0.8.0;







contract GBotStaking is ERC721Receiver, ERC721Stakeable, ReentrancyGuard  {

    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    IERC20 public immutable rewardToken;
    IGBotInventory private GBotContract;

    event GBotStaked(address indexed user, uint256 tokenId, uint256 index);
    event GBotWithdrawn(address indexed user, uint256 tokenId);
    event EventFinished(uint256 totalStakes, uint256 totalReward);
    event RewardClaimed(address indexed user, uint256 reward);
    event EventStarted(uint256 duration, uint256 reward);
    event ERC721Received(address operator, address from, uint256 tokenId, bytes data);
    event TokensReturned(uint256 tokensReturned);
    event GbotsReturned(uint256 numOfGbots);

    constructor (
        address gBotInventory_,
        address rewardToken_ ) 
        ERC721Stakeable(msg.sender) {
        require(rewardToken_ != address(0), "GBot Staking: Reward token not set");
        require(gBotInventory_ != address(0), "GBot Staking: GBot inventory not set");
        rewardToken = IERC20(rewardToken_);
        GBotContract = IGBotInventory(gBotInventory_);
    }

    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external virtual override returns (bytes4) {
        emit ERC721Received(operator, from, tokenId, data);
        return this.onERC721Received.selector;
    }


    // stake
    function stake(uint256 tokenId) stakingNotFinished nonReentrant public {
        updateReward(_msgSender());
        // Check if token is not allready staked
        require(_isRightfulOwner(_msgSender(), tokenId) == false, "ERC721Stakeable: Token already staked!");
        
        // Check owner
        address owner = GBotContract.ownerOf(tokenId);
        require(owner==_msgSender(), "GBot Staking: Not the rightful owner");

        // Get metadata
        uint256 metadata = GBotContract.getMetadata(tokenId);

        // Get rarity
        uint256 rarity = getRarity(metadata);
        // Gbot cannot be starter
        require(rarity != GBOT_RARITY_STARTER, "GBot Staking: Cannot stake STARTER GBot");

        // Transfer the GBot to the Staker
        GBotContract.safeTransferFrom(_msgSender(), address(this), tokenId);

        // Stake the token
        uint256 index =_stake(tokenId, rarity);

        emit GBotStaked(_msgSender(), tokenId, index);
    }


    // claim prize
    function claimPrizes() nonReentrant public {
        updateReward(_msgSender());
        // Get reward for owner
        uint256 reward = rewards[_msgSender()] + unclaimedPrizes[_msgSender()];
        if (reward == 0) return;
        
        rewards[_msgSender()] = 0;
        unclaimedPrizes[_msgSender()] = 0;

        rewardToken.safeTransfer(_msgSender(), reward);
        claimedPrizes[_msgSender()] += reward;

        emit RewardClaimed(_msgSender(), reward);
    }

    // withdraw
    function withdraw(uint256 tokenId) nonReentrant  public { 
        updateReward(_msgSender());
       
        // Check is user rightful owner
        require(_isRightfulOwner(_msgSender(), tokenId), "ERC721Stakeable: Not rightful owner");

        // withdraw stake
        _withdrawStake(tokenId, _msgSender());

        // Transfer the GBot to the user
        GBotContract.safeTransferFrom(address(this), _msgSender(), tokenId);

        emit GBotWithdrawn(_msgSender(), tokenId);
    }

    // withdraw all
    function withdrawAll() virtual public {
        updateReward(_msgSender());
        uint256[] memory currentTokens = _ownerTokenIds(_msgSender());
        
        // Loop through every stake the current user has
        for (uint256 i = 0; i < currentTokens.length; i += 1) {
            // Make sure the token is not withdrawed
            if (currentTokens[i] != 0){
                // Withdraw stake with current index
                _withdrawStake(currentTokens[i], _msgSender());
                // Transfer GBot back to user
                GBotContract.safeTransferFrom(address(this), _msgSender(), currentTokens[i]);
                emit GBotWithdrawn(_msgSender(), currentTokens[i]);
            }
        }

        // Claim all prizes for user
        claimPrizes();
    }

    //================================== PUBLIC FUNCTIONS ==================================//
    function getUnclaimedReward(address owner) virtual public view returns (uint256) {
        return earned(owner) + unclaimedPrizes[owner];
    }

    function getClaimedReward(address owner) virtual public view returns (uint256) {
        return claimedPrizes[owner];
    }

    function getStakedGBots(address owner) virtual public view returns (uint256[] memory) {
        return _ownerTokenIds(owner);
    }

    function getTotalWeight(address owner) virtual public view returns (uint256) {
        return _balances[owner];
    } 

    function totalWeight() public view returns (uint256) {
        return _totalWeight;
    }

    function totalRewardsPool() public view returns (uint256) {
        return _totalRewardsPool;
    }

    function periodFinish() public view returns (uint256) {
        return _periodFinish;
    }


    //================================== ADMIN ONLY FUNCTIONS ==================================//
   
    /**
     * Actvates, or 'starts' another period of staking 
     * @notice to be called after the amount of reward tokens is sent to the contract
     * @param duration The duration of the contract (in minutes)
     * @dev Reverts if called by any other than the contract owner.
     * @dev Reverts if amount specified is not allready in the contract
     */
    function confirmPoolAndStart(uint256 amount, uint256 duration) external stakingFinished {
        _requireOwnership(_msgSender());
        _saveUnclaimedPrizes();
        rewardRate = amount.div(duration * 1 minutes);
        
        rewardPerTokenStored = 0;
        lastUpdateTime = block.timestamp;
        _periodFinish = block.timestamp + (duration * 1 minutes);

        uint256 balance = rewardToken.balanceOf(address(this));
        require (amount <= balance, "GBotStaking: Not enough balance to confirm");
       _totalRewardsPool = amount;
       emit EventStarted(duration, amount);
    }

    function finishEvent() external {
        _requireOwnership(_msgSender());
        uint256 totalRewardGmee;
        uint256 totalStakes = stakeholders.length;
        // Loop for every user
        for (uint256 s = 0; s < totalStakes; s += 1) {
            address currentUser = stakeholders[s].user;
            updateReward(currentUser);
            // Get current tokenIds for user
            uint256[] memory currentTokens = _ownerTokenIds(currentUser);

            // Loop through every stake the current user has
            for (uint256 i = 0; i < currentTokens.length; i += 1) {
                // Make sure the token is not withdrawed
                if (currentTokens[i] != 0){
                    // Withdraw stake with current index
                    _withdrawStake(currentTokens[i], currentUser);
                    // Transfer GBot back to user
                    GBotContract.safeTransferFrom(address(this), currentUser, currentTokens[i]);
                }
            }

            // Get reward for owner
            uint256 reward = earned(currentUser) + unclaimedPrizes[currentUser]; 
            // Transfer GMEE reward to user
            if (reward != 0) {
            rewardToken.safeTransfer(currentUser, reward);
            totalRewardGmee += reward;
            unclaimedPrizes[currentUser] = 0;
            rewards[currentUser] = 0;
            claimedPrizes[currentUser] += reward;
            }
        }
        _periodFinish = block.timestamp;
        emit EventFinished(totalStakes, totalRewardGmee);
    }

    function returnTokensToOwner() external {
        _requireOwnership(_msgSender());
        uint256 balance = rewardToken.balanceOf(address(this));
        if (balance == 0)
            return;
        rewardToken.safeTransfer(_owner, balance);
        emit TokensReturned(balance);
    }

    function returnGbots() external {
        _requireOwnership(_msgSender());
        uint256 numOfGbots;

        uint256 totalStakes = stakeholders.length;
        for (uint256 s = 0; s < totalStakes; s += 1) {
            address currentUser = stakeholders[s].user;
            uint256[] memory currentTokens = _ownerTokenIds(currentUser);

            for (uint256 i = 0; i < currentTokens.length; i += 1) {
                if (currentTokens[i] != 0){
                    GBotContract.safeTransferFrom(address(this), currentUser, currentTokens[i]);
                    numOfGbots++;
                }
            }
        }
        emit GbotsReturned(numOfGbots);
    }

    //================================== HELPER FUNCTIONS ==================================//


    function getRarity(uint256 metadataId) private pure returns (uint256) {
        uint bits = 8;
        uint256 RARITY_BITS = 223;
        uint256 ONES = uint(~0);
        return metadataId >> RARITY_BITS & ONES >> 256 - bits;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"gBotInventory_","type":"address"},{"internalType":"address","name":"rewardToken_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"ERC721Received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"totalStakes","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalReward","type":"uint256"}],"name":"EventFinished","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"duration","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"EventStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"}],"name":"GBotStaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"GBotWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"numOfGbots","type":"uint256"}],"name":"GbotsReturned","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokensReturned","type":"uint256"}],"name":"TokensReturned","type":"event"},{"inputs":[],"name":"claimPrizes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"confirmPoolAndStart","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"finishEvent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getClaimedReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getStakedGBots","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getTotalWeight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getUnclaimedReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC721Received","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":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"returnGbots","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"returnTokensToOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRewardsPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalWeight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000005b30cc4def69ae2dfcddbc7ebafea82cedae0190000000000000000000000000cf32822ff397ef82425153a9dcb726e5ff61dca7

-----Decoded View---------------
Arg [0] : gBotInventory_ (address): 0x5b30cc4def69ae2dfcddbc7ebafea82cedae0190
Arg [1] : rewardToken_ (address): 0xcf32822ff397ef82425153a9dcb726e5ff61dca7

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005b30cc4def69ae2dfcddbc7ebafea82cedae0190
Arg [1] : 000000000000000000000000cf32822ff397ef82425153a9dcb726e5ff61dca7

45788:9353:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26400:209;;;;;;;;;;;;;;;;-1:-1:-1;26400:209:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;50402:125;;;;;;;;;;;;;;;;-1:-1:-1;50402:125:0;-1:-1:-1;;;;;50402:125:0;;:::i;:::-;;;;;;;;;;;;;;;;46951:299;;;;;;;;;;;;;;;;-1:-1:-1;;;;;46951:299:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46951:299:0;;-1:-1:-1;46951:299:0;-1:-1:-1;46951:299:0;:::i;:::-;;;;;;;;;;;;;;;;;;;53802:294;;;:::i;:::-;;48810:503;;;;;;;;;;;;;;;;-1:-1:-1;48810:503:0;;:::i;50903:101::-;;;:::i;48299:486::-;;;:::i;51590:614::-;;;;;;;;;;;;;;;;-1:-1:-1;51590:614:0;;;;;;;:::i;50676:119::-;;;;;;;;;;;;;;;;-1:-1:-1;50676:119:0;-1:-1:-1;;;;;50676:119:0;;:::i;50535:133::-;;;;;;;;;;;;;;;;-1:-1:-1;50535:133:0;-1:-1:-1;;;;;50535:133:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33786:29;;;:::i;52212:1582::-;;;:::i;42519:157::-;;;:::i;49342:803::-;;;:::i;35895:57::-;;;;;;;;;;;;;;;;-1:-1:-1;35895:57:0;-1:-1:-1;;;;;35895:57:0;;:::i;31027:96::-;;;:::i;:::-;;;;-1:-1:-1;;;;;31027:96:0;;;;;;;;;;;;;;50249:145;;;;;;;;;;;;;;;;-1:-1:-1;50249:145:0;-1:-1:-1;;;;;50249:145:0;;:::i;50804:91::-;;;:::i;47274:995::-;;;;;;;;;;;;;;;;-1:-1:-1;47274:995:0;;:::i;54104:688::-;;;:::i;33864:29::-;;;:::i;36016:361::-;;;:::i;33822:35::-;;;:::i;51012:93::-;;;:::i;31370:201::-;;;;;;;;;;;;;;;;-1:-1:-1;31370:201:0;-1:-1:-1;;;;;31370:201:0;;:::i;45939:35::-;;;:::i;26400:209::-;26485:4;26509:40;;;26524:25;26509:40;;:92;;-1:-1:-1;26553:48:0;;;26568:33;26553:48;26509:92;26502:99;;26400:209;;;;:::o;50402:125::-;-1:-1:-1;;;;;50499:20:0;50472:7;50499:20;;;:13;:20;;;;;;;50402:125::o;46951:299::-;47125:6;47149:45;47164:8;47174:4;47180:7;47189:4;;47149:45;;;;-1:-1:-1;;;;;47149:45:0;;;;;;-1:-1:-1;;;;;47149:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;47149:45:0;;;;;;;;-1:-1:-1;47149:45:0;;-1:-1:-1;;;;;;;47149:45:0;-1:-1:-1;47212:30:0;46951:299;;;;;;;:::o;53802:294::-;53853:31;53871:12;:10;:12::i;:::-;53853:17;:31::i;:::-;53895:15;53913:11;-1:-1:-1;;;;;53913:21:0;;53943:4;53913:36;;;;;;;;;;;;;-1:-1:-1;;;;;53913:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53913:36:0;;-1:-1:-1;53964:12:0;53960:38;;53991:7;;;53960:38;54033:6;;54008:41;;-1:-1:-1;;;;;54008:11:0;:24;;;54033:6;54041:7;54008:24;:41::i;:::-;54065:23;;;;;;;;;;;;;;;;;53802:294;;:::o;48810:503::-;44719:1;45316:7;;:19;;45308:63;;;;;-1:-1:-1;;;45308:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;44719:1;45449:7;:18;48878:26:::1;48891:12;:10;:12::i;:::-;48878;:26::i;:::-;48973:39;48990:12;:10;:12::i;:::-;49004:7;48973:16;:39::i;:::-;48965:87;;;;-1:-1:-1::0;;;48965:87:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49092:37;49107:7;49116:12;:10;:12::i;:::-;49092:14;:37::i;:::-;49184:12;::::0;-1:-1:-1;;;;;49184:12:0::1;:29;49222:4;49229:12;:10;:12::i;:::-;49243:7;49184:67;;;;;;;;;;;;;-1:-1:-1::0;;;;;49184:67:0::1;;;;;;-1:-1:-1::0;;;;;49184:67:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49283:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;49269:36:0::1;;49297:7;49269:36;;;;;;;;;;;;;;;;;;-1:-1:-1::0;44675:1:0;45628:7;:22;48810:503::o;50903:101::-;50979:17;;50903:101;;:::o;48299:486::-;44719:1;45316:7;;:19;;45308:63;;;;;-1:-1:-1;;;45308:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;44719:1;45449:7;:18;48353:26:::1;48366:12;:10;:12::i;48353:26::-;48423:14;48464:15;:29;48480:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;48464:29:0::1;-1:-1:-1::0;;;;;48464:29:0::1;;;;;;;;;;;;;48440:7;:21;48448:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;48440:21:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;48440:21:0;;:53:::1;::::0;-1:-1:-1;48508:11:0;48504:24:::1;;48521:7;;;48504:24;48572:1;48548:7;:21;48556:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;48548:21:0::1;-1:-1:-1::0;;;;;48548:21:0::1;;;;;;;;;;;;:25;;;;48616:1;48584:15;:29;48600:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;48584:29:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;48584:29:0;:33;48630:46:::1;48655:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;48630:11:0::1;:24;::::0;48669:6;48630:24:::1;:46::i;:::-;48718:6;48687:13;:27;48701:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;48687:27:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;48687:27:0;:37;;;;::::1;::::0;;48756:12:::1;:10;:12::i;:::-;-1:-1:-1::0;;;;;48742:35:0::1;;48770:6;48742:35;;;;;;;;;;;;;;;;;;45480:1;;44675::::0;45628:7;:22;48299:486::o;51590:614::-;42895:13;;42877:15;:31;42869:82;;;;-1:-1:-1;;;42869:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51689:31:::1;51707:12;:10;:12::i;51689:31::-;51731:22;:20;:22::i;:::-;51777:32;:6:::0;51799:9:::1;51788:20:::0;::::1;51777:10;:32::i;:::-;51764:10;:45:::0;;;51853:1:::1;51830:20;:24:::0;;;51882:15:::1;51865:14;:32:::0;;;51954:9:::1;51943:20:::0;::::1;51924:40;51908:13;:56:::0;51995:36:::1;::::0;;;;;52025:4:::1;51995:36:::0;;::::1;::::0;;;;;51853:1;;-1:-1:-1;;;;;51995:11:0::1;:21;::::0;::::1;::::0;:36;;;;;::::1;::::0;;;;;;;;;:21;:36;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;51995:36:0;;-1:-1:-1;52051:17:0;;::::1;;52042:73;;;;-1:-1:-1::0;;;52042:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52125:17;:26:::0;;;52166:30:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;;;;;;;;::::1;42962:1;51590:614:::0;;:::o;50676:119::-;-1:-1:-1;;;;;50771:16:0;50744:7;50771:16;;;:9;:16;;;;;;;50676:119::o;50535:133::-;50603:16;50639:21;50654:5;50639:14;:21::i;33786:29::-;;;;:::o;52212:1582::-;52255:31;52273:12;:10;:12::i;52255:31::-;52353:12;:19;52297:23;;;52415:1271;52439:11;52435:1;:15;52415:1271;;;52475:19;52497:12;52510:1;52497:15;;;;;;;;;;;;;;;;;;;;;:20;-1:-1:-1;;;;;52497:20:0;;-1:-1:-1;52532:25:0;52497:20;52532:12;:25::i;:::-;52618:30;52651:27;52666:11;52651:14;:27::i;:::-;52618:60;;52762:9;52757:467;52781:13;:20;52777:1;:24;52757:467;;;52892:13;52906:1;52892:16;;;;;;;;;;;;;;52912:1;52892:21;52888:321;;52995:45;53010:13;53024:1;53010:16;;;;;;;;;;;;;;53028:11;52995:14;:45::i;:::-;53114:12;;53172:16;;-1:-1:-1;;;;;53114:12:0;;;;:29;;53152:4;;53159:11;;53172:13;;53186:1;;53172:16;;;;;;;;;;;;53114:75;;;;;;;;;;;;;-1:-1:-1;;;;;53114:75:0;;;;;;-1:-1:-1;;;;;53114:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52888:321;52808:1;52803:6;52757:467;;;-1:-1:-1;;;;;;53316:28:0;;53277:14;53316:28;;;:15;:28;;;;;;53294:19;53332:11;53294:6;:19::i;:::-;:50;;-1:-1:-1;53409:11:0;;53405:270;;53437:45;-1:-1:-1;;;;;53437:11:0;:24;53462:11;53475:6;53437:24;:45::i;:::-;-1:-1:-1;;;;;53537:28:0;;53568:1;53537:28;;;:15;:28;;;;;;;;:32;;;53584:7;:20;;;;;:24;;;53623:13;:26;;;;;:36;;;;;;53497:25;;;;53405:270;-1:-1:-1;;;52457:1:0;52452:6;52415:1271;;;-1:-1:-1;53712:15:0;53696:13;:31;53743:43;;;;;;;;;;;;;;;;;;;;;;;;;52212:1582;;:::o;42519:157::-;42576:7;42621:13;;42603:15;:31;:65;;42655:13;;42603:65;;;42637:15;42603:65;42596:72;;42519:157;:::o;49342:803::-;49391:26;49404:12;:10;:12::i;49391:26::-;49428:30;49461:28;49476:12;:10;:12::i;:::-;49461:14;:28::i;:::-;49428:61;;49573:9;49568:506;49592:13;:20;49588:1;:24;49568:506;;;49695:13;49709:1;49695:16;;;;;;;;;;;;;;49715:1;49695:21;49691:372;;49790:46;49805:13;49819:1;49805:16;;;;;;;;;;;;;;49823:12;:10;:12::i;49790:46::-;49902:12;;-1:-1:-1;;;;;49902:12:0;:29;49940:4;49947:12;:10;:12::i;:::-;49961:13;49975:1;49961:16;;;;;;;;;;;;;;49902:76;;;;;;;;;;;;;-1:-1:-1;;;;;49902:76:0;;;;;;-1:-1:-1;;;;;49902:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50016:12;:10;:12::i;:::-;-1:-1:-1;;;;;50002:45:0;;50030:13;50044:1;50030:16;;;;;;;;;;;;;;50002:45;;;;;;;;;;;;;;;;;;49691:372;49619:1;49614:6;49568:506;;;;50124:13;:11;:13::i;:::-;49342:803;:::o;35895:57::-;;;;;;;;;;;;;:::o;31027:96::-;31082:7;31109:6;-1:-1:-1;;;;;31109:6:0;31027:96;:::o;50249:145::-;-1:-1:-1;;;;;50364:22:0;;50321:7;50364:22;;;:15;:22;;;;;;50348:13;50380:5;50348:6;:13::i;:::-;:38;;50249:145;-1:-1:-1;;50249:145:0:o;50804:91::-;50875:12;;50804:91;:::o;47274:995::-;42751:13;;42733:15;:31;42725:78;;;;-1:-1:-1;;;42725:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44719:1:::1;45316:7;;:19;;45308:63;;;::::0;;-1:-1:-1;;;45308:63:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;44719:1;45449:7;:18:::0;47356:26:::2;47369:12;:10;:12::i;47356:26::-;47451:39;47468:12;:10;:12::i;47451:39::-;:48;47443:99;;;;-1:-1:-1::0;;;47443:99:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47603:12;::::0;:29:::2;::::0;;;;;::::2;::::0;::::2;::::0;;;;;47587:13:::2;::::0;-1:-1:-1;;;;;47603:12:0::2;::::0;:20:::2;::::0;:29;;;;;::::2;::::0;;;;;;;;:12;:29;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;47603:29:0;;-1:-1:-1;47658:12:0::2;:10;:12::i;:::-;-1:-1:-1::0;;;;;47651:19:0::2;:5;-1:-1:-1::0;;;;;47651:19:0::2;;47643:68;;;;-1:-1:-1::0;;;47643:68:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47768:12;::::0;:33:::2;::::0;;;;;::::2;::::0;::::2;::::0;;;;;47749:16:::2;::::0;-1:-1:-1;;;;;47768:12:0::2;::::0;:24:::2;::::0;:33;;;;;::::2;::::0;;;;;;;;:12;:33;::::2;;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;::::0;::::2;;-1:-1:-1::0;47768:33:0;;-1:-1:-1;47837:14:0::2;47854:19;47768:33:::0;47854:9:::2;:19::i;:::-;47837:36:::0;-1:-1:-1;47927:29:0;47919:81:::2;;;;-1:-1:-1::0;;;47919:81:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48057:12;::::0;-1:-1:-1;;;;;48057:12:0::2;:29;48087:12;:10;:12::i;:::-;48109:4;48116:7;48057:67;;;;;;;;;;;;;-1:-1:-1::0;;;;;48057:67:0::2;;;;;;-1:-1:-1::0;;;;;48057:67:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;48165:13;48180:23;48187:7;48196:6;48180;:23::i;:::-;48165:38;;48232:12;:10;:12::i;:::-;-1:-1:-1::0;;;;;48221:40:0::2;;48246:7;48255:5;48221:40;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;44675:1:0::1;45628:7;:22:::0;-1:-1:-1;;;47274:995:0:o;54104:688::-;54147:31;54165:12;:10;:12::i;54147:31::-;54242:12;:19;54189:18;;;54272:472;54296:11;54292:1;:15;54272:472;;;54332:19;54354:12;54367:1;54354:15;;;;;;;;;;;;;;;;;;;;:20;-1:-1:-1;;;;;54354:20:0;;-1:-1:-1;54422:27:0;54354:20;54422:14;:27::i;:::-;54389:60;;54471:9;54466:267;54490:13;:20;54486:1;:24;54466:267;;;54543:13;54557:1;54543:16;;;;;;;;;;;;;;54563:1;54543:21;54539:179;;54588:12;;54646:16;;-1:-1:-1;;;;;54588:12:0;;;;:29;;54626:4;;54633:11;;54646:13;;54660:1;;54646:16;;;;;;;;;;;;54588:75;;;;;;;;;;;;;-1:-1:-1;;;;;54588:75:0;;;;;;-1:-1:-1;;;;;54588:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;54686:12:0;;;;;-1:-1:-1;;54539:179:0;54517:1;54512:6;54466:267;;;-1:-1:-1;;;54314:1:0;54309:6;54272:472;;;-1:-1:-1;54759:25:0;;;;;;;;;;;;;;;;;54104:688;;:::o;33864:29::-;;;;:::o;36016:361::-;36063:7;36087:12;;36103:1;36087:17;36083:77;;;-1:-1:-1;36128:20:0;;36121:27;;36083:77;36190:179;36274:80;36341:12;;36274:62;36325:10;;36274:46;36305:14;;36274:26;:24;:26::i;:::-;:30;;:46::i;:::-;:50;;:62::i;:::-;:66;;:80::i;:::-;36190:20;;;:24;:179::i;33822:35::-;;;;:::o;51012:93::-;51084:13;;51012:93;:::o;31370:201::-;31450:31;31468:12;:10;:12::i;31450:31::-;31492:6;:17;;-1:-1:-1;;31492:17:0;-1:-1:-1;;;;;31492:17:0;;;;;;;;;31525:38;;31492:17;;31546:6;;;31525:38;;31492:6;31525:38;31370:201;:::o;45939:35::-;;;:::o;27001:115::-;27097:10;27001:115;:::o;31702:138::-;31793:4;-1:-1:-1;;;;;31793:10:0;;:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31793:12:0;-1:-1:-1;;;;;31782:23:0;;;;;;31774:58;;;;;-1:-1:-1;;;31774:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;20532:177;20642:58;;;-1:-1:-1;;;;;20642:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20665:23;20642:58;;;20615:86;;20635:5;;20615:19;:86::i;:::-;20532:177;;;:::o;36598:327::-;36680:16;:14;:16::i;:::-;36657:20;:39;36724:26;:24;:26::i;:::-;36707:14;:43;-1:-1:-1;;;;;36765:21:0;;;36761:157;;36822:15;36829:7;36822:6;:15::i;:::-;-1:-1:-1;;;;;36803:16:0;;;;;;:7;:16;;;;;;;;:34;;;;36886:20;;36852:22;:31;;;;;;:54;36598:327;:::o;40094:448::-;-1:-1:-1;;;;;40264:13:0;;40174:4;40264:13;;;:6;:13;;;;;;40251:12;:27;;40174:4;;40264:13;40251:27;;;;;;;;;;;;;;;;:42;;40219:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;40219:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;40324:21:0;;40219:74;;-1:-1:-1;40304:17:0;;-1:-1:-1;;40356:156:0;40380:9;40376:1;:13;40356:156;;;40429:14;40444:1;40429:17;;;;;;;;;;;;;;:25;;;40418:7;:36;40414:88;;;40482:4;40475:11;;;;;;;40414:88;40396:1;40391:6;40356:156;;;;40529:5;40522:12;;;;40094:448;;;;;:::o;38696:709::-;-1:-1:-1;;;;;38868:13:0;;38847:18;38868:13;;;:6;:13;;;;;;;38949:30;38875:5;38971:7;38949:14;:30::i;:::-;38933:46;;38990:26;39019:12;39032:10;39019:24;;;;;;;;;;;;;;;;;;:39;;39059:5;39019:46;;;;;;;;;;;;;;;;;38990:75;;;;;;;;39019:46;;;;;;;38990:75;;-1:-1:-1;;;;;38990:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39151:12;:24;;38990:75;;-1:-1:-1;39151:12:0;39164:10;;39151:24;;;;;;;;;;;;;;;;:39;;39191:5;39151:46;;;;;;;;;;;;;;;;;;;;39144:53;;-1:-1:-1;;39144:53:0;;;;;;;;;;;;;;;;;;;;39296:20;;;;39274:43;;:21;:43::i;:::-;39328:12;:27;;;;;;;-1:-1:-1;;;;;39366:16:0;;;39328:12;39366:16;;;:9;:16;;;;;:31;;;;;;;;;-1:-1:-1;;;;;38696:709:0:o;39584:383::-;39658:12;:19;39636;39688:272;39712:11;39708:1;:15;39688:272;;;39748:12;39763;39776:1;39763:15;;;;;;;;;;;;;;;;;;;;;:20;-1:-1:-1;;;;;39763:20:0;;-1:-1:-1;39798:18:0;39763:20;39798:12;:18::i;:::-;-1:-1:-1;;;;;39856:13:0;;;;;:7;:13;;;;;;;;;;39831:15;:21;;;;;:38;;;;;;;39884:17;;;39916:22;:28;;;;;:32;-1:-1:-1;39725:6:0;39688:272;;;;39584:383;:::o;8769:153::-;8827:7;8859:1;8855;:5;8847:44;;;;;-1:-1:-1;;;8847:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;8913:1;8909;:5;;;;;;;8769:153;-1:-1:-1;;;8769:153:0:o;42035:476::-;-1:-1:-1;;;;;42239:13:0;;42194:29;42239:13;;;:6;:13;;;;;;42226:12;:27;;42096:16;;42194:29;42239:13;42226:27;;;;;;;;;;;;;;;;:42;;42194:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;42194:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42279:25;42321:14;:21;42307:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42307:36:0;;42279:64;;42361:9;42356:122;42380:14;:21;42376:1;:25;42356:122;;;42441:14;42456:1;42441:17;;;;;;;;;;;;;;:25;;;42426:8;42435:1;42426:11;;;;;;;;;;;;;;;;;:41;42408:1;42403:6;42356:122;;;-1:-1:-1;42495:8:0;42035:476;-1:-1:-1;;;42035:476:0:o;36385:204::-;-1:-1:-1;;;;;36566:14:0;;36439:7;36566:14;;;:7;:14;;;;;;;;;36530:22;:29;;;;;;36488:93;;36566:14;36488:73;;36509:51;;:16;:14;:16::i;:51::-;-1:-1:-1;;;;;36488:16:0;;;;;;:9;:16;;;;;;;:20;:73::i;:::-;:77;;:93::i;54900:236::-;55027:3;55082:25;55110:18;55082:46;;54900:236::o;37767:690::-;37834:7;37862:13;37878:6;:20;37885:12;:10;:12::i;:::-;-1:-1:-1;;;;;37878:20:0;;;;;;;;;;;;-1:-1:-1;37878:20:0;;;-1:-1:-1;37929:15:0;38040:10;38037:78;;38074:29;38090:12;:10;:12::i;:::-;38074:15;:29::i;:::-;38066:37;;38037:78;38125:12;38138:5;38125:19;;;;;;;;;;;;;;;;;;:34;;38165:47;;;;;;;;38171:12;:10;:12::i;:::-;-1:-1:-1;;;;;38165:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;38125:88;;;;;;;;-1:-1:-1;38125:88:0;;;;;;;;;;;;;;;-1:-1:-1;;38125:88:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38310:29;38165:47;38310:21;:29::i;:::-;38350:12;:27;;;;;;38288:51;-1:-1:-1;38288:51:0;38388:9;38350:12;38398;:10;:12::i;:::-;-1:-1:-1;;;;;38388:23:0;;;;;;;;;;;;-1:-1:-1;38388:23:0;:38;;;;;;;-1:-1:-1;38444:5:0;;-1:-1:-1;;37767:690:0;;;;:::o;7654:158::-;7712:7;7745:1;7740;:6;;7732:49;;;;;-1:-1:-1;;;7732:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7799:5:0;;;7654:158::o;8071:220::-;8129:7;8153:6;8149:20;;-1:-1:-1;8168:1:0;8161:8;;8149:20;8192:5;;;8196:1;8192;:5;:1;8216:5;;;;;:10;8208:56;;;;-1:-1:-1;;;8208:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8282:1;8071:220;-1:-1:-1;;;8071:220:0:o;7192:179::-;7250:7;7282:5;;;7306:6;;;;7298:46;;;;;-1:-1:-1;;;7298:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;22837:761;23261:23;23287:69;23315:4;23287:69;;;;;;;;;;;;;;;;;23295:5;-1:-1:-1;;;;;23287:27:0;;;:69;;;;;:::i;:::-;23371:17;;23261:95;;-1:-1:-1;23371:21:0;23367:224;;23513:10;23502:30;;;;;;;;;;;;;;;-1:-1:-1;23502:30:0;23494:85;;;;-1:-1:-1;;;23494:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40790:442;-1:-1:-1;;;;;40961:13:0;;40868:7;40961:13;;;:6;:13;;;;;;40948:12;:27;;40868:7;;40961:13;40948:27;;;;;;;;;;;;;;;;:42;;40916:74;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;40916:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;41021:21:0;;40916:74;;-1:-1:-1;41001:17:0;;-1:-1:-1;;41053:153:0;41077:9;41073:1;:13;41053:153;;;41126:14;41141:1;41126:17;;;;;;;;;;;;;;:25;;;41115:7;:36;41111:85;;;41179:1;-1:-1:-1;41172:8:0;;-1:-1:-1;;41172:8:0;41111:85;41093:1;41088:6;41053:153;;41336:691;41406:20;34054:1;41443:6;:28;41439:86;;;-1:-1:-1;34452:1:0;41486:27;;41439:86;34107:1;41539:6;:26;41535:91;;;-1:-1:-1;34507:1:0;41580:25;;41535:91;34160:1;41640:6;:26;41636:82;;;-1:-1:-1;34562:2:0;41681:25;;41636:82;34218:1;41732:6;:31;41728:92;;;-1:-1:-1;34623:2:0;41778:30;;41728:92;34275:1;41834:6;:30;41830:90;;;-1:-1:-1;34683:3:0;41879:29;;41830:90;34332:1;41934:6;:30;41930:90;;;-1:-1:-1;34744:1:0;41979:29;;37041:514;37200:12;:19;;;;;;;;37100:7;37200:19;;;37100:7;37434:6;;37200:19;;37403:23;;;;;;;;;;;;;;;;;;;;;;:37;;-1:-1:-1;;37403:37:0;-1:-1:-1;;;;;37403:37:0;;;;;;37493:14;;;;;;:6;:14;;;;;;;:26;;;-1:-1:-1;37493:26:0;37041:514::o;15539:195::-;15642:12;15674:52;15696:6;15704:4;15710:1;15713:12;15674:21;:52::i;:::-;15667:59;15539:195;-1:-1:-1;;;;15539:195:0:o;16591:530::-;16718:12;16776:5;16751:21;:30;;16743:81;;;;-1:-1:-1;;;16743:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16843:18;16854:6;16843:10;:18::i;:::-;16835:60;;;;;-1:-1:-1;;;16835:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;16969:12;16983:23;17010:6;-1:-1:-1;;;;;17010:11:0;17030:5;17038:4;17010:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;17010:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16968:75;;;;17061:52;17079:7;17088:10;17100:12;17061:17;:52::i;:::-;17054:59;16591:530;-1:-1:-1;;;;;;;16591:530:0:o;12621:422::-;12988:20;13027:8;;;12621:422::o;19131:742::-;19246:12;19275:7;19271:595;;;-1:-1:-1;19306:10:0;19299:17;;19271:595;19420:17;;:21;19416:439;;19683:10;19677:17;19744:15;19731:10;19727:2;19723:19;19716:44;19631:148;19826:12;19819:20;;-1:-1:-1;;;19819:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://11c40c47e395dc94d8364850e0d1c9f3fd8d3a3711548c83aa8d1083ba59eed0