Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "../Interface/IMetaX.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract SocialMining is AccessControl, Ownable {
    using SafeMath for uint256;

    /** Roles **/
    bytes32 public constant Admin = keccak256("Admin");

    /* Initialize Today as the first release time | Admin roles */
    constructor(
        uint256 _Today
    ) {
        Today = _Today;
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(Admin, msg.sender);
    }

    /** Smart Contracts Preset **/
    /* $MetaX */
    address public MetaX_Addr;
    IERC20 public MX;

    function setMetaX(address _MetaX_Addr) public onlyOwner {
        MetaX_Addr = _MetaX_Addr;
        MX = IERC20(_MetaX_Addr);
    }

    /* PlanetMan */
    address public PlanetMan_Addr;
    IERC721 public PM;

    function setPlanetMan(address _PlanetMan_Addr) public onlyOwner {
        PlanetMan_Addr = _PlanetMan_Addr;
        PM = IERC721(_PlanetMan_Addr);
    }

    /* X-Power */
    address public XPower_Addr;
    IMetaX public XP;

    function setXPower(address _XPower_Addr) public onlyOwner {
        XPower_Addr = _XPower_Addr;
        XP = IMetaX(_XPower_Addr);
    }

    /* PlanetGenesis */
    address public PlanetGenesis_Addr;
    IERC721 public PG;

    function setPlanetGenesis(address _PlanetGenesis_Addr) public onlyOwner {
        PlanetGenesis_Addr = _PlanetGenesis_Addr;
        PG = IERC721(_PlanetGenesis_Addr);
    }

    /* POSW */
    address public POSW_Addr;
    IMetaX public POSW;

    function setPOSW(address _POSW_Addr) public onlyOwner {
        POSW_Addr = _POSW_Addr;
        POSW = IMetaX(_POSW_Addr);
    }

    /* PlanetBadges */
    address public PlanetBadges_Addr;
    IMetaX public PB;

    function setPlanetBadges(address _PlanetBadges_Addr) public onlyOwner {
        PlanetBadges_Addr = _PlanetBadges_Addr;
        PB = IMetaX(_PlanetBadges_Addr);
    }

    /* Excess Claimable User */
    address public ExcessClaimableUser_Addr;
    IMetaX public ECU;

    function setExcessClaimableUser(address _ExcessClaimableUser_Addr) public onlyOwner {
        ExcessClaimableUser_Addr = _ExcessClaimableUser_Addr;
        ECU = IMetaX(_ExcessClaimableUser_Addr);
    }

    /** Daily Reset by admins **/
    function dailyReset(bytes32 _merkleRoot) public onlyRole(Admin) {
        Burn(); /* Burning daily unclaimed tokens */
        setRoot(_merkleRoot); /* Set the merkleRoot for POSW verification */
        setToday(); /* Update the timestamp of Today by 1 days */
    }

    /** Daily Quota **/
    uint256 public T0 = 1676332800; /* Genesis time @Feb 14th 2023 */

    uint256 public dailyQuota = 5479452 ether; /* 40% allocation | halve every 2 years | daily released */

    function Halve() public onlyOwner {
        require(block.timestamp >= T0 + 730 days, "SocialMining: Halving every 2 years.");
        dailyQuota = dailyQuota.div(2); /* Daily released tokens halve */
        for (uint256 i = 0; i < Rate.length; i++) {
            for (uint256 j = 0; j < Rate[0].length; j++) {
                Rate[i][j] = Rate[i][j].div(2); /* Minting rate halves */
                Limit[i][j] = Limit[i][j].div(2); /* Daily minting limit halves */
            }
        }
        T0 += 730 days; /* Update T0 for next halve */
    }

    /* Daily release mechanism */
    uint256 public Today; /* The timestamp of today @00:00 UTC */

    function setToday() public onlyRole(Admin) {
        require(block.timestamp - Today > 1 days, "SocialMining: Still within today.");
        Today += 1 days;
    }

    /** Social Mining Ability **/
    uint256[][] public Rate = [ /* Rate * 10 ** 15 */
        [ 200,  220,  250,  300,  380,  500,  620,  750,  880, 1000, 1150, 1300, 1500],
        [ 300,  380,  500,  680,  880, 1000, 1180, 1350, 1500, 1620, 1780, 1900, 2000],
        [ 800, 1200, 1500, 1720, 1860, 2000, 2380, 2700, 2830, 3000, 3230, 3500, 4000],
        [1600, 1880, 2000, 2300, 2500, 2800, 3200, 3500, 4000, 4300, 4680, 5000, 6000],
        [2500, 2880, 3200, 3600, 4000, 4500, 5200, 5800, 6600, 7500, 8300, 9000, 10000]
    ]; /* Halve every 2 years */

    uint256[][] public Limit = [ /* Limit * 10 ** 19 */
        [ 200,  220,  250,  268,  300,  370,  460,  550,  640,  720,  800,  900, 1000],
        [ 300,  380,  500,  750, 1000, 1320, 1680, 2000, 2400, 2800, 3000, 3350, 3500],
        [ 800, 1000, 1300, 1800, 2200, 2680, 3150, 3500, 3800, 4000, 4400, 4680, 5000],
        [1500, 1800, 2300, 2800, 3500, 4000, 4500, 5000, 5400, 5700, 6000, 6300, 7000],
        [2800, 3100, 3600, 4200, 4780, 5200, 5680, 6200, 7000, 7750, 8200, 9000, 10000]
    ]; /* Halve every 2 years */

    /* Additional 3 levels by owning PlanetGenesis NFT */
    function boostPG() public view returns (bool) {
        if (PlanetGenesis_Addr == address(0) || PG.balanceOf(msg.sender) == 0) {
            return false;
        } else {
            return true;
        }
    }

    /* Additional 10% of social mining ability by owning 10+ different series of PlanetBadges NFT */
    function boostPB() public view returns (bool) {
        if (PlanetBadges_Addr == address(0) || PB.getBoostNum(msg.sender) < 10) {
            return false;
        } else {
            return true;
        }
    }

    /** User $MetaX Claiming **/
    /* POSW Verification for User */
    bytes32 public merkleRoot;

    function setRoot(bytes32 _merkleRoot) public onlyRole(Admin) {
        merkleRoot = _merkleRoot;
    }

    function flattenArray(uint256[][] memory data) internal pure returns (uint256[] memory) {
        uint256 size = 0;
        for (uint256 i = 0; i < data.length; i++) {
            size = size.add(data[i].length);
        }
        uint256[] memory flatArray = new uint256[](size);
        uint256 index = 0;
        for (uint256 i = 0; i < data.length; i++) {
            for (uint256 j = 0; j < data[i].length; j++) {
                flatArray[index] = data[i][j];
                index = index.add(1);
            }
        }
        return flatArray;
    }

    function Verify(
        uint256 _POSW_Overall,
        uint256[] memory Id_SocialPlatform,
        uint256[] memory Id_Community,
        uint256[] memory POSW_SocialPlatform,
        uint256[] memory POSW_Community,
        uint256[][] memory POSW_SocialPlatform_Community,
        bytes32[] calldata merkleProof
    ) public view returns (bool) {
        require(Id_SocialPlatform.length == POSW_SocialPlatform.length && Id_Community.length == POSW_Community.length, "SocialMining: Incorrect POSW inputs.");
        bytes32 leaf = keccak256(abi.encodePacked(msg.sender, _POSW_Overall, Id_SocialPlatform, Id_Community, POSW_SocialPlatform, POSW_Community, flattenArray(POSW_SocialPlatform_Community)));
        return MerkleProof.verify(merkleProof, merkleRoot, leaf);
    }

    mapping(address => uint256) public recentClaimed_Time; /* Recording recent claim time of wallet */
    
    mapping(uint256 => uint256) public recentClaimed_PM; /* Recording recent claim time of PlanetMan tokenId */

    mapping(address => mapping(uint256 => uint256)) public recentClaimed_Tokens; /* Recording daily claimed tokens of wallet */
    
    /* $MetaX Calculation */
    function Algorithm(uint256 _POSW, uint256 _tokenId_PM) public view returns (uint256 amount, uint256 todayExcess) {
        uint256 _rarity = IMetaX(PlanetMan_Addr).getRarity(_tokenId_PM);
        uint256 _level = XP.getLevel(_tokenId_PM);

        if (boostPG()) {
            _level += 3;
        }

        uint256 _rate = Rate[_rarity][_level];
        uint256 _limit = Limit[_rarity][_level].mul(10000);

        if (boostPB()) {
            _rate = _rate.mul(110).div(100);
            _limit = _limit.mul(110).div(100);
        }

        uint256 _decimals = 10**15;
        uint256 todayClaimable = (_POSW.mul(_rate)) + (ECU.getExcess(msg.sender).div(_decimals));

        if (todayClaimable > _limit) {
            amount = _limit;
            todayExcess = todayClaimable - _limit;
        } else {
            amount = todayClaimable;
        }

        if ( (todayClaimed[Today].div(_decimals) + amount) > (dailyQuota.div(_decimals)) ) {
            todayExcess += ((todayClaimed[Today].div(_decimals)) + amount - dailyQuota.div(_decimals));
            amount = (dailyQuota.div(_decimals)) - (todayClaimed[Today].div(_decimals));
        }

        amount = amount.mul(_decimals);
        todayExcess = todayExcess.mul(_decimals);
    }

    function Amount(uint256 _POSW, uint256 _tokenId_PM) public view returns (uint256) {
        (uint256 amount, ) = Algorithm(_POSW, _tokenId_PM);
        return amount;
    }

    function Excess(uint256 _POSW, uint256 _tokenId_PM) public view returns (uint256) {
        (, uint256 todayExcess) = Algorithm(_POSW, _tokenId_PM);
        return todayExcess;
    }

    /* Claim $MetaX */
    function Claim_User(
        uint256 _tokenId_PM,
        uint256 POSW_Overall,
        uint256[] memory Id_SocialPlatform,
        uint256[] memory Id_Community,
        uint256[] memory POSW_SocialPlatform,
        uint256[] memory POSW_Community,
        uint256[][] memory POSW_SocialPlatform_Community,
        bytes32[] calldata merkleProof
    ) public {
        require(PM.ownerOf(_tokenId_PM) == msg.sender, "SocialMining: You are not the owner of this PlanetMan NFT.");
        require(Verify(POSW_Overall, Id_SocialPlatform, Id_Community, POSW_SocialPlatform, POSW_Community, POSW_SocialPlatform_Community, merkleProof), "SocialMining: Fail to verify your Identity or POSW.");
        require(block.timestamp <= Today + 1 days, "SocialMining: Today's claiming process has not started.");
        require(recentClaimed_Time[msg.sender] < Today, "SocialMining: Every Wallet can claim only once per day.");
        require(recentClaimed_PM[_tokenId_PM] < Today, "SocialMining: Every PlanetMan can claim only once per day.");
        uint256 amount = Amount(POSW_Overall, _tokenId_PM);
        uint256 todayExcess = Excess(POSW_Overall, _tokenId_PM);
        require(todayClaimed[Today] + amount <= dailyQuota, "SocialMining: Exceed today's limit.");
        
        MX.transfer(msg.sender, amount); /* Claiming tokens for user */
        todayClaimed[Today] += amount; /* Update global today claimed tokens with amount */
        recentClaimed_Tokens[msg.sender][Today] = amount; /* Record tokens claimed today by user */
        ECU.setExcess(msg.sender, todayExcess); /* Update user's excess claimable balance */
        recentClaimed_Time[msg.sender] = block.timestamp; /* Update recent claimed time of wallet as now */
        recentClaimed_PM[_tokenId_PM] = block.timestamp; /* Update recent claimed time of PlanetMan tokenId as now */
        POSW.addPOSW_User(msg.sender, POSW_Overall, Id_SocialPlatform, Id_Community, POSW_SocialPlatform, POSW_Community, POSW_SocialPlatform_Community); /* Accumulate POSW on user's wallet */
        XP.addPOSW_PM(_tokenId_PM, POSW_Overall); /* Accumulate POSW on PlanetMan NFT */
        emit userClaimRecord(msg.sender, _tokenId_PM, POSW_Overall, amount, todayExcess, block.timestamp);
    }

    mapping(uint256 => uint256) public todayClaimed; /* accumulative global tokens claimed daily */

    event userClaimRecord(address user, uint256 _tokenId, uint256 _POSW, uint256 $MetaX, uint256 Excess, uint256 _time);

    /** Add POSW Without Claiming **/
    bool public addPOSW_Open;

    function setAddPOSW_Open (bool _Open) public onlyOwner {
        addPOSW_Open = _Open;
    }

    function addPOSW(
        uint256 POSW_Overall,
        uint256[] memory Id_SocialPlatform,
        uint256[] memory Id_Community,
        uint256[] memory POSW_SocialPlatform,
        uint256[] memory POSW_Community,
        uint256[][] memory POSW_SocialPlatform_Community,
        bytes32[] calldata merkleProof
    ) public {
        require(addPOSW_Open, "SocialMining: Add POSW without claiming tokens is close.");
        require(Verify(POSW_Overall, Id_SocialPlatform, Id_Community, POSW_SocialPlatform, POSW_Community, POSW_SocialPlatform_Community, merkleProof), "SocialMining: Fail to verify your POSW.");
        require(block.timestamp <= Today + 1 days, "SocialMining: Today's claiming process has not started.");
        require(recentClaimed_Time[msg.sender] < Today, "SocialMining: Every Wallet can claim only once per day.");
        POSW.addPOSW_User(msg.sender, POSW_Overall, Id_SocialPlatform, Id_Community, POSW_SocialPlatform, POSW_Community, POSW_SocialPlatform_Community);
        recentClaimed_Time[msg.sender] = block.timestamp;
        emit addPOSW_Record(msg.sender, POSW_Overall, block.timestamp);
    }

    event addPOSW_Record(address user, uint256 posw, uint256 time);

    /** Burn **/
    uint256 public accumBurnt;

    address public immutable Burn_addr = 0x000000000000000000000000000000000000dEaD;

    function Burn() public onlyRole(Admin) {
        require(block.timestamp - Today > 1 days, "SocialMining: Still within today.");
        require(todayBurnt[Today] == 0, "SocialMining: Unclaimed tokens have been burnt.");
        uint256 todayUnclaimed = dailyQuota - todayClaimed[Today];
        MX.transfer(Burn_addr, todayUnclaimed);
        todayBurnt[Today] += todayUnclaimed;
        accumBurnt += todayUnclaimed;
        emit burnRecord(todayUnclaimed, block.timestamp);
    }

    function Burn_Amount(uint256 amount) public onlyOwner {
        require(amount <= MX.balanceOf(address(this)), "SocialMining: Insufficient balance.");
        MX.transfer(Burn_addr, amount);
        todayBurnt[Today] += amount;
        accumBurnt += amount;
        emit burnRecord(amount, block.timestamp);
    }

    mapping(uint256 => uint256) public todayBurnt; /* accumulative tokens burnt daily */

    event burnRecord(uint256 burnAmount, uint256 time);
}

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

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

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

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;

import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * 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:
 *
 * ```solidity
 * 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}:
 *
 * ```solidity
 * 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. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

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

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

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        Strings.toHexString(account),
                        " is missing role ",
                        Strings.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

    /**
     * @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 virtual override 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.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _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.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _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 revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        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.
     *
     * May emit a {RoleGranted} event.
     *
     * [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}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    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 {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            require(proofPos == proofLen, "MerkleProof: invalid multiproof");
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

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

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

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

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

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

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

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

interface IMetaX {

/** $MetaX **/
    function Burn(address sender, uint256 amount) external;


/** PlanetMan **/
    function getRarity(uint256 _tokenId) external view returns (uint256);

    function getLevel(uint256 _tokenId) external view returns (uint256);

    function getPOSW(uint256 _tokenId) external view returns (uint256);

    function levelUp(uint256 _tokenId) external;

    function addPOSW_PM (uint256 _tokenId, uint256 _POSW) external;


/** BlackHole SBT **/
    function totalSupply() external view returns (uint256);

    function addPOSW_Builder (
        uint256 _tokenId, 
        uint256 _POSW, 
        uint256[] memory Id_SocialPlatform, 
        uint256[] memory POSW_SocialPlatform
    ) external;

    function getPOSW_Builder (uint256 _tokenId) external view returns (uint256);

    function getPOSW_Builder_Owner (uint256 _tokenId) external view returns (uint256);

    function getPOSW_Builder_SocialPlatform (uint256 _tokenId, uint256 _socialPlatform) external view returns (uint256);

    function getPOSW_Builder_SocialPlatform_Owner (uint256 _tokenId, uint256 _socialPlatform) external view returns (uint256);

/** PlanetBadges **/
    function getBoostNum (address user) external view returns (uint256);

/** POSW **/
  /* Get User POSW */
    /* User POSW Overall */
    function getPOSW (address user) external view returns (uint256);

    function getPOSWbyYourself () external view returns (uint256);

    /* User POSW by Version */
    function getPOSW_Version (address user, uint256 _version) external view returns (uint256);

    function getPOSW_Version_Yourself (uint256 _version) external view returns (uint256);

    /* User POSW by Social Platform */
    function getPOSW_SocialPlatform (address user, uint256 _socialPlatform) external view returns (uint256);

    function getPOSW_SocialPlatform_Yourself (uint256 _socialPlatform) external view returns (uint256);

    /* User POSW by Community */
    function getPOSW_Community (address user, uint256 _community) external view returns (uint256);

    function getPOSW_Community_Yourself (uint256 _community) external view returns (uint256);

    /* User POSW by Version & Social Platform */
    function getPOSW_Version_SocialPlatform (address user, uint256 _version, uint256 _socialPlatform) external view returns (uint256);

    function getPOSW_Version_SocialPlatform_Yourself (uint256 _version, uint256 _socialPlatform) external view returns (uint256);

    /* User POSW by Version & Community */
    function getPOSW_Version_Community (address user, uint256 _version, uint256 _community) external view returns (uint256);

    function getPOSW_Version_Community_Yourself (uint256 _version, uint256 _community) external view returns (uint256);

    /* User POSW by Social Platform & Community */
    function getPOSW_SocialPlatform_Community (address user, uint256 _socialPlatform, uint256 _community) external view returns (uint256);

    function getPOSW_SocialPlatform_Community_Yourself (uint256 _socialPlatform, uint256 _community) external view returns (uint256);

    /* User POSW by Version & Social Platform & Community */
    function getPOSW_Version_SocialPlatform_Community (address user, uint256 _version, uint256 _socialPlatform, uint256 _community) external view returns (uint256);

    function getPOSW_Version_SocialPlatform_Community_Yourself (uint256 _version, uint256 _socialPlatform, uint256 _community) external view returns (uint256);

  /* Get Global POSW */
    /* Global POSW Overall */
    function getGlobalPOSW_Overall () external view returns (uint256);

    /* Global POSW by Version */
    function getGlobalPOSW_Version (uint256 _version) external view returns (uint256);

    /* Global POSW by Social Platform */
    function getGlobalPOSW_SocialPlatform (uint256 _socialPlatform) external view returns (uint256);

    /* Global POSW by Community */
    function getGlobalPOSW_Community (uint256 _community) external view returns (uint256);

    /* Global POSW by Version & Social Platform */
    function getGlobalPOSW_Version_SocialPlatform (uint256 _version, uint256 _socialPlatform) external view returns (uint256);

    /* Global POSW by Version & Community */
    function getGlobalPOSW_Version_Community (uint256 _version, uint256 _community) external view returns (uint256);

    /* Global POSW by Social Platform & Community */
    function getGlobalPOSW_SocialPlatform_Community (uint256 _socialPlatform, uint256 _community) external view returns (uint256);

    /* Global POSW by Version & Social Platform & Community */
    function getGlobalPOSW_Version_SocialPlatform_Community (uint256 _version, uint256 _socialPlatform, uint256 _community) external view returns (uint256);

  /* Add POSW */
    function addPOSW_User (
        address user,
        uint256 _POSW_Overall,
        uint256[] memory Id_SocialPlatform,
        uint256[] memory Id_Community,
        uint256[] memory _POSW_SocialPlatform,
        uint256[] memory _POSW_Community,
        uint256[][] memory _POSW_SocialPlatform_Community
    ) external;

/** PlanetPass **/
    function getBeginTime (uint256 _tokenId) external view returns (uint256);

    function getEndTime (uint256 _tokenId) external view returns (uint256);

/** Excess Claimable User **/
    function getExcess(address sender) external view returns (uint256);

    function setExcess(address sender, uint256 amount) external;

    function consumeExcess(address sender, uint256 amount) external;

/** Excess Claimable Builder **/
    function _getExcess(uint256 _tokenId) external view returns (uint256);

    function _setExcess(uint256 _tokenId, uint256 amount) external;

    function _consumeExcess(uint256 _tokenId, uint256 amount) external;


/** Admin Tool **/
  /* Daily Reset */
    /* Social Mining & Builder Incentives */
    function dailyReset (bytes32 _merkleRoot) external;

    /* Early Bird */
    function setRoot_Ini (bytes32 _merkleRoot_Ini) external;

    function setRoot_Claim (bytes32 _merkleRoot_Claim) external;

/** PlanetVault **/
  /* Get Stake Scores */
    function finalScores (address user) external view returns (uint256);

    function _baseScores (address user) external view returns (uint256);

    function _baseScoresByBatch (address user, uint256 batch) external view returns (uint256);

    function _finalScoresByBatch (address user, uint256 batch) external view returns (uint256);

  /* Get Stake Record */
    function getStakedAmount (address user) external view returns (uint256);

    function getRecordLength (address user) external view returns (uint256);

    function getStakedAmount_Record (address user, uint256 batch) external view returns (uint256);

    function getStakedAmount_Record_All (address user) external view returns (uint256[] memory);

    function getStakedTime_Record (address user, uint256 batch) external view returns (uint256);

    function getStakedTime_Record_All (address user) external view returns (uint256[] memory);

    function getAccumStakedAmount (address user) external view returns (uint256);

    function getAccumUnstakedAmount (address user) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

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

    /**
     * @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 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

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

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

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

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

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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @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 {AccessControl-_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) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

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

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

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

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

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

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

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

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

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{
  "optimizer": {
    "enabled": true,
    "runs": 1000
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"_Today","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"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":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"posw","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"addPOSW_Record","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"burnAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"burnRecord","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"_tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_POSW","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"$MetaX","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"Excess","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_time","type":"uint256"}],"name":"userClaimRecord","type":"event"},{"inputs":[],"name":"Admin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_POSW","type":"uint256"},{"internalType":"uint256","name":"_tokenId_PM","type":"uint256"}],"name":"Algorithm","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"todayExcess","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_POSW","type":"uint256"},{"internalType":"uint256","name":"_tokenId_PM","type":"uint256"}],"name":"Amount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Burn_Amount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"Burn_addr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId_PM","type":"uint256"},{"internalType":"uint256","name":"POSW_Overall","type":"uint256"},{"internalType":"uint256[]","name":"Id_SocialPlatform","type":"uint256[]"},{"internalType":"uint256[]","name":"Id_Community","type":"uint256[]"},{"internalType":"uint256[]","name":"POSW_SocialPlatform","type":"uint256[]"},{"internalType":"uint256[]","name":"POSW_Community","type":"uint256[]"},{"internalType":"uint256[][]","name":"POSW_SocialPlatform_Community","type":"uint256[][]"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"Claim_User","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ECU","outputs":[{"internalType":"contract IMetaX","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_POSW","type":"uint256"},{"internalType":"uint256","name":"_tokenId_PM","type":"uint256"}],"name":"Excess","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ExcessClaimableUser_Addr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Halve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"Limit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MX","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MetaX_Addr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PB","outputs":[{"internalType":"contract IMetaX","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PG","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PM","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POSW","outputs":[{"internalType":"contract IMetaX","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"POSW_Addr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PlanetBadges_Addr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PlanetGenesis_Addr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PlanetMan_Addr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"Rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"T0","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Today","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_POSW_Overall","type":"uint256"},{"internalType":"uint256[]","name":"Id_SocialPlatform","type":"uint256[]"},{"internalType":"uint256[]","name":"Id_Community","type":"uint256[]"},{"internalType":"uint256[]","name":"POSW_SocialPlatform","type":"uint256[]"},{"internalType":"uint256[]","name":"POSW_Community","type":"uint256[]"},{"internalType":"uint256[][]","name":"POSW_SocialPlatform_Community","type":"uint256[][]"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"Verify","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"XP","outputs":[{"internalType":"contract IMetaX","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"XPower_Addr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accumBurnt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"POSW_Overall","type":"uint256"},{"internalType":"uint256[]","name":"Id_SocialPlatform","type":"uint256[]"},{"internalType":"uint256[]","name":"Id_Community","type":"uint256[]"},{"internalType":"uint256[]","name":"POSW_SocialPlatform","type":"uint256[]"},{"internalType":"uint256[]","name":"POSW_Community","type":"uint256[]"},{"internalType":"uint256[][]","name":"POSW_SocialPlatform_Community","type":"uint256[][]"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"addPOSW","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"addPOSW_Open","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"boostPB","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"boostPG","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dailyQuota","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"dailyReset","outputs":[],"stateMutability":"nonpayable","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":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","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":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"recentClaimed_PM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"recentClaimed_Time","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"recentClaimed_Tokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","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":"bool","name":"_Open","type":"bool"}],"name":"setAddPOSW_Open","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_ExcessClaimableUser_Addr","type":"address"}],"name":"setExcessClaimableUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_MetaX_Addr","type":"address"}],"name":"setMetaX","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_POSW_Addr","type":"address"}],"name":"setPOSW","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_PlanetBadges_Addr","type":"address"}],"name":"setPlanetBadges","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_PlanetGenesis_Addr","type":"address"}],"name":"setPlanetGenesis","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_PlanetMan_Addr","type":"address"}],"name":"setPlanetMan","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setToday","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_XPower_Addr","type":"address"}],"name":"setXPower","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"todayBurnt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"todayClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106103af5760003560e01c80638786ac8e116101f4578063d51503901161011a578063e5c69a3c116100ad578063f70a389d1161007c578063f70a389d14610836578063f93cee4814610861578063faea8cf214610874578063ff1b636d1461088757600080fd5b8063e5c69a3c146107e3578063ebec9d14146107f6578063ef193ebb14610816578063f2fde38b1461082357600080fd5b8063dab5f340116100e9578063dab5f340146107a1578063dae8e084146107b4578063e53db217146107bd578063e5a379dd146107d057600080fd5b8063d515039014610755578063d547741f14610768578063d82352f91461077b578063d8e711e11461078e57600080fd5b8063a217fddf11610192578063bad0525c11610161578063bad0525c14610707578063bf12fd1014610727578063cd8a4dcb1461073a578063d40d01031461074d57600080fd5b8063a217fddf146106bc578063a8c275bf146106c4578063adc128eb146106eb578063b06b3a35146106f457600080fd5b806391d14854116101ce57806391d148541461063f57806393d1aea0146106765780639b3d2ace146106895780639de614b5146106a957600080fd5b80638786ac8e1461061257806389ce1a891461061b5780638da5cb5b1461062e57600080fd5b80633f32c26e116102d9578063576bf99a11610277578063649e92e411610246578063649e92e4146105d1578063715018a6146105e4578063717770f8146105ec578063731e44bf146105ff57600080fd5b8063576bf99a146105a55780635844bdad146105ae578063589cf278146105c157806358fb5f06146105c957600080fd5b806347959e6e116102b357806347959e6e1461054c578063496fbf721461055f5780634a2f6c8c14610572578063535805ef1461059257600080fd5b80633f32c26e1461051357806340c07d3c1461052657806344ffc4d61461053957600080fd5b80632eb4a7ab11610351578063380af1ab11610320578063380af1ab146104bd578063395ba694146104d0578063396ed0ab146104f85780633ee2a40e1461050057600080fd5b80632eb4a7ab1461047b5780632f2ff15d1461048457806334846f211461049757806336568abe146104aa57600080fd5b80631cbdf6951161038d5780631cbdf6951461041c5780631faf09d21461042f578063204cee1f14610442578063248a9ca31461044a57600080fd5b806301ffc9a7146103b457806303c7d322146103dc5780631188b62b146103f1575b600080fd5b6103c76103c23660046129fa565b6108ae565b60405190151581526020015b60405180910390f35b6103ef6103ea366004612a51565b610947565b005b600c54610404906001600160a01b031681565b6040516001600160a01b0390911681526020016103d3565b600954610404906001600160a01b031681565b600f54610404906001600160a01b031681565b6103ef61097b565b61046d610458366004612a6e565b60009081526020819052604090206001015490565b6040519081526020016103d3565b61046d60155481565b6103ef610492366004612a87565b610a30565b6103ef6104a5366004612c59565b610a5a565b6103ef6104b8366004612a87565b610d43565b600454610404906001600160a01b031681565b6104e36104de366004612d5f565b610dcf565b604080519283526020830191909152016103d3565b6103ef61117c565b600654610404906001600160a01b031681565b6103ef610521366004612d8f565b6113c8565b600e54610404906001600160a01b031681565b6103ef610547366004612dac565b6113e3565b6103ef61055a366004612a6e565b611a84565b6103ef61056d366004612a51565b611ac7565b61046d610580366004612a51565b60166020526000908152604090205481565b6103ef6105a0366004612a6e565b611afb565b61046d60105481565b6103ef6105bc366004612a51565b611cf6565b6103c7611d2a565b6103c7611dbf565b61046d6105df366004612d5f565b611e67565b6103ef611ea4565b61046d6105fa366004612d5f565b611eb8565b600d54610404906001600160a01b031681565b61046d601b5481565b6103ef610629366004612a51565b611ece565b6001546001600160a01b0316610404565b6103c761064d366004612a87565b6000918252602082815260408084206001600160a01b0393909316845291905290205460ff1690565b600354610404906001600160a01b031681565b61046d610697366004612a6e565b601c6020526000908152604090205481565b61046d6106b7366004612d5f565b611f02565b61046d600081565b6104047f000000000000000000000000000000000000000000000000000000000000dead81565b61046d60125481565b6103c7610702366004612c59565b611f12565b61046d610715366004612a6e565b60176020526000908152604090205481565b600554610404906001600160a01b031681565b600254610404906001600160a01b031681565b6103ef612025565b6103ef610763366004612a51565b612217565b6103ef610776366004612a87565b61224b565b600854610404906001600160a01b031681565b6103ef61079c366004612a51565b612270565b6103ef6107af366004612a6e565b6122a4565b61046d60115481565b6103ef6107cb366004612a51565b6122d4565b600754610404906001600160a01b031681565b61046d6107f1366004612d5f565b612308565b61046d610804366004612a6e565b60196020526000908152604090205481565b601a546103c79060ff1681565b6103ef610831366004612a51565b61231e565b61046d610844366004612ebf565b601860209081526000928352604080842090915290825290205481565b600a54610404906001600160a01b031681565b600b54610404906001600160a01b031681565b61046d7fa729ef4e25027bc652fc8b5c4d1d902947361fa7c8e7b4905e877823f27331b381565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f7965db0b00000000000000000000000000000000000000000000000000000000148061094157507f01ffc9a7000000000000000000000000000000000000000000000000000000007fffffffff000000000000000000000000000000000000000000000000000000008316145b92915050565b61094f6123ae565b600680546001600160a01b039092166001600160a01b0319928316811790915560078054909216179055565b7fa729ef4e25027bc652fc8b5c4d1d902947361fa7c8e7b4905e877823f27331b36109a581612408565b62015180601254426109b79190612f01565b11610a135760405162461bcd60e51b815260206004820152602160248201527f536f6369616c4d696e696e673a205374696c6c2077697468696e20746f6461796044820152601760f91b60648201526084015b60405180910390fd5b6201518060126000828254610a289190612f14565b909155505050565b600082815260208190526040902060010154610a4b81612408565b610a558383612412565b505050565b601a5460ff16610ad25760405162461bcd60e51b815260206004820152603860248201527f536f6369616c4d696e696e673a2041646420504f535720776974686f7574206360448201527f6c61696d696e6720746f6b656e7320697320636c6f73652e00000000000000006064820152608401610a0a565b610ae28888888888888888611f12565b610b545760405162461bcd60e51b815260206004820152602760248201527f536f6369616c4d696e696e673a204661696c20746f2076657269667920796f7560448201527f7220504f53572e000000000000000000000000000000000000000000000000006064820152608401610a0a565b601254610b649062015180612f14565b421115610bd95760405162461bcd60e51b815260206004820152603760248201527f536f6369616c4d696e696e673a20546f646179277320636c61696d696e67207060448201527f726f6365737320686173206e6f7420737461727465642e0000000000000000006064820152608401610a0a565b6012543360009081526016602052604090205410610c5f5760405162461bcd60e51b815260206004820152603760248201527f536f6369616c4d696e696e673a2045766572792057616c6c65742063616e206360448201527f6c61696d206f6e6c79206f6e636520706572206461792e0000000000000000006064820152608401610a0a565b600b546040517f1fc1993b0000000000000000000000000000000000000000000000000000000081526001600160a01b0390911690631fc1993b90610cb49033908c908c908c908c908c908c90600401612f62565b600060405180830381600087803b158015610cce57600080fd5b505af1158015610ce2573d6000803e3d6000fd5b505033600081815260166020908152604091829020429081905582519384529083018d905282820152517ffb7f9de6ea98e89f8e035dd671a5e1563833cc8c4e7a231578b5f42dc8aa4f6c9350908190036060019150a15050505050505050565b6001600160a01b0381163314610dc15760405162461bcd60e51b815260206004820152602f60248201527f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560448201527f20726f6c657320666f722073656c6600000000000000000000000000000000006064820152608401610a0a565b610dcb82826124b0565b5050565b600480546040517f48758697000000000000000000000000000000000000000000000000000000008152918201839052600091829182916001600160a01b0390911690634875869790602401602060405180830381865afa158015610e38573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e5c9190613051565b6007546040517f86481d40000000000000000000000000000000000000000000000000000000008152600481018790529192506000916001600160a01b03909116906386481d4090602401602060405180830381865afa158015610ec4573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ee89190613051565b9050610ef2611d2a565b15610f0557610f02600382612f14565b90505b600060138381548110610f1a57610f1a61306a565b906000526020600020018281548110610f3557610f3561306a565b906000526020600020015490506000610f9161271060148681548110610f5d57610f5d61306a565b906000526020600020018581548110610f7857610f7861306a565b906000526020600020015461252f90919063ffffffff16565b9050610f9b611dbf565b15610fcb57610fb66064610fb084606e61252f565b90612542565b9150610fc86064610fb083606e61252f565b90505b600f546040517f70d547d500000000000000000000000000000000000000000000000000000000815233600482015266038d7ea4c68000916000916110629184916001600160a01b03909116906370d547d590602401602060405180830381865afa15801561103e573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610fb09190613051565b61106c8b8661252f565b6110769190612f14565b90508281111561109657829750828161108f9190612f01565b965061109a565b8097505b6011546110a79083612542565b60125460009081526019602052604090205489906110c59085612542565b6110cf9190612f14565b1115611157576011546110e29083612542565b60125460009081526019602052604090205489906111009085612542565b61110a9190612f14565b6111149190612f01565b61111e9088612f14565b60125460009081526019602052604090205490975061113d9083612542565b60115461114a9084612542565b6111549190612f01565b97505b611161888361252f565b975061116d878361252f565b96505050505050509250929050565b7fa729ef4e25027bc652fc8b5c4d1d902947361fa7c8e7b4905e877823f27331b36111a681612408565b62015180601254426111b89190612f01565b1161120f5760405162461bcd60e51b815260206004820152602160248201527f536f6369616c4d696e696e673a205374696c6c2077697468696e20746f6461796044820152601760f91b6064820152608401610a0a565b6012546000908152601c6020526040902054156112945760405162461bcd60e51b815260206004820152602f60248201527f536f6369616c4d696e696e673a20556e636c61696d656420746f6b656e73206860448201527f617665206265656e206275726e742e00000000000000000000000000000000006064820152608401610a0a565b6012546000908152601960205260408120546011546112b39190612f01565b60035460405163a9059cbb60e01b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000dead811660048301526024820184905292935091169063a9059cbb906044016020604051808303816000875af1158015611328573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061134c9190613080565b506012546000908152601c60205260408120805483929061136e908490612f14565b9250508190555080601b60008282546113879190612f14565b9091555050604080518281524260208201527fd8b47ed99b44859e2ff3eb5b3892b33ef15ca78d83d57574a92d1b7f892acb7d910160405180910390a15050565b6113d06123ae565b601a805460ff1916911515919091179055565b6005546040517f6352211e000000000000000000000000000000000000000000000000000000008152600481018b905233916001600160a01b031690636352211e90602401602060405180830381865afa158015611445573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611469919061309d565b6001600160a01b0316146114e55760405162461bcd60e51b815260206004820152603a60248201527f536f6369616c4d696e696e673a20596f7520617265206e6f7420746865206f7760448201527f6e6572206f66207468697320506c616e65744d616e204e46542e0000000000006064820152608401610a0a565b6114f58888888888888888611f12565b6115675760405162461bcd60e51b815260206004820152603360248201527f536f6369616c4d696e696e673a204661696c20746f2076657269667920796f7560448201527f72204964656e74697479206f7220504f53572e000000000000000000000000006064820152608401610a0a565b6012546115779062015180612f14565b4211156115ec5760405162461bcd60e51b815260206004820152603760248201527f536f6369616c4d696e696e673a20546f646179277320636c61696d696e67207060448201527f726f6365737320686173206e6f7420737461727465642e0000000000000000006064820152608401610a0a565b60125433600090815260166020526040902054106116725760405162461bcd60e51b815260206004820152603760248201527f536f6369616c4d696e696e673a2045766572792057616c6c65742063616e206360448201527f6c61696d206f6e6c79206f6e636520706572206461792e0000000000000000006064820152608401610a0a565b60125460008a815260176020526040902054106116f75760405162461bcd60e51b815260206004820152603a60248201527f536f6369616c4d696e696e673a20457665727920506c616e65744d616e20636160448201527f6e20636c61696d206f6e6c79206f6e636520706572206461792e0000000000006064820152608401610a0a565b6000611703898b612308565b905060006117118a8c611eb8565b60115460125460009081526019602052604090205491925090611735908490612f14565b11156117a95760405162461bcd60e51b815260206004820152602360248201527f536f6369616c4d696e696e673a2045786365656420746f6461792773206c696d60448201527f69742e00000000000000000000000000000000000000000000000000000000006064820152608401610a0a565b60035460405163a9059cbb60e01b8152336004820152602481018490526001600160a01b039091169063a9059cbb906044016020604051808303816000875af11580156117fa573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061181e9190613080565b5060125460009081526019602052604081208054849290611840908490612f14565b9091555050336000818152601860209081526040808320601254845290915290819020849055600f5490517fd24d3b5d0000000000000000000000000000000000000000000000000000000081526004810192909252602482018390526001600160a01b03169063d24d3b5d90604401600060405180830381600087803b1580156118ca57600080fd5b505af11580156118de573d6000803e3d6000fd5b505050504260166000336001600160a01b03166001600160a01b031681526020019081526020016000208190555042601760008d815260200190815260200160002081905550600b60009054906101000a90046001600160a01b03166001600160a01b0316631fc1993b338c8c8c8c8c8c6040518863ffffffff1660e01b81526004016119719796959493929190612f62565b600060405180830381600087803b15801561198b57600080fd5b505af115801561199f573d6000803e3d6000fd5b50506007546040517f502bf321000000000000000000000000000000000000000000000000000000008152600481018f9052602481018e90526001600160a01b03909116925063502bf3219150604401600060405180830381600087803b158015611a0957600080fd5b505af1158015611a1d573d6000803e3d6000fd5b505060408051338152602081018f90529081018d905260608101859052608081018490524260a08201527ff1d9097534c80a50cfd4d600d18c19eeead760a1dc4ae0eaf641d408c1699ca5925060c001905060405180910390a15050505050505050505050565b7fa729ef4e25027bc652fc8b5c4d1d902947361fa7c8e7b4905e877823f27331b3611aae81612408565b611ab661117c565b611abf826122a4565b610dcb61097b565b611acf6123ae565b600480546001600160a01b039092166001600160a01b0319928316811790915560058054909216179055565b611b036123ae565b6003546040516370a0823160e01b81523060048201526001600160a01b03909116906370a0823190602401602060405180830381865afa158015611b4b573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b6f9190613051565b811115611be45760405162461bcd60e51b815260206004820152602360248201527f536f6369616c4d696e696e673a20496e73756666696369656e742062616c616e60448201527f63652e00000000000000000000000000000000000000000000000000000000006064820152608401610a0a565b60035460405163a9059cbb60e01b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000dead81166004830152602482018490529091169063a9059cbb906044016020604051808303816000875af1158015611c57573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611c7b9190613080565b506012546000908152601c602052604081208054839290611c9d908490612f14565b9250508190555080601b6000828254611cb69190612f14565b9091555050604080518281524260208201527fd8b47ed99b44859e2ff3eb5b3892b33ef15ca78d83d57574a92d1b7f892acb7d910160405180910390a150565b611cfe6123ae565b600280546001600160a01b039092166001600160a01b0319928316811790915560038054909216179055565b6008546000906001600160a01b03161580611dae57506009546040516370a0823160e01b81523360048201526001600160a01b03909116906370a0823190602401602060405180830381865afa158015611d88573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611dac9190613051565b155b15611db95750600090565b50600190565b600c546000906001600160a01b03161580611dae5750600d546040517fee3b72ce000000000000000000000000000000000000000000000000000000008152336004820152600a916001600160a01b03169063ee3b72ce90602401602060405180830381865afa158015611e37573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611e5b9190613051565b1015611db95750600090565b60148281548110611e7757600080fd5b906000526020600020018181548110611e8f57600080fd5b90600052602060002001600091509150505481565b611eac6123ae565b611eb6600061254e565b565b600080611ec58484610dcf565b95945050505050565b611ed66123ae565b600e80546001600160a01b039092166001600160a01b03199283168117909155600f8054909216179055565b60138281548110611e7757600080fd5b600085518851148015611f26575084518751145b611f975760405162461bcd60e51b8152602060048201526024808201527f536f6369616c4d696e696e673a20496e636f727265637420504f535720696e7060448201527f7574732e000000000000000000000000000000000000000000000000000000006064820152608401610a0a565b6000338a8a8a8a8a611fa88b6125a0565b604051602001611fbe97969594939291906130df565b6040516020818303038152906040528051906020012090506120178484808060200260200160405190810160405280939291908181526020018383602002808284376000920191909152505060155491508490506126f6565b9a9950505050505050505050565b61202d6123ae565b60105461203e906303c26700612f14565b4210156120b25760405162461bcd60e51b8152602060048201526024808201527f536f6369616c4d696e696e673a2048616c76696e67206576657279203220796560448201527f6172732e000000000000000000000000000000000000000000000000000000006064820152608401610a0a565b6011546120c0906002612542565b60115560005b6013548110156121f95760005b60136000815481106120e7576120e761306a565b6000918252602090912001548110156121e6576121466002601384815481106121125761211261306a565b90600052602060002001838154811061212d5761212d61306a565b906000526020600020015461254290919063ffffffff16565b601383815481106121595761215961306a565b9060005260206000200182815481106121745761217461306a565b906000526020600020018190555061219a6002601484815481106121125761211261306a565b601483815481106121ad576121ad61306a565b9060005260206000200182815481106121c8576121c861306a565b600091825260209091200155806121de8161313a565b9150506120d3565b50806121f18161313a565b9150506120c6565b506303c26700601060008282546122109190612f14565b9091555050565b61221f6123ae565b600c80546001600160a01b039092166001600160a01b03199283168117909155600d8054909216179055565b60008281526020819052604090206001015461226681612408565b610a5583836124b0565b6122786123ae565b600880546001600160a01b039092166001600160a01b0319928316811790915560098054909216179055565b7fa729ef4e25027bc652fc8b5c4d1d902947361fa7c8e7b4905e877823f27331b36122ce81612408565b50601555565b6122dc6123ae565b600a80546001600160a01b039092166001600160a01b03199283168117909155600b8054909216179055565b6000806123158484610dcf565b50949350505050565b6123266123ae565b6001600160a01b0381166123a25760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f64647265737300000000000000000000000000000000000000000000000000006064820152608401610a0a565b6123ab8161254e565b50565b6001546001600160a01b03163314611eb65760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610a0a565b6123ab813361270c565b6000828152602081815260408083206001600160a01b038516845290915290205460ff16610dcb576000828152602081815260408083206001600160a01b03851684529091529020805460ff1916600117905561246c3390565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b6000828152602081815260408083206001600160a01b038516845290915290205460ff1615610dcb576000828152602081815260408083206001600160a01b0385168085529252808320805460ff1916905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b600061253b8284613153565b9392505050565b600061253b828461316a565b600180546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b60606000805b83518110156125f0576125dc8482815181106125c4576125c461306a565b6020026020010151518361277f90919063ffffffff16565b9150806125e88161313a565b9150506125a6565b5060008167ffffffffffffffff81111561260c5761260c612ab7565b604051908082528060200260200182016040528015612635578160200160208202803683370190505b5090506000805b85518110156126ec5760005b86828151811061265a5761265a61306a565b6020026020010151518110156126d95786828151811061267c5761267c61306a565b602002602001015181815181106126955761269561306a565b60200260200101518484815181106126af576126af61306a565b60209081029190910101526126c583600161277f565b9250806126d18161313a565b915050612648565b50806126e48161313a565b91505061263c565b5090949350505050565b600082612703858461278b565b14949350505050565b6000828152602081815260408083206001600160a01b038516845290915290205460ff16610dcb5761273d816127d8565b6127488360206127ea565b6040516020016127599291906131b0565b60408051601f198184030181529082905262461bcd60e51b8252610a0a91600401613231565b600061253b8284612f14565b600081815b84518110156127d0576127bc828683815181106127af576127af61306a565b60200260200101516129cb565b9150806127c88161313a565b915050612790565b509392505050565b60606109416001600160a01b03831660145b606060006127f9836002613153565b612804906002612f14565b67ffffffffffffffff81111561281c5761281c612ab7565b6040519080825280601f01601f191660200182016040528015612846576020820181803683370190505b5090507f30000000000000000000000000000000000000000000000000000000000000008160008151811061287d5761287d61306a565b60200101906001600160f81b031916908160001a9053507f7800000000000000000000000000000000000000000000000000000000000000816001815181106128c8576128c861306a565b60200101906001600160f81b031916908160001a90535060006128ec846002613153565b6128f7906001612f14565b90505b600181111561297c577f303132333435363738396162636465660000000000000000000000000000000085600f16601081106129385761293861306a565b1a60f81b82828151811061294e5761294e61306a565b60200101906001600160f81b031916908160001a90535060049490941c9361297581613264565b90506128fa565b50831561253b5760405162461bcd60e51b815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e746044820152606401610a0a565b60008183106129e757600082815260208490526040902061253b565b600083815260208390526040902061253b565b600060208284031215612a0c57600080fd5b81357fffffffff000000000000000000000000000000000000000000000000000000008116811461253b57600080fd5b6001600160a01b03811681146123ab57600080fd5b600060208284031215612a6357600080fd5b813561253b81612a3c565b600060208284031215612a8057600080fd5b5035919050565b60008060408385031215612a9a57600080fd5b823591506020830135612aac81612a3c565b809150509250929050565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff81118282101715612af657612af6612ab7565b604052919050565b600067ffffffffffffffff821115612b1857612b18612ab7565b5060051b60200190565b600082601f830112612b3357600080fd5b81356020612b48612b4383612afe565b612acd565b82815260059290921b84018101918181019086841115612b6757600080fd5b8286015b84811015612b825780358352918301918301612b6b565b509695505050505050565b600082601f830112612b9e57600080fd5b81356020612bae612b4383612afe565b82815260059290921b84018101918181019086841115612bcd57600080fd5b8286015b84811015612b8257803567ffffffffffffffff811115612bf15760008081fd5b612bff8986838b0101612b22565b845250918301918301612bd1565b60008083601f840112612c1f57600080fd5b50813567ffffffffffffffff811115612c3757600080fd5b6020830191508360208260051b8501011115612c5257600080fd5b9250929050565b60008060008060008060008060e0898b031215612c7557600080fd5b88359750602089013567ffffffffffffffff80821115612c9457600080fd5b612ca08c838d01612b22565b985060408b0135915080821115612cb657600080fd5b612cc28c838d01612b22565b975060608b0135915080821115612cd857600080fd5b612ce48c838d01612b22565b965060808b0135915080821115612cfa57600080fd5b612d068c838d01612b22565b955060a08b0135915080821115612d1c57600080fd5b612d288c838d01612b8d565b945060c08b0135915080821115612d3e57600080fd5b50612d4b8b828c01612c0d565b999c989b5096995094979396929594505050565b60008060408385031215612d7257600080fd5b50508035926020909101359150565b80151581146123ab57600080fd5b600060208284031215612da157600080fd5b813561253b81612d81565b60008060008060008060008060006101008a8c031215612dcb57600080fd5b8935985060208a0135975060408a013567ffffffffffffffff80821115612df157600080fd5b612dfd8d838e01612b22565b985060608c0135915080821115612e1357600080fd5b612e1f8d838e01612b22565b975060808c0135915080821115612e3557600080fd5b612e418d838e01612b22565b965060a08c0135915080821115612e5757600080fd5b612e638d838e01612b22565b955060c08c0135915080821115612e7957600080fd5b612e858d838e01612b8d565b945060e08c0135915080821115612e9b57600080fd5b50612ea88c828d01612c0d565b915080935050809150509295985092959850929598565b60008060408385031215612ed257600080fd5b8235612edd81612a3c565b946020939093013593505050565b634e487b7160e01b600052601160045260246000fd5b8181038181111561094157610941612eeb565b8082018082111561094157610941612eeb565b600081518084526020808501945080840160005b83811015612f5757815187529582019590820190600101612f3b565b509495945050505050565b6001600160a01b038816815260006020888184015260e06040840152612f8b60e0840189612f27565b8381036060850152612f9d8189612f27565b90508381036080850152612fb18188612f27565b905083810360a0850152612fc58187612f27565b905083810360c08501528085518083528383019150838160051b8401018488016000805b8481101561303c57868403601f19018652825180518086529089019089860190845b818110156130275783518352928b0192918b019160010161300b565b50509689019694505091870191600101612fe9565b50919f9e505050505050505050505050505050565b60006020828403121561306357600080fd5b5051919050565b634e487b7160e01b600052603260045260246000fd5b60006020828403121561309257600080fd5b815161253b81612d81565b6000602082840312156130af57600080fd5b815161253b81612a3c565b80516000906020808401838315612f5757815187529582019590820190600101612f3b565b6bffffffffffffffffffffffff198860601b168152866014820152600061312d61312761312161311b613115603487018c6130ba565b8a6130ba565b886130ba565b866130ba565b846130ba565b9998505050505050505050565b60006001820161314c5761314c612eeb565b5060010190565b808202811582820484141761094157610941612eeb565b60008261318757634e487b7160e01b600052601260045260246000fd5b500490565b60005b838110156131a757818101518382015260200161318f565b50506000910152565b7f416363657373436f6e74726f6c3a206163636f756e74200000000000000000008152600083516131e881601785016020880161318c565b7f206973206d697373696e6720726f6c6520000000000000000000000000000000601791840191820152835161322581602884016020880161318c565b01602801949350505050565b602081526000825180602084015261325081604085016020870161318c565b601f01601f19169190910160400192915050565b60008161327357613273612eeb565b50600019019056fea264697066735822122083c52da985ee598f9091f60eed1706400601b9c6dc49c411692b5f64014f168a64736f6c63430008120033

0000000000000000000000000000000000000000000000000000000064fe5880

-----Decoded View---------------
Arg [0] : _Today (uint256): 1694390400

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000064fe5880