Contract 0xE63f6aB514167A7f28dD81d332A5e9f00819B9Aa

/**
 *Submitted for verification at FtmScan.com on 2022-07-01
*/

// File contracts/OpenZeppelin/introspection/IERC165.sol

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;

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

// File contracts/OpenZeppelin/token/ERC721/IERC721.sol

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(
        address indexed owner,
        address indexed approved,
        uint256 indexed tokenId
    );

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(
        address indexed owner,
        address indexed operator,
        bool approved
    );

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId)
        external
        view
        returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator)
        external
        view
        returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}

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

pragma solidity >=0.6.0 <0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// File contracts/OpenZeppelin/token/ERC721/ERC721Holder.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Implementation of the {IERC721Receiver} interface.
 *
 * Accepts all token transfers.
 * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}.
 */
contract ERC721Holder is IERC721Receiver {
    /**
     * @dev See {IERC721Receiver-onERC721Received}.
     *
     * Always returns `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address,
        address,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}

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

pragma solidity >=0.4.0;

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

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

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

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

    /**
     * @dev Returns the ERC token owner.
     */
    function getOwner() external view returns (address);

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

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

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

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

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

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

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

// File contracts/OpenZeppelin/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, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

// File contracts/OpenZeppelin/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);
    }

    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/OpenZeppelin/token/ERC20/SafeERC20.sol

pragma solidity ^0.6.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/OpenZeppelin/GSN/Context.sol

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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

// File contracts/OpenZeppelin/utils/EnumerableSet.sol

pragma solidity >=0.6.0 <0.8.0;

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

// File contracts/OpenZeppelin/access/AccessControl.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context {
    using EnumerableSet for EnumerableSet.AddressSet;
    using Address for address;

    struct RoleData {
        EnumerableSet.AddressSet members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(
        bytes32 indexed role,
        bytes32 indexed previousAdminRole,
        bytes32 indexed newAdminRole
    );

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {_setupRole}.
     */
    event RoleGranted(
        bytes32 indexed role,
        address indexed account,
        address indexed sender
    );

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(
        bytes32 indexed role,
        address indexed account,
        address indexed sender
    );

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view returns (bool) {
        return _roles[role].members.contains(account);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view returns (uint256) {
        return _roles[role].members.length();
    }

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index)
        public
        view
        returns (address)
    {
        return _roles[role].members.at(index);
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual {
        require(
            hasRole(_roles[role].adminRole, _msgSender()),
            "AccessControl: sender must be an admin to grant"
        );

        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual {
        require(
            hasRole(_roles[role].adminRole, _msgSender()),
            "AccessControl: sender must be an admin to revoke"
        );

        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual {
        require(
            account == _msgSender(),
            "AccessControl: can only renounce roles for self"
        );

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
        _roles[role].adminRole = adminRole;
    }

    function _grantRole(bytes32 role, address account) private {
        if (_roles[role].members.add(account)) {
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (_roles[role].members.remove(account)) {
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// File contracts/OpenZeppelin/utils/Counters.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath}
 * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
 * directly accessed.
 */
library Counters {
    using SafeMath for uint256;

    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        // The {SafeMath} overflow check can be skipped here, see the comment at the top
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value.sub(1);
    }
}

// File contracts/interfaces/IMasterFarmer.sol

pragma solidity 0.6.12;

interface IMasterFarmer {
    function deposit(uint256 _pid, uint256 _amount) external;

    function withdraw(uint256 _pid, uint256 _amount) external;

    function enterStaking(uint256 _amount) external;

    function leaveStaking(uint256 _amount) external;

    function pendingWigo(uint256 _pid, address _user)
        external
        view
        returns (uint256);

    function userInfo(uint256 _pid, address _user)
        external
        view
        returns (uint256, uint256);

    function wigoBurn(uint256 _amount) external;

    function emergencyWithdraw(uint256 _pid) external;
}

// File contracts/WigoGalaxy.sol

pragma solidity 0.6.12;

contract WigoGalaxy is AccessControl, ERC721Holder {
    using Counters for Counters.Counter;
    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    IERC20 public wigoToken;
    IMasterFarmer public masterFarmer;

    bytes32 public constant NFT_ROLE = keccak256("NFT_ROLE");
    bytes32 public constant POINT_ROLE = keccak256("POINT_ROLE");
    bytes32 public constant SPECIAL_ROLE = keccak256("SPECIAL_ROLE");
    uint256 public constant MAX_REFERRAL_SHARE = 80; // 80%

    uint256 public numberActiveProfiles;
    uint256 public numberWigoToReactivate;
    uint256 public numberWigoToRegister;
    uint256 public numberWigoToUpdate;
    uint256 public numberPlanets;
    uint256 public referralFeeShare = 80; // 80%
    uint256 public referralPointShare = 10; // 10%

    mapping(address => bool) public hasRegistered;

    mapping(uint256 => Planet) private planets;
    mapping(address => Resident) private residents;
    mapping(uint256 => Referral) private referrals;

    // Used for generating the planetId
    Counters.Counter private _countPlanets;

    // Used for generating the residentId
    Counters.Counter private _countResidents;

    // Event to notify a new planet is created
    event PlanetAdd(uint256 planetId, string planetName);

    // Event to notify that planet points are increased
    event PlanetPointIncrease(
        uint256 indexed planetId,
        uint256 numberPoints,
        uint256 indexed campaignId
    );

    event ResidentChangePlanet(
        address indexed residentAddress,
        uint256 oldPlanetId,
        uint256 newPlanetId
    );

    // Event to notify that a resident is registered
    event ResidentNew(
        address indexed residentAddress,
        uint256 planetId,
        address nftAddress,
        uint256 tokenId
    );

    // Event to notify a resident pausing her profile
    event ResidentPause(address indexed residentAddress, uint256 planetId);

    // Event to notify that resident points are increased
    event ResidentPointIncrease(
        address indexed residentAddress,
        uint256 numberPoints,
        uint256 indexed campaignId
    );

    // Event to notify that a list of residents have an increase in points
    event ResidentPointIncreaseMultiple(
        address[] residentAddresses,
        uint256 numberPoints,
        uint256 indexed campaignId
    );

    // Event to notify that a resident is reactivating her profile
    event ResidentReactivate(
        address indexed residentAddress,
        uint256 planetId,
        address nftAddress,
        uint256 tokenId
    );

    // Event to notify that a resident is pausing her profile
    event ResidentUpdate(
        address indexed residentAddress,
        address nftAddress,
        uint256 tokenId
    );

    // Event to notify new referral share
    event SetReferralShare(
        address indexed sender,
        uint256 indexed newReferralFeeShare,
        uint256 indexed newReferralPointShare
    );

    // Modifier for admin roles
    modifier onlyOwner() {
        require(
            hasRole(DEFAULT_ADMIN_ROLE, _msgSender()),
            "Not the main admin"
        );
        _;
    }

    // Modifier for point roles
    modifier onlyPoint() {
        require(hasRole(POINT_ROLE, _msgSender()), "Not a point admin");
        _;
    }

    // Modifier for special roles
    modifier onlySpecial() {
        require(hasRole(SPECIAL_ROLE, _msgSender()), "Not a special admin");
        _;
    }

    struct Planet {
        string planetName;
        string planetDescription;
        uint256 numberResidents;
        uint256 numberPoints;
        bool isJoinable;
    }

    struct Resident {
        uint256 residentId;
        uint256 numberPoints;
        uint256 planetId;
        address nftAddress;
        uint256 tokenId;
        uint256 referral;
        bool isActive;
    }

    struct Referral {
        address residentAddress;
        uint256 totalReferred;
    }

    constructor(
        IERC20 _wigoToken,
        IMasterFarmer _masterFarmer,
        uint256 _numberWigoToReactivate,
        uint256 _numberWigoToRegister,
        uint256 _numberWigoToUpdate
    ) public {
        wigoToken = _wigoToken;
        masterFarmer = _masterFarmer;
        numberWigoToReactivate = _numberWigoToReactivate;
        numberWigoToRegister = _numberWigoToRegister;
        numberWigoToUpdate = _numberWigoToUpdate;
        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
    }

    /**
     * @dev To create a resident profile. It sends the NFT to the contract
     * and sends WIGO to wigoBurn function on MasterFarmer.
     */
    function createProfile(
        uint256 _planetId,
        address _nftAddress,
        uint256 _tokenId,
        uint256 _referralId
    ) external {
        require(!hasRegistered[_msgSender()], "Already registered");
        require(
            (_planetId <= numberPlanets) && (_planetId > 0),
            "Invalid planetId"
        );
        require(planets[_planetId].isJoinable, "Planet not joinable");
        require(hasRole(NFT_ROLE, _nftAddress), "NFT address invalid");
        if (_referralId != 0) {
            address referralAddress = referrals[_referralId].residentAddress;
            if (
                !hasRegistered[referralAddress] ||
                !residents[referralAddress].isActive
            ) {
                _referralId = 0;
            }
        }

        // Loads the interface to deposit the NFT contract
        IERC721 nftToken = IERC721(_nftAddress);

        require(
            _msgSender() == nftToken.ownerOf(_tokenId),
            "Only NFT owner can register"
        );

        // Transfer NFT to this contract
        nftToken.safeTransferFrom(_msgSender(), address(this), _tokenId);

        // Transfer WIGO tokens to this contract
        wigoToken.safeTransferFrom(
            _msgSender(),
            address(this),
            numberWigoToRegister
        );
        if (_referralId != 0) {
            address referralAddress = referrals[_referralId].residentAddress;
            // Send rewards to referral
            wigoToken.safeTransfer(
                referralAddress,
                (referralFeeShare.mul(numberWigoToRegister)).div(100)
            );

            // Burn WIGO tokens from this contract
            IMasterFarmer(masterFarmer).wigoBurn(
                ((100 - referralFeeShare).mul(numberWigoToRegister)).div(100)
            );

            referrals[_referralId].totalReferred = referrals[_referralId]
                .totalReferred
                .add(1);
        } else {
            // Burn WIGO tokens from this contract
            IMasterFarmer(masterFarmer).wigoBurn(numberWigoToRegister);
        }

        // Increment the _countResidents counter and get residentId
        _countResidents.increment();
        uint256 newResidentId = _countResidents.current();

        // Add data to the struct for newResidentId
        residents[_msgSender()] = Resident({
            residentId: newResidentId,
            numberPoints: 0,
            planetId: _planetId,
            nftAddress: _nftAddress,
            tokenId: _tokenId,
            referral: _referralId,
            isActive: true
        });

        // Add data to the struct for newResidentId
        referrals[newResidentId] = Referral({
            residentAddress: _msgSender(),
            totalReferred: 0
        });

        // Update registration status
        hasRegistered[_msgSender()] = true;

        // Update number of active profiles
        numberActiveProfiles = numberActiveProfiles.add(1);

        // Increase the number of residents for the planet
        planets[_planetId].numberResidents = planets[_planetId]
            .numberResidents
            .add(1);

        // Emit an event
        emit ResidentNew(_msgSender(), _planetId, _nftAddress, _tokenId);
    }

    /**
     * @dev To pause resident profile. It releases the NFT.
     * Callable only by registered residents.
     */
    function pauseProfile() external {
        require(hasRegistered[_msgSender()], "Has not registered");

        // Checks whether resident has already paused
        require(residents[_msgSender()].isActive, "Resident not active");

        // Change status of resident to make it inactive
        residents[_msgSender()].isActive = false;

        // Retrieve the planetId of the resident calling
        uint256 residentPlanetId = residents[_msgSender()].planetId;

        // Reduce number of active residents and planet residents
        planets[residentPlanetId].numberResidents = planets[residentPlanetId]
            .numberResidents
            .sub(1);
        numberActiveProfiles = numberActiveProfiles.sub(1);

        // Interface to deposit the NFT contract
        IERC721 nftToken = IERC721(residents[_msgSender()].nftAddress);

        // tokenId of NFT redeemed
        uint256 redeemedTokenId = residents[_msgSender()].tokenId;

        // Change internal statuses as extra safety
        residents[_msgSender()].nftAddress = address(
            0x0000000000000000000000000000000000000000
        );

        residents[_msgSender()].tokenId = 0;

        // Transfer the NFT back to the resident
        nftToken.safeTransferFrom(address(this), _msgSender(), redeemedTokenId);

        // Emit event
        emit ResidentPause(_msgSender(), residentPlanetId);
    }

    /**
     * @dev To update resident profile.
     * Callable only by registered residents.
     */
    function updateProfile(address _nftAddress, uint256 _tokenId) external {
        require(hasRegistered[_msgSender()], "Has not registered");
        require(hasRole(NFT_ROLE, _nftAddress), "NFT address invalid");
        require(residents[_msgSender()].isActive, "Resident not active");

        address currentAddress = residents[_msgSender()].nftAddress;
        uint256 currentTokenId = residents[_msgSender()].tokenId;

        // Interface to deposit the NFT contract
        IERC721 nftNewToken = IERC721(_nftAddress);

        require(
            _msgSender() == nftNewToken.ownerOf(_tokenId),
            "Only NFT owner can update"
        );

        // Transfer token to new address
        nftNewToken.safeTransferFrom(_msgSender(), address(this), _tokenId);

        // Transfer WIGO token to this address
        wigoToken.safeTransferFrom(
            _msgSender(),
            address(this),
            numberWigoToUpdate
        );

        if (
            residents[_msgSender()].referral != 0 &&
            residents[
                referrals[residents[_msgSender()].referral].residentAddress
            ].isActive
        ) {
            address referralAddress = referrals[
                residents[_msgSender()].referral
            ].residentAddress;
            // Send rewards to referral (50% of Referral Fee)
            wigoToken.safeTransfer(
                referralAddress,
                (referralFeeShare.mul(numberWigoToUpdate)).div(200)
            );

            // Burn WIGO tokens from this contract
            IMasterFarmer(masterFarmer).wigoBurn(
                ((200 - referralFeeShare).mul(numberWigoToUpdate)).div(200)
            );
        } else {
            // Burn WIGO tokens from this contract
            IMasterFarmer(masterFarmer).wigoBurn(numberWigoToUpdate);
        }

        // Interface to deposit the NFT contract
        IERC721 nftCurrentToken = IERC721(currentAddress);

        // Transfer old token back to the owner
        nftCurrentToken.safeTransferFrom(
            address(this),
            _msgSender(),
            currentTokenId
        );

        // Update mapping in storage
        residents[_msgSender()].nftAddress = _nftAddress;
        residents[_msgSender()].tokenId = _tokenId;

        emit ResidentUpdate(_msgSender(), _nftAddress, _tokenId);
    }

    /**
     * @dev To reactivate resident profile.
     * Callable only by registered residents.
     */
    function reactivateProfile(address _nftAddress, uint256 _tokenId) external {
        require(hasRegistered[_msgSender()], "Has not registered");
        require(hasRole(NFT_ROLE, _nftAddress), "NFT address invalid");
        require(!residents[_msgSender()].isActive, "Resident is active");

        // Interface to deposit the NFT contract
        IERC721 nftToken = IERC721(_nftAddress);
        require(
            _msgSender() == nftToken.ownerOf(_tokenId),
            "Only NFT owner can update"
        );

        // Transfer to this address
        wigoToken.safeTransferFrom(
            _msgSender(),
            address(this),
            numberWigoToReactivate
        );

        if (
            residents[_msgSender()].referral != 0 &&
            residents[
                referrals[residents[_msgSender()].referral].residentAddress
            ].isActive
        ) {
            address referralAddress = referrals[
                residents[_msgSender()].referral
            ].residentAddress;
            // Send rewards to referral (50% of Referral Fee)
            wigoToken.safeTransfer(
                referralAddress,
                (referralFeeShare.mul(numberWigoToReactivate)).div(200)
            );

            // Burn WIGO tokens from this contract
            IMasterFarmer(masterFarmer).wigoBurn(
                ((200 - referralFeeShare).mul(numberWigoToReactivate)).div(200)
            );
        } else {
            // Burn WIGO tokens from this contract
            IMasterFarmer(masterFarmer).wigoBurn(numberWigoToReactivate);
        }

        // Transfer NFT to contract
        nftToken.safeTransferFrom(_msgSender(), address(this), _tokenId);

        // Retrieve planetId of the resident
        uint256 residentPlanetId = residents[_msgSender()].planetId;

        // Update number of residents for the planet and number of active profiles
        planets[residentPlanetId].numberResidents = planets[residentPlanetId]
            .numberResidents
            .add(1);
        numberActiveProfiles = numberActiveProfiles.add(1);

        // Update resident statuses
        residents[_msgSender()].isActive = true;
        residents[_msgSender()].nftAddress = _nftAddress;
        residents[_msgSender()].tokenId = _tokenId;

        // Emit event
        emit ResidentReactivate(
            _msgSender(),
            residentPlanetId,
            _nftAddress,
            _tokenId
        );
    }

    /**
     * @dev To increase the number of points for a resident.
     * Callable only by point admins
     */
    function increaseResidentPoints(
        address _residentAddress,
        uint256 _numberPoints,
        uint256 _campaignId,
        bool _withReferral
    ) external onlyPoint {
        if (_withReferral && residents[_residentAddress].referral != 0) {
            address referralAddress = referrals[
                residents[_residentAddress].referral
            ].residentAddress;
            // Increase the number of points for the referral
            residents[referralAddress].numberPoints = residents[referralAddress]
                .numberPoints
                .add((referralPointShare.mul(_numberPoints)).div(100));
        }
        // Increase the number of points for the resident
        residents[_residentAddress].numberPoints = residents[_residentAddress]
            .numberPoints
            .add(_numberPoints);

        emit ResidentPointIncrease(
            _residentAddress,
            _numberPoints,
            _campaignId
        );
    }

    /**
     * @dev To increase the number of points for a set of residents.
     * Callable only by point admins
     */
    function increaseResidentPointsMultiple(
        address[] calldata _residentAddresses,
        uint256 _numberPoints,
        uint256 _campaignId,
        bool _withReferral
    ) external onlyPoint {
        require(_residentAddresses.length < 1001, "Length must be < 1001");
        for (uint256 i = 0; i < _residentAddresses.length; i++) {
            if (
                _withReferral && residents[_residentAddresses[i]].referral != 0
            ) {
                address referralAddress = referrals[
                    residents[_residentAddresses[i]].referral
                ].residentAddress;
                // Increase the number of points for the referral
                residents[referralAddress].numberPoints = residents[
                    referralAddress
                ].numberPoints.add(
                        (referralPointShare.mul(_numberPoints)).div(100)
                    );
            }

            residents[_residentAddresses[i]].numberPoints = residents[
                _residentAddresses[i]
            ].numberPoints.add(_numberPoints);
        }
        emit ResidentPointIncreaseMultiple(
            _residentAddresses,
            _numberPoints,
            _campaignId
        );
    }

    /**
     * @dev To increase the number of points for a planet.
     * Callable only by point admins
     */

    function increasePlanetPoints(
        uint256 _planetId,
        uint256 _numberPoints,
        uint256 _campaignId
    ) external onlyPoint {
        // Increase the number of points for the planet
        planets[_planetId].numberPoints = planets[_planetId].numberPoints.add(
            _numberPoints
        );

        emit PlanetPointIncrease(_planetId, _numberPoints, _campaignId);
    }

    /**
     * @dev To remove the number of points for a resident.
     * Callable only by point admins
     */
    function removeResidentPoints(
        address _residentAddress,
        uint256 _numberPoints
    ) external onlyPoint {
        // Increase the number of points for the resident
        residents[_residentAddress].numberPoints = residents[_residentAddress]
            .numberPoints
            .sub(_numberPoints);
    }

    /**
     * @dev To remove a set number of points for a set of residents.
     */
    function removeResidentPointsMultiple(
        address[] calldata _residentAddresses,
        uint256 _numberPoints
    ) external onlyPoint {
        require(_residentAddresses.length < 1001, "Length must be < 1001");
        for (uint256 i = 0; i < _residentAddresses.length; i++) {
            residents[_residentAddresses[i]].numberPoints = residents[
                _residentAddresses[i]
            ].numberPoints.sub(_numberPoints);
        }
    }

    /**
     * @dev To remove the number of points for a planet.
     * Callable only by point admins
     */

    function decreasePlanetPoints(uint256 _planetId, uint256 _numberPoints)
        external
        onlyPoint
    {
        // Decrease the number of points for the planet
        planets[_planetId].numberPoints = planets[_planetId].numberPoints.sub(
            _numberPoints
        );
    }

    /**
     * @dev To add a NFT contract address for residents to set their profile.
     * Callable only by owner admins.
     */
    function addNftAddress(address _nftAddress) external onlyOwner {
        require(
            IERC721(_nftAddress).supportsInterface(0x80ac58cd),
            "Not ERC721"
        );
        grantRole(NFT_ROLE, _nftAddress);
    }

    /**
     * @dev Add a new planetId
     * Callable only by owner admins.
     */
    function addPlanet(
        string calldata _planetName,
        string calldata _planetDescription
    ) external onlyOwner {
        // Verify length is between 3 and 16
        bytes memory strBytes = bytes(_planetName);
        require(strBytes.length < 20, "Must be < 20");
        require(strBytes.length > 3, "Must be > 3");

        // Increment the _countPlanets counter and get planetId
        _countPlanets.increment();
        uint256 newPlanetId = _countPlanets.current();

        // Add new planet data to the struct
        planets[newPlanetId] = Planet({
            planetName: _planetName,
            planetDescription: _planetDescription,
            numberResidents: 0,
            numberPoints: 0,
            isJoinable: true
        });

        numberPlanets = newPlanetId;
        emit PlanetAdd(newPlanetId, _planetName);
    }

    /**
     * @dev Function to change planet.
     * Callable only by special admins.
     */
    function changePlanet(address _residentAddress, uint256 _newPlanetId)
        external
        onlySpecial
    {
        require(hasRegistered[_residentAddress], "Resident doesn't exist");
        require(
            (_newPlanetId <= numberPlanets) && (_newPlanetId > 0),
            "planetId doesn't exist"
        );
        require(planets[_newPlanetId].isJoinable, "Planet not joinable");
        require(
            residents[_residentAddress].planetId != _newPlanetId,
            "Already in the planet"
        );

        // Get old planetId
        uint256 oldPlanetId = residents[_residentAddress].planetId;

        // Change number of residents in old planet
        planets[oldPlanetId].numberResidents = planets[oldPlanetId]
            .numberResidents
            .sub(1);

        // Change planetId in resident mapping
        residents[_residentAddress].planetId = _newPlanetId;

        // Change number of residents in new planet
        planets[_newPlanetId].numberResidents = planets[_newPlanetId]
            .numberResidents
            .add(1);

        emit ResidentChangePlanet(_residentAddress, oldPlanetId, _newPlanetId);
    }

    /**
     * @dev to burn fee manually.
     * Callable only by owner admins.
     */
    function burnFee(uint256 _amount) external onlyOwner {
        IMasterFarmer(masterFarmer).wigoBurn(_amount);
    }

    /**
     * @dev Make a planet joinable again.
     * Callable only by owner admins.
     */
    function makePlanetJoinable(uint256 _planetId) external onlyOwner {
        require(
            (_planetId <= numberPlanets) && (_planetId > 0),
            "planetId invalid"
        );
        planets[_planetId].isJoinable = true;
    }

    /**
     * @dev Make a planet not joinable.
     * Callable only by owner admins.
     */
    function makePlanetNotJoinable(uint256 _planetId) external onlyOwner {
        require(
            (_planetId <= numberPlanets) && (_planetId > 0),
            "planetId invalid"
        );
        planets[_planetId].isJoinable = false;
    }

    /**
     * @dev Rename a planet
     * Callable only by owner admins.
     */
    function renamePlanet(
        uint256 _planetId,
        string calldata _planetName,
        string calldata _planetDescription
    ) external onlyOwner {
        require(
            (_planetId <= numberPlanets) && (_planetId > 0),
            "planetId invalid"
        );

        // Verify length is between 3 and 16
        bytes memory strBytes = bytes(_planetName);
        require(strBytes.length < 20, "Must be < 20");
        require(strBytes.length > 3, "Must be > 3");

        planets[_planetId].planetName = _planetName;
        planets[_planetId].planetDescription = _planetDescription;
    }

    /**
     * @dev Update the number of WIGO to register
     * Callable only by owner admins.
     */
    function updateNumberWigo(
        uint256 _newNumberWigoToReactivate,
        uint256 _newNumberWigoToRegister,
        uint256 _newNumberWigoToUpdate
    ) external onlyOwner {
        numberWigoToReactivate = _newNumberWigoToReactivate;
        numberWigoToRegister = _newNumberWigoToRegister;
        numberWigoToUpdate = _newNumberWigoToUpdate;
    }

    /**
     * @notice Sets referral share
     * @dev Callable only by owner admins.
     */
    function setReferralShare(
        uint256 _referralFeeShare,
        uint256 _referralPointShare
    ) external onlyOwner {
        require(
            _referralFeeShare <= MAX_REFERRAL_SHARE,
            "referralFeeShare cannot be more than MAX_REFERRAL_SHARE"
        );
        require(
            _referralPointShare <= MAX_REFERRAL_SHARE,
            "referralPointShare cannot be more than MAX_REFERRAL_SHARE"
        );
        referralFeeShare = _referralFeeShare;
        referralPointShare = _referralPointShare;
        emit SetReferralShare(
            msg.sender,
            _referralFeeShare,
            _referralPointShare
        );
    }

    /**
     * @dev Check the resident's profile for a given address
     */
    function getResidentProfile(address _residentAddress)
        external
        view
        returns (
            uint256,
            uint256,
            uint256,
            address,
            uint256,
            uint256,
            bool
        )
    {
        require(hasRegistered[_residentAddress], "Not registered");
        return (
            residents[_residentAddress].residentId,
            residents[_residentAddress].numberPoints,
            residents[_residentAddress].planetId,
            residents[_residentAddress].nftAddress,
            residents[_residentAddress].tokenId,
            residents[_residentAddress].referral,
            residents[_residentAddress].isActive
        );
    }

    /**
     * @dev Check the resident's status for a given address
     */
    function getResidentStatus(address _residentAddress)
        external
        view
        returns (bool)
    {
        return (residents[_residentAddress].isActive);
    }

    /**
     * @dev Check a planet's profile
     */
    function getPlanetProfile(uint256 _planetId)
        external
        view
        returns (
            string memory,
            string memory,
            uint256,
            uint256,
            bool
        )
    {
        require(
            (_planetId <= numberPlanets) && (_planetId > 0),
            "planetId invalid"
        );
        return (
            planets[_planetId].planetName,
            planets[_planetId].planetDescription,
            planets[_planetId].numberResidents,
            planets[_planetId].numberPoints,
            planets[_planetId].isJoinable
        );
    }

    /**
     * @dev Check total referred by resident
     */
    function getTotalReferred(address _residentAddress)
        external
        view
        returns (uint256)
    {
        require(hasRegistered[_residentAddress], "Resident doesn't exist");
        return (
            referrals[residents[_residentAddress].residentId].totalReferred
        );
    }

    /**
     * @dev Check a referral data
     */
    function getReferralData(address _residentAddress)
        external
        view
        returns (
            address,
            bool,
            uint256
        )
    {
        require(hasRegistered[_residentAddress], "Resident doesn't exist");
        return (
            referrals[residents[_residentAddress].referral].residentAddress,
            residents[
                referrals[residents[_residentAddress].referral].residentAddress
            ].isActive,
            referrals[residents[_residentAddress].referral].totalReferred
        );
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_wigoToken","type":"address"},{"internalType":"contract IMasterFarmer","name":"_masterFarmer","type":"address"},{"internalType":"uint256","name":"_numberWigoToReactivate","type":"uint256"},{"internalType":"uint256","name":"_numberWigoToRegister","type":"uint256"},{"internalType":"uint256","name":"_numberWigoToUpdate","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"planetId","type":"uint256"},{"indexed":false,"internalType":"string","name":"planetName","type":"string"}],"name":"PlanetAdd","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"planetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"numberPoints","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"campaignId","type":"uint256"}],"name":"PlanetPointIncrease","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"residentAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldPlanetId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newPlanetId","type":"uint256"}],"name":"ResidentChangePlanet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"residentAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"planetId","type":"uint256"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ResidentNew","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"residentAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"planetId","type":"uint256"}],"name":"ResidentPause","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"residentAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"numberPoints","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"campaignId","type":"uint256"}],"name":"ResidentPointIncrease","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"residentAddresses","type":"address[]"},{"indexed":false,"internalType":"uint256","name":"numberPoints","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"campaignId","type":"uint256"}],"name":"ResidentPointIncreaseMultiple","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"residentAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"planetId","type":"uint256"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ResidentReactivate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"residentAddress","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ResidentUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"uint256","name":"newReferralFeeShare","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"newReferralPointShare","type":"uint256"}],"name":"SetReferralShare","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_REFERRAL_SHARE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NFT_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POINT_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SPECIAL_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"}],"name":"addNftAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_planetName","type":"string"},{"internalType":"string","name":"_planetDescription","type":"string"}],"name":"addPlanet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burnFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_residentAddress","type":"address"},{"internalType":"uint256","name":"_newPlanetId","type":"uint256"}],"name":"changePlanet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_planetId","type":"uint256"},{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_referralId","type":"uint256"}],"name":"createProfile","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_planetId","type":"uint256"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"}],"name":"decreasePlanetPoints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_planetId","type":"uint256"}],"name":"getPlanetProfile","outputs":[{"internalType":"string","name":"","type":"string"},{"internalType":"string","name":"","type":"string"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_residentAddress","type":"address"}],"name":"getReferralData","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bool","name":"","type":"bool"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_residentAddress","type":"address"}],"name":"getResidentProfile","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_residentAddress","type":"address"}],"name":"getResidentStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_residentAddress","type":"address"}],"name":"getTotalReferred","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"hasRegistered","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_planetId","type":"uint256"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"},{"internalType":"uint256","name":"_campaignId","type":"uint256"}],"name":"increasePlanetPoints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_residentAddress","type":"address"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"},{"internalType":"uint256","name":"_campaignId","type":"uint256"},{"internalType":"bool","name":"_withReferral","type":"bool"}],"name":"increaseResidentPoints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_residentAddresses","type":"address[]"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"},{"internalType":"uint256","name":"_campaignId","type":"uint256"},{"internalType":"bool","name":"_withReferral","type":"bool"}],"name":"increaseResidentPointsMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_planetId","type":"uint256"}],"name":"makePlanetJoinable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_planetId","type":"uint256"}],"name":"makePlanetNotJoinable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"masterFarmer","outputs":[{"internalType":"contract IMasterFarmer","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberActiveProfiles","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberPlanets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberWigoToReactivate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberWigoToRegister","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberWigoToUpdate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pauseProfile","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"reactivateProfile","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"referralFeeShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"referralPointShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_residentAddress","type":"address"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"}],"name":"removeResidentPoints","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_residentAddresses","type":"address[]"},{"internalType":"uint256","name":"_numberPoints","type":"uint256"}],"name":"removeResidentPointsMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_planetId","type":"uint256"},{"internalType":"string","name":"_planetName","type":"string"},{"internalType":"string","name":"_planetDescription","type":"string"}],"name":"renamePlanet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_referralFeeShare","type":"uint256"},{"internalType":"uint256","name":"_referralPointShare","type":"uint256"}],"name":"setReferralShare","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newNumberWigoToReactivate","type":"uint256"},{"internalType":"uint256","name":"_newNumberWigoToRegister","type":"uint256"},{"internalType":"uint256","name":"_newNumberWigoToUpdate","type":"uint256"}],"name":"updateNumberWigo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"updateProfile","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wigoToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000e992beab6659bff447893641a378fbbf031c5bd6000000000000000000000000a1a938855735c0651a6cfe2e93a32a28a236d0e90000000000000000000000000000000000000000000000878678326eac90000000000000000000000000000000000000000000000000010f0cf064dd592000000000000000000000000000000000000000000000000000878678326eac900000

-----Decoded View---------------
Arg [0] : _wigoToken (address): 0xe992beab6659bff447893641a378fbbf031c5bd6
Arg [1] : _masterFarmer (address): 0xa1a938855735c0651a6cfe2e93a32a28a236d0e9
Arg [2] : _numberWigoToReactivate (uint256): 2500000000000000000000
Arg [3] : _numberWigoToRegister (uint256): 5000000000000000000000
Arg [4] : _numberWigoToUpdate (uint256): 2500000000000000000000

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000e992beab6659bff447893641a378fbbf031c5bd6
Arg [1] : 000000000000000000000000a1a938855735c0651a6cfe2e93a32a28a236d0e9
Arg [2] : 0000000000000000000000000000000000000000000000878678326eac900000
Arg [3] : 00000000000000000000000000000000000000000000010f0cf064dd59200000
Arg [4] : 0000000000000000000000000000000000000000000000878678326eac900000

49537:27721:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50083:37;;;:::i;:::-;;;;;;;;;;;;;;;;59345:2412;;;;;;;;;;;;;;;;-1:-1:-1;59345:2412:0;;;;;;;;;:::i;:::-;;74541:741;;;;;;;;;;;;;;;;-1:-1:-1;74541:741:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7335:207;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7335:207:0;;-1:-1:-1;7335:207:0;;-1:-1:-1;;;;;7335:207:0:i;:::-;;;;;;;;;;;;;;;;;;;43895:114;;;;;;;;;;;;;;;;-1:-1:-1;43895:114:0;;:::i;44271:264::-;;;;;;;;;;;;;;;;-1:-1:-1;44271:264:0;;;;;;;;;:::i;50127:35::-;;;:::i;70350:1193::-;;;;;;;;;;;;;;;;-1:-1:-1;70350:1193:0;;;;;;;;;:::i;45554:246::-;;;;;;;;;;;;;;;;-1:-1:-1;45554:246:0;;;;;;;;;:::i;64519:998::-;;;;;;;;;;;;;;;;-1:-1:-1;64519:998:0;;;;;;;;;;;;;;;;;;;;;:::i;71643:117::-;;;;;;;;;;;;;;;;-1:-1:-1;71643:117:0;;:::i;75369:178::-;;;;;;;;;;;;;;;;-1:-1:-1;75369:178:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;50169:33;;;:::i;69031:235::-;;;;;;;;;;;;;;;;-1:-1:-1;69031:235:0;;;;:::i;50294:38::-;;;:::i;75611:625::-;;;;;;;;;;;;;;;;-1:-1:-1;75611:625:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75611:625:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67572:331;;;;;;;;;;;;;;;;-1:-1:-1;67572:331:0;;;;;;;;;:::i;49705:23::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;68589:298;;;;;;;;;;;;;;;;-1:-1:-1;68589:298:0;;;;;;;:::i;72562:626::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72562:626:0;;-1:-1:-1;72562:626:0;-1:-1:-1;72562:626:0;:::i;50244:36::-;;;:::i;49735:33::-;;;:::i;43536:170::-;;;;;;;;;;;;;;;;-1:-1:-1;43536:170:0;;;;;;;:::i;67042:406::-;;;;;;;;;;;;;;;;-1:-1:-1;67042:406:0;;;;;;;;;;;;:::i;42497:139::-;;;;;;;;;;;;;;;;-1:-1:-1;42497:139:0;;;;;;;;;:::i;73304:363::-;;;;;;;;;;;;;;;;-1:-1:-1;73304:363:0;;;;;;;;;;;;:::i;73773:680::-;;;;;;;;;;;;;;;;-1:-1:-1;73773:680:0;;;;;;;:::i;71868:245::-;;;;;;;;;;;;;;;;-1:-1:-1;71868:245:0;;:::i;50348:45::-;;;;;;;;;;;;;;;;-1:-1:-1;50348:45:0;;;;:::i;41140:49::-;;;:::i;76677:578::-;;;;;;;;;;;;;;;;-1:-1:-1;76677:578:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61875:2518;;;;;;;;;;;;;;;;-1:-1:-1;61875:2518:0;;;;;;;;;:::i;76308:308::-;;;;;;;;;;;;;;;;-1:-1:-1;76308:308:0;;;;:::i;50041:35::-;;;:::i;49907:64::-;;;:::i;72219:249::-;;;;;;;;;;;;;;;;-1:-1:-1;72219:249:0;;:::i;57810:1421::-;;;:::i;49840:60::-;;;:::i;42810:127::-;;;;;;;;;;;;;;;;-1:-1:-1;42810:127:0;;:::i;54323:3353::-;;;;;;;;;;;;;;;;-1:-1:-1;54323:3353:0;;;;;;;;;;;;;;;;;;;:::i;49978:47::-;;;:::i;44780:267::-;;;;;;;;;;;;;;;;-1:-1:-1;44780:267:0;;;;;;;;;:::i;67999:466::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67999:466:0;-1:-1:-1;67999:466:0;;:::i;69363:880::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69363:880:0;;-1:-1:-1;69363:880:0;-1:-1:-1;69363:880:0;:::i;65651:1265::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65651:1265:0;-1:-1:-1;65651:1265:0;;;;;;;;;;;;;;:::i;50209:28::-;;;:::i;49777:56::-;;;:::i;50083:37::-;;;;:::o;59345:2412::-;59435:13;:27;59449:12;:10;:12::i;:::-;59435:27;;;;;;;;;;;;;-1:-1:-1;59435:27:0;;;;59427:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59504:30;49812:21;59522:11;59504:7;:30::i;:::-;59496:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59577:9;:23;59587:12;:10;:12::i;:::-;59577:23;;;;;;;;;;;;;-1:-1:-1;59577:23:0;:32;;;;;59569:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59646:22;59671:9;:23;59681:12;:10;:12::i;:::-;59671:23;;;;;;;;;;;;;;;-1:-1:-1;59671:23:0;;;:34;;;;;;;-1:-1:-1;59741:9:0;-1:-1:-1;59751:12:0;:10;:12::i;:::-;59741:23;;;;;;;;;;;;;;;:31;;;59716:56;;59835:19;59865:11;59835:42;;59928:11;:19;;;59948:8;59928:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59928:29:0;59912:45;;:12;:10;:12::i;:::-;:45;;;59890:120;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60065:11;:28;;;60094:12;:10;:12::i;:::-;60116:4;60123:8;60065:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60193:125;60234:12;:10;:12::i;:::-;60289:18;;60193:9;;;;;:125;60269:4;;60193:26;:125::i;:::-;60349:9;:23;60359:12;:10;:12::i;:::-;60349:23;;;;;;;;;;;;;-1:-1:-1;60349:23:0;:32;;;:37;;;;:165;;;60403:9;:102;60431:9;:43;60441:9;:23;60451:12;:10;:12::i;:::-;60441:23;;;;;;;;;;;;;;;;;;-1:-1:-1;60441:23:0;;;:32;;;60431:43;;;;;;;;;;;;;;:59;;;;60403:102;;;;;;;;;;;;:111;;;;;60349:165;60331:897;;;60541:23;60567:9;:75;60595:9;:23;60605:12;:10;:12::i;:::-;60595:23;;;;;;;;;;;;;;;:32;;;60567:75;;;;;;;;;;;:91;;;;;;;;;;;;60541:117;;60736:141;60777:15;60811:51;60858:3;60812:40;60833:18;;60812:16;;:20;;:40;;;;:::i;:::-;60811:46;;:51::i;:::-;60736:9;;;;;:141;:22;:141::i;:::-;60960:12;;61031:18;;61009:16;;60960:12;;;;;60946:36;;61001:59;;61056:3;;61002:48;;61003:22;;;61002:28;:48::i;61001:59::-;60946:129;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60331:897;;;;61174:12;;61197:18;;61160:56;;;;;;;;;;;;;;61174:12;;;;;61160:36;;:56;;;;;61174:12;;61160:56;;;;;;;;61174:12;;61160:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60331:897;61324:14;61401:32;;;;61456:4;61476:12;:10;:12::i;:::-;61503:14;61401:127;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61616:11;61579:9;:23;61589:12;:10;:12::i;:::-;61579:23;;;;;;;;;;;;;;;:34;;;:48;;;;;;;;;;;;;;;;;;61672:8;61638:9;:23;61648:12;:10;:12::i;:::-;61638:23;;;;;;;;;;;;;-1:-1:-1;61638:23:0;:31;;:42;61713:12;:10;:12::i;:::-;61698:51;;;61727:11;61740:8;61698:51;;;;;;;;;;;;;;;;;;;;;;;;;;59345:2412;;;;;;:::o;74541:741::-;74831:31;;;74659:7;74831:31;;;:13;:31;;;;;;74659:7;;;;;;;;;;;;74831:31;;74823:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;74914:27:0;;;;;;;;:9;:27;;;;;:38;;74967:40;;;;75022:36;;;;75073:38;;;;75126:35;;;;75176:36;;;;75227;;;;;74914:38;;74967:40;;75022:36;;-1:-1:-1;75073:38:0;;;-1:-1:-1;75126:35:0;-1:-1:-1;75227:36:0;;;;;74541:741::o;7335:207::-;7504:30;7335:207;;;;;;:::o;43895:114::-;43952:7;43979:12;;;;;;;;;;:22;;;;43895:114::o;44271:264::-;44377:6;:12;;;;;;;;;;:22;;;44369:45;;44401:12;:10;:12::i;:::-;44369:7;:45::i;:::-;44347:142;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44502:25;44513:4;44519:7;44502:10;:25::i;:::-;44271:264;;:::o;50127:35::-;;;;:::o;70350:1193::-;53054:35;49946:25;53076:12;:10;:12::i;53054:35::-;53046:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70483:31:::1;::::0;::::1;;::::0;;;:13:::1;:31;::::0;;;;;::::1;;70475:66;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;70591:13;;70575:12;:29;;70574:53;;;;;70625:1;70610:12;:16;70574:53;70552:125;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;70696:21;::::0;;;:7:::1;:21;::::0;;;;:32:::1;;::::0;::::1;;70688:64;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;70785:27;::::0;::::1;;::::0;;;:9:::1;:27;::::0;;;;:36:::1;;::::0;:52;::::1;;70763:123;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;70950:27;::::0;::::1;70928:19;70950:27:::0;;;:9:::1;:27;::::0;;;;;;;:36:::1;::::0;;::::1;::::0;71091:20;;;:7:::1;:20:::0;;;;;:50;;::::1;::::0;:71:::1;::::0;71160:1:::1;71091:68;:71::i;:::-;71052:20;::::0;;;:7:::1;:20;::::0;;;;;;;:36:::1;::::0;;::::1;:110:::0;;;;71223:27:::1;::::0;::::1;::::0;;:9:::1;:27:::0;;;;;:36;::::1;:51:::0;;;71380:21;;;;;;;;:51:::1;::::0;:72:::1;::::0;71450:1:::1;71380:69;:72::i;:::-;71340:21;::::0;;;:7:::1;:21;::::0;;;;;;;;:37:::1;;:112:::0;;;;71470:65;;;;;;;::::1;::::0;;;;;::::1;::::0;::::1;::::0;::::1;::::0;;;;;;;::::1;53124:1;70350:1193:::0;;:::o;45554:246::-;45666:12;:10;:12::i;:::-;45655:23;;:7;:23;;;45633:120;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45766:26;45778:4;45784:7;45766:11;:26::i;64519:998::-;52894:33;49877:23;52914:12;:10;:12::i;52894:33::-;52886:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64718:13:::1;:58;;;;-1:-1:-1::0;64735:27:0::1;::::0;::::1;;::::0;;;:9:::1;:27;::::0;;;;:36:::1;;::::0;:41;::::1;64718:58;64714:461;;;64847:27;::::0;;::::1;64793:23;64847:27:::0;;;:9:::1;:27;::::0;;;;;;;:36:::1;;::::0;64819:79;;:9:::1;:79:::0;;;;;:95;65115:18:::1;::::0;64819:95;::::1;::::0;65034:129:::1;::::0;65114:48:::1;::::0;65158:3:::1;::::0;65115:37:::1;::::0;65138:13;65115:22:::1;:37::i;65114:48::-;65034:26;::::0;::::1;;::::0;;;:9:::1;:26;::::0;;;;:57:::1;;::::0;;:79:::1;:129::i;:::-;64992:26;::::0;;::::1;;::::0;;;:9:::1;:26;::::0;;;;:39:::1;;:171:::0;64714:461:::1;65287:27;::::0;::::1;;::::0;;;:9:::1;:27;::::0;;;;:54:::1;;::::0;:87:::1;::::0;65360:13;65287:72:::1;:87::i;:::-;65244:27;::::0;::::1;;::::0;;;:9:::1;:27;::::0;;;;;;;;:40:::1;;:130:::0;;;;65392:117;;;;;;;65487:11;;65392:117:::1;::::0;;;;;;::::1;64519:998:::0;;;;:::o;71643:117::-;52706:41;41185:4;52734:12;:10;:12::i;52706:41::-;52684:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71721:12:::1;::::0;71707:45:::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;71721:12:::1;::::0;;::::1;::::0;71707:36:::1;::::0;:45;;;;;71721:12:::1;::::0;71707:45;;;;;;;;71721:12;;71707:45;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;71643:117:::0;:::o;75369:178::-;75502:27;;75472:4;75502:27;;;:9;:27;;;;;:36;;;;;;75369:178::o;50169:33::-;;;;:::o;69031:235::-;52706:41;41185:4;52734:12;:10;:12::i;52706:41::-;52684:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69127:50:::1;::::0;;;;;;::::1;::::0;::::1;::::0;;;:38:::1;::::0;::::1;::::0;::::1;::::0;:50;;;;;::::1;::::0;;;;;;;;:38;:50;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;69127:50:0;69105:110:::1;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;69226:32;49812:21;69246:11;69226:9;:32::i;:::-;69031:235:::0;:::o;50294:38::-;;;;:::o;75611:625::-;75720:13;75748;75776:7;75798;75820:4;75888:13;;75875:9;:26;;75874:47;;;;;75919:1;75907:9;:13;75874:47;75852:113;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75998:18;;;;:7;:18;;;;;;;;;76093:34;;;;;76142:31;;;;76188:29;;;;75976:252;;;;;;76042:36;75976:252;;;;76188:29;75976:252;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75998:18;;76042:36;;;;76093:34;;76142:31;;76188:29;;;;;75998:18;;75976:252;;;75998:18;75976:252;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;75976:252:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75976:252:0;;-1:-1:-1;75976:252:0;-1:-1:-1;75976:252:0;;;-1:-1:-1;75976:252:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75976:252:0;;;;-1:-1:-1;75976:252:0;;-1:-1:-1;75976:252:0;;-1:-1:-1;75976:252:0;;-1:-1:-1;75611:625:0;-1:-1:-1;;;;;;;75611:625:0:o;67572:331::-;52894:33;49877:23;52914:12;:10;:12::i;52894:33::-;52886:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67808:27:::1;::::0;::::1;;::::0;;;:9:::1;:27;::::0;;;;:54:::1;;::::0;:87:::1;::::0;67881:13;67808:72:::1;:87::i;:::-;67765:27;::::0;;::::1;;::::0;;;:9:::1;:27;::::0;;;;:40:::1;;:130:::0;;;;-1:-1:-1;67572:331:0:o;49705:23::-;;;;;;:::o;68589:298::-;52894:33;49877:23;52914:12;:10;:12::i;52894:33::-;52886:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68805:18:::1;::::0;;;:7:::1;:18;::::0;;;;:31:::1;;::::0;:74:::1;::::0;68855:13;68805:35:::1;:74::i;:::-;68771:18;::::0;;;:7:::1;:18;::::0;;;;;:31:::1;;:108:::0;;;;-1:-1:-1;68589:298:0:o;72562:626::-;52706:41;41185:4;52734:12;:10;:12::i;52706:41::-;52684:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72768:13:::1;;72755:9;:26;;72754:47;;;;;72799:1;72787:9;:13;72754:47;72732:113;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;72904:21;72934:11;;72904:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;72965:15:0;;72904:42;;-1:-1:-1;;72983:2:0::1;72965:20:::0;;::::1;::::0;-1:-1:-1;72957:45:0::1;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;73039:1;73021:8;:15;:19;73013:43;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;73069:18;::::0;;;:7:::1;:18;::::0;;;;:43:::1;::::0;73101:11;;73069:43:::1;:::i;:::-;-1:-1:-1::0;73123:18:0::1;::::0;;;:7:::1;:18;::::0;;;;:57:::1;::::0;:36:::1;;73162:18:::0;;73123:57:::1;:::i;:::-;;52804:1;72562:626:::0;;;;;:::o;50244:36::-;;;;:::o;49735:33::-;;;;;;:::o;43536:170::-;43636:7;43668:12;;;;;;;;;;:30;;43692:5;43668:23;:30::i;:::-;43661:37;;43536:170;;;;;:::o;67042:406::-;52894:33;49877:23;52914:12;:10;:12::i;52894:33::-;52886:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67290:18:::1;::::0;;;:7:::1;:18;::::0;;;;:31:::1;;::::0;:74:::1;::::0;67340:13;67290:35:::1;:74::i;:::-;67256:7;:18;67264:9;67256:18;;;;;;;;;;;:31;;:108;;;;67428:11;67402:9;67382:58;67413:13;67382:58;;;;;;;;;;;;;;;;;;67042:406:::0;;;:::o;42497:139::-;42566:4;42590:12;;;;;;;;;;:38;;42620:7;42590:29;:38::i;73304:363::-;52706:41;41185:4;52734:12;:10;:12::i;52706:41::-;52684:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73496:22:::1;:51:::0;;;;73558:20:::1;:47:::0;73616:18:::1;:43:::0;73304:363::o;73773:680::-;52706:41;41185:4;52734:12;:10;:12::i;52706:41::-;52684:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50023:2:::1;73932:17;:39;;73910:144;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50023:2;74087:19;:41;;74065:148;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74224:16;:36:::0;;;74271:18:::1;:40:::0;;;74327:118:::1;::::0;74292:19;;74243:17;;74358:10:::1;::::0;74327:118:::1;::::0;-1:-1:-1;;74327:118:0::1;73773:680:::0;;:::o;71868:245::-;52706:41;41185:4;52734:12;:10;:12::i;52706:41::-;52684:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71981:13:::1;;71968:9;:26;;71967:47;;;;;72012:1;72000:9;:13;71967:47;71945:113;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;72069:18;::::0;;;:7:::1;:18;::::0;;;;:29:::1;;:36:::0;;;::::1;72101:4;72069:36;::::0;;71868:245::o;50348:45::-;;;;;;;;;;;;;;;:::o;41140:49::-;41185:4;41140:49;:::o;76677:578::-;76876:31;;;76792:7;76876:31;;;:13;:31;;;;;;76792:7;;;;76876:31;;76868:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;76977:27:0;;;;76967:47;76977:27;;;:9;:27;;;;;;;;:36;;;76967:47;;;:9;:47;;;;;;:63;;;;;77045:106;;;;;;;;;:115;;;77175:47;;;;76967:63;77175:61;;;;76967:63;;77045:115;;;;;77175:61;76677:578::o;61875:2518::-;61969:13;:27;61983:12;:10;:12::i;:::-;61969:27;;;;;;;;;;;;;-1:-1:-1;61969:27:0;;;;61961:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62038:30;49812:21;62056:11;62038:7;:30::i;:::-;62030:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62112:9;:23;62122:12;:10;:12::i;:::-;62112:23;;;;;;;;;;;;;-1:-1:-1;62112:23:0;:32;;;;;62111:33;62103:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62230:16;62257:11;62230:39;;62318:8;:16;;;62335:8;62318:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62318:26:0;62302:42;;:12;:10;:12::i;:::-;:42;;;62280:117;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62447:129;62488:12;:10;:12::i;:::-;62543:22;;62447:9;;;;;:129;62523:4;;62447:26;:129::i;:::-;62607:9;:23;62617:12;:10;:12::i;:::-;62607:23;;;;;;;;;;;;;-1:-1:-1;62607:23:0;:32;;;:37;;;;:165;;;62661:9;:102;62689:9;:43;62699:9;:23;62709:12;:10;:12::i;:::-;62699:23;;;;;;;;;;;;;;;;;;-1:-1:-1;62699:23:0;;;:32;;;62689:43;;;;;;;;;;;;;;:59;;;;62661:102;;;;;;;;;;;;:111;;;;;62607:165;62589:909;;;62799:23;62825:9;:75;62853:9;:23;62863:12;:10;:12::i;:::-;62853:23;;;;;;;;;;;;;;;:32;;;62825:75;;;;;;;;;;;:91;;;;;;;;;;;;62799:117;;62994:145;63035:15;63069:55;63120:3;63070:44;63091:22;;63070:16;;:20;;:44;;;;:::i;62994:145::-;63222:12;;63293:22;;63271:16;;63222:12;;;;;63208:36;;63263:63;;63322:3;;63264:52;;63265:22;;;63264:28;:52::i;63263:63::-;63208:133;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62589:909;;;;63440:12;;63463:22;;;63426:60;;;;;;;;;;;;;;63440:12;;;;;63426:36;;:60;;;;;63440:12;;63426:60;;;;;;;;63440:12;;63426:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62589:909;63547:8;:25;;;63573:12;:10;:12::i;:::-;63595:4;63602:8;63547:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63670:24;63697:9;:23;63707:12;:10;:12::i;:::-;63697:23;;;;;;;;;;;;;;;:32;;;63670:59;;63870:76;63944:1;63870:7;:25;63878:16;63870:25;;;;;;;;;;;:55;;;:73;;:76;;;;:::i;:::-;63826:25;;;;:7;:25;;;;;:41;;:120;63980:20;;:27;;64005:1;63980:24;:27::i;:::-;63957:20;:50;64092:4;64057:9;:23;64067:12;:10;:12::i;:::-;64057:23;;;;;;;;;;;;;;;:32;;;:39;;;;;;;;;;;;;;;;;;64144:11;64107:9;:23;64117:12;:10;:12::i;:::-;64107:23;;;;;;;;;;;;;;;:34;;;:48;;;;;;;;;;;;;;;;;;64200:8;64166:9;:23;64176:12;:10;:12::i;:::-;64166:23;;;;;;;;;;;;;-1:-1:-1;64166:23:0;:31;;:42;64282:12;:10;:12::i;:::-;64249:136;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61875:2518;;;;:::o;76308:308::-;76443:31;;;76410:7;76443:31;;;:13;:31;;;;;;;;76435:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76544:27:0;;76534:49;76544:27;;;:9;:27;;;;;;;;:38;76534:49;;:9;:49;;;;;:63;;;;76308:308::o;50041:35::-;;;;:::o;49907:64::-;49946:25;49907:64;:::o;72219:249::-;52706:41;41185:4;52734:12;:10;:12::i;52706:41::-;52684:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72335:13:::1;;72322:9;:26;;72321:47;;;;;72366:1;72354:9;:13;72321:47;72299:113;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;72455:5;72423:18:::0;;;:7:::1;:18;::::0;;;;:29:::1;;:37:::0;;;::::1;::::0;;72219:249::o;57810:1421::-;57862:13;:27;57876:12;:10;:12::i;:::-;57862:27;;;;;;;;;;;;;-1:-1:-1;57862:27:0;;;;57854:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57988:9;:23;57998:12;:10;:12::i;:::-;57988:23;;;;;;;;;;;;;-1:-1:-1;57988:23:0;:32;;;;;57980:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58150:5;58115:9;:23;58125:12;:10;:12::i;:::-;58115:23;;;;;;;;;;;;;-1:-1:-1;58115:23:0;;;:32;;:40;;;;;;;;;;;;;;58253:9;-1:-1:-1;58263:12:0;:10;:12::i;:::-;58253:23;;;;;;;;;;;;;;;:32;;;58226:59;;58409:76;58483:1;58409:7;:25;58417:16;58409:25;;;;;;;;;;;:55;;;:73;;:76;;;;:::i;:::-;58365:25;;;;:7;:25;;;;;:41;;:120;58519:20;;:27;;58544:1;58519:24;:27::i;:::-;58496:20;:50;58609:16;58636:9;58609:16;58646:12;:10;:12::i;:::-;58636:23;;;;;;;;;;;;;;;-1:-1:-1;58636:23:0;;;:34;;;;;;;-1:-1:-1;58746:9:0;-1:-1:-1;58756:12:0;:10;:12::i;:::-;58746:23;;;;;;;;;;;;;;;:31;;;58720:57;;58902:42;58843:9;:23;58853:12;:10;:12::i;:::-;58843:23;;;;;;;;;;;;;;;:34;;;:112;;;;;;;;;;;;;;;;;;59002:1;58968:9;:23;58978:12;:10;:12::i;:::-;58968:23;;;;;;;;;;;;;;;:31;;:35;;;;59066:8;:25;;;59100:4;59107:12;:10;:12::i;:::-;59121:15;59066:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59192:12;:10;:12::i;:::-;59178:45;;;59206:16;59178:45;;;;;;;;;;;;;;;;;;57810:1421;;;:::o;49840:60::-;49877:23;49840:60;:::o;42810:127::-;42873:7;42900:12;;;;;;;;;;:29;;:27;:29::i;54323:3353::-;54497:13;:27;54511:12;:10;:12::i;:::-;54497:27;;;;;;;;;;;;;-1:-1:-1;54497:27:0;;;;54496:28;54488:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54594:13;;54581:9;:26;;54580:47;;;;;54625:1;54613:9;:13;54580:47;54558:113;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54690:18;;;;:7;:18;;;;;:29;;;;;54682:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54762:30;49812:21;54780:11;54762:7;:30::i;:::-;54754:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54831:16;;54827:303;;54864:23;54890:22;;;:9;:22;;;;;;;;:38;;;54966:30;;;:13;:30;;;;;;;;;54965:31;;:88;;-1:-1:-1;55018:26:0;;;;;;;:9;:26;;;;;:35;;;;;55017:36;54965:88;54943:176;;;55102:1;55088:15;;54943:176;54827:303;;55202:16;55229:11;55202:39;;55292:8;:16;;;55309:8;55292:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55292:26:0;55276:42;;:12;:10;:12::i;:::-;:42;;;55254:119;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55428:8;:25;;;55454:12;:10;:12::i;:::-;55476:4;55483:8;55428:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55555:127;55596:12;:10;:12::i;:::-;55651:20;;55555:9;;;;;:127;55631:4;;55555:26;:127::i;:::-;55697:16;;55693:790;;55730:23;55756:22;;;:9;:22;;;;;:38;55947:20;;55926:16;;55756:38;;;;;55850:143;;55756:38;;55925:53;;55974:3;;55926:42;;:20;:42::i;55850:143::-;56076:12;;56147:20;;56125:16;;56076:12;;;;;56062:36;;56117:61;;56174:3;;56118:50;;56119:22;;;56118:28;:50::i;56117:61::-;56062:131;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;56249:22:0;;;;:9;:22;;;;;56326:1;56249:54;;;;:79;;-1:-1:-1;56249:54:0;:76;:79::i;:::-;56210:22;;;;:9;:22;;;;;:36;;:118;-1:-1:-1;55693:790:0;;;56427:12;;56450:20;;56413:58;;;;;;;;;;;;;;56427:12;;;;;56413:36;;:58;;;;;56427:12;;56413:58;;;;;;;;56427:12;;56413:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55693:790;56564:27;:15;:25;:27::i;:::-;56602:21;56626:25;:15;:23;:25::i;:::-;56602:49;;56743:260;;;;;;;;56779:13;56743:260;;;;56821:1;56743:260;;;;56847:9;56743:260;;;;56883:11;56743:260;;;;;;56918:8;56743:260;;;;56951:11;56743:260;;;;56987:4;56743:260;;;;;56717:9;:23;56727:12;:10;:12::i;:::-;56717:23;;;;;;;;;;;;;;;;;;-1:-1:-1;56717:23:0;:286;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57096:96;;;;;;;;;57137:12;:10;:12::i;:::-;57096:96;;;;;;57179:1;57096:96;;;;;;;57069:24;;;:9;:24;;;;;:123;;;;;;;;;;;;;;;;;;;-1:-1:-1;57069:123:0;;;;-1:-1:-1;57244:13:0;;57258:12;:10;:12::i;:::-;57244:27;;;;;;;;;;;;;-1:-1:-1;57244:27:0;:34;;;;;;;;;;;;;57359:20;;:27;;-1:-1:-1;57359:24:0;:27::i;:::-;57336:20;:50;57496:18;;;;:7;:18;;;;;:48;;;:69;;57563:1;57496:66;:69::i;:::-;57459:18;;;;:7;:18;;;;;:34;;:106;57621:12;:10;:12::i;:::-;57609:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54323:3353;;;;;;:::o;49978:47::-;50023:2;49978:47;:::o;44780:267::-;44887:6;:12;;;;;;;;;;:22;;;44879:45;;44911:12;:10;:12::i;44879:45::-;44857:143;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67999:466;52894:33;49877:23;52914:12;:10;:12::i;52894:33::-;52886:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68190:4:::1;68162:32:::0;::::1;68154:66;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;68236:9;68231:227;68251:29:::0;;::::1;68231:227;;;68350:96;68432:13;68350:9;:64;68378:18;;68397:1;68378:21;;;;;;;;;;;;;;;68350:64;;;;;;;;;;;;;;;:77;;;:81;;:96;;;;:::i;:::-;68302:9;:32;68312:18;;68331:1;68312:21;;;;;;;;;;;;;;;68302:32;;;;;;;;;;;;;;;:45;;:144;;;;68282:3;;;;;;;68231:227;;;;67999:466:::0;;;:::o;69363:880::-;52706:41;41185:4;52734:12;:10;:12::i;52706:41::-;52684:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69548:21:::1;69578:11;;69548:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;69609:15:0;;69548:42;;-1:-1:-1;;69627:2:0::1;69609:20:::0;;::::1;::::0;-1:-1:-1;69601:45:0::1;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;69683:1;69665:8;:15;:19;69657:43;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;69778:25;:13;:23;:25::i;:::-;69814:19;69836:23;:13;:21;:23::i;:::-;69941:203;::::0;;;::::1;;::::0;::::1;::::0;;::::1;;::::0;;;;;;;::::1;::::0;::::1;::::0;;;69814:45;;-1:-1:-1;69941:203:0;;;69975:11;;;;;;69941:203;;69975:11;;;;69941:203;::::1;;::::0;::::1;::::0;;;;-1:-1:-1;;;69941:203:0;;;-1:-1:-1;69941:203:0::1;::::0;;::::1;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;;;;::::1;::::0;;70020:18;;;;;;69941:203;::::1;70020:18:::0;;;;69941:203;::::1;;::::0;::::1;::::0;;;-1:-1:-1;69941:203:0;;;-1:-1:-1;;;69941:203:0::1;::::0;;::::1;::::0;;;;;;;;;;70128:4:::1;69941:203:::0;;;;;;;;69918:20;;;:7:::1;:20:::0;;;;;:226;;;;:20;;:226:::1;::::0;:20;;:226;;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;69918:226:0::1;::::0;;::::1;::::0;;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;69918:226:0::1;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;;70157:13:::1;:27:::0;;;70200:35;;;;;::::1;::::0;::::1;::::0;;;;;;;;;::::1;::::0;70157:27;;70223:11;;70200:35;;;;;;;70223:11;70200:35;;70223:11;70200:35;::::1;;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;70200:35:0;;-1:-1:-1;;;;;70200:35:0::1;52804:1;;69363:880:::0;;;;:::o;65651:1265::-;52894:33;49877:23;52914:12;:10;:12::i;52894:33::-;52886:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65903:4:::1;65875:32:::0;::::1;65867:66;;;::::0;;::::1;::::0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;65949:9;65944:822;65964:29:::0;;::::1;65944:822;;;66037:13;:63;;;;;66054:9;:32;66064:18;;66083:1;66064:21;;;;;;;;;;;;;;;66054:32;;;;;;;;;;;;;;;:41;;;66099:1;66054:46;;66037:63;66015:579;;;66135:23;66161:9;:92;66193:9;:32;66203:18;;66222:1;66203:21;;;;;;;;;;;;;;;66193:32;;;;;;;;;;;;;;;:41;;;66161:92;;;;;;;;;;;:108;;;;;;;;;;;;66135:134;;66397:181;66507:48;66551:3;66508:37;66531:13;66508:18;;:22;;:37;;;;:::i;66397:181::-;66355:26;::::0;;::::1;;::::0;;;:9:::1;:26;::::0;;;;:39:::1;;:223:::0;66015:579:::1;66658:96;66740:13;66658:9;:64;66686:18;;66705:1;66686:21;;;;;;;;;;;;;;;66658:64;;;;;;;;;;;;;;;:77;;;:81;;:96;;;;:::i;:::-;66610:9;:32;66620:18;;66639:1;66620:21;;;;;;;;;;;;;;;66610:32;;;;;;;;;;;;;;;:45;;:144;;;;65995:3;;;;;;;65944:822;;;;66886:11;66781:127;66825:18;;66858:13;66781:127;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;66781:127:0;;-1:-1:-1;;;;;66781:127:0::1;65651:1265:::0;;;;;:::o;50209:28::-;;;;:::o;49777:56::-;49812:21;49777:56;:::o;36203:166::-;36291:4;36320:41;36325:3;36345:14;;;36320:4;:41::i;28956:106::-;29044:10;28956:106;:::o;24841:285::-;25039:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25062:27;25039:68;;;24985:133;;25019:5;;24985:19;:133::i;13177:471::-;13235:7;13480:6;13476:47;;-1:-1:-1;13510:1:0;13503:8;;13476:47;13547:5;;;13551:1;13547;:5;:1;13571:5;;;;;:10;13563:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14124:132;14182:7;14209:39;14213:1;14216;14209:39;;;;;;;;;;;;;;;;;:3;:39::i;24585:248::-;24756:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24779:23;24756:58;;;24702:123;;24736:5;;24702:19;:123::i;:::-;24585:248;;;:::o;46834:188::-;46908:6;:12;;;;;;;;;;:33;;46933:7;46908:24;:33::i;:::-;46904:111;;;46990:12;:10;:12::i;:::-;46963:40;;46981:7;46963:40;;46975:4;46963:40;;;;;;;;;;46834:188;;:::o;12253:136::-;12311:7;12338:43;12342:1;12345;12338:43;;;;;;;;;;;;;;;;;:3;:43::i;11789:181::-;11847:7;11879:5;;;11903:6;;;;11895:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47030:192;47105:6;:12;;;;;;;;;;:36;;47133:7;47105:27;:36::i;:::-;47101:114;;;47190:12;:10;:12::i;:::-;47163:40;;47181:7;47163:40;;47175:4;47163:40;;;;;;;;;;47030:192;;:::o;37550:181::-;37651:7;37699:22;37703:3;37715:5;37699:3;:22::i;36803:190::-;36910:4;36939:46;36949:3;36969:14;;;36939:9;:46::i;37079:117::-;37142:7;37169:19;37177:3;37169:7;:19::i;48468:181::-;48622:19;;48640:1;48622:19;;;48468:181::o;48346:114::-;48438:14;;48346:114::o;31023:414::-;31086:4;31108:21;31118:3;31123:5;31108:9;:21::i;:::-;31103:327;;-1:-1:-1;31146:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;31329:18;;31307:19;;;:12;;;:19;;;;;;:40;;;;31362:11;;31103:327;-1:-1:-1;31413:5:0;31406:12;;27461:860;27885:23;27911:106;27953:4;27911:106;;;;;;;;;;;;;;;;;27919:5;27911:27;;;;:106;;;;;:::i;:::-;28032:17;;27885:132;;-1:-1:-1;28032:21:0;28028:286;;28205:10;28194:30;;;;;;;;;;;;;;;-1:-1:-1;28194:30:0;28168:134;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14752:312;14872:7;14907:12;14900:5;14892:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14931:9;14947:1;14943;:5;;;;;;;-1:-1:-1;;14752:312:0;;;;;;:::o;12692:226::-;12812:7;12848:12;12840:6;;;;12832:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;12884:5:0;;;12692:226::o;36545:172::-;36636:4;36665:44;36673:3;36693:14;;;36665:7;:44::i;33966:273::-;34107:18;;34060:7;;34107:26;-1:-1:-1;34085:110:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34213:3;:11;;34225:5;34213:18;;;;;;;;;;;;;;;;34206:25;;33966:273;;;;:::o;33256:161::-;33356:4;33385:19;;;:12;;;;;:19;;;;;;:24;;;33256:161::o;20156:229::-;20293:12;20325:52;20347:6;20355:4;20361:1;20364:12;20325:21;:52::i;:::-;20318:59;20156:229;-1:-1:-1;;;;20156:229:0:o;31613:1557::-;31679:4;31818:19;;;:12;;;:19;;;;;;31854:15;;31850:1313;;32302:18;;32253:14;;;;;32302:22;;;;32229:21;;32302:3;;:22;;32589;;;;;;;;;;;;;;32569:42;;32735:9;32706:3;:11;;32718:13;32706:26;;;;;;;;;;;;;;;;;;;:38;;;;32812:23;;;32854:1;32812:12;;;:23;;;;;;32838:17;;;32812:43;;32964:17;;32812:3;;32964:17;;;;;;;;;;;;;;;;;;;;;;33059:3;:12;;:19;33072:5;33059:19;;;;;;;;;;;33052:26;;;33102:4;33095:11;;;;;;;;31850:1313;33146:5;33139:12;;;;;21372:632;21542:12;21614:5;21589:21;:30;;21567:118;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21704:18;21715:6;21704:10;:18::i;:::-;21696:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21830:12;21844:23;21871:6;:11;;21890:5;21911:4;21871:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21829:97;;;;21944:52;21962:7;21971:10;21983:12;21944:17;:52::i;:::-;21937:59;21372:632;-1:-1:-1;;;;;;;21372:632:0:o;17119:444::-;17499:20;17547:8;;;17119:444::o;23155:777::-;23305:12;23334:7;23330:595;;;-1:-1:-1;23365:10:0;23358:17;;23330:595;23479:17;;:21;23475:439;;23742:10;23736:17;23803:15;23790:10;23786:2;23782:19;23775:44;23690:148;23878:20;;;;;;;;;;;;;;;;;;;;23885:12;;23878:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ipfs://e195e9b686e5f4c9f4cc7133194fa0321f53573d6b7c4eaf19848485232447e9