Contract 0x5b18f41ac7ac7d756b1374a8e7c5ce46450a7b04

/**
 *Submitted for verification at hecoinfo.com on 2021-05-10
*/

pragma solidity >=0.5.0 <0.6.0;

library TimeLineValue {
    struct Data {
        uint256 timeInterval_final;
        uint256[] timeList;
        mapping(uint256 => uint256) valueMapping;
    }

    function init(
        Data storage self,
        uint256 interval,
        uint256 t,
        uint256 value
    ) internal {
        uint256 tz = (t / interval) * interval;

        self.timeInterval_final = interval;
        self.timeList.push(tz);
        self.valueMapping[tz] = value;
    }

    function increase(Data storage self, uint256 addValue)
        internal
        returns (uint256)
    {
        uint256 t = (now / self.timeInterval_final) * self.timeInterval_final;

        uint256 latestTime = self.timeList[self.timeList.length - 1];

        if (latestTime == t) {
            self.valueMapping[latestTime] += addValue;
            return self.valueMapping[latestTime];
        } else {
            self.timeList.push(t);
            self.valueMapping[t] = (self.valueMapping[latestTime] + addValue);
            return self.valueMapping[t];
        }
    }

    function decrease(Data storage self, uint256 subValue)
        internal
        returns (uint256)
    {
        uint256 t = (now / self.timeInterval_final) * self.timeInterval_final;

        uint256 latestTime =
            self.timeList.length == 0
                ? t
                : self.timeList[self.timeList.length - 1];

        require(self.valueMapping[latestTime] >= subValue, "InsufficientQuota");

        if (latestTime == t) {
            self.valueMapping[latestTime] -= subValue;
            return self.valueMapping[latestTime];
        } else {
            self.timeList.push(t);
            self.valueMapping[t] = (self.valueMapping[latestTime] - subValue);
            return self.valueMapping[t];
        }
    }

    function forceSet(Data storage self, uint256 value) internal {
        uint256 t = (now / self.timeInterval_final) * self.timeInterval_final;

        uint256 latestTime = self.timeList[self.timeList.length - 1];

        if (latestTime == t) {
            self.valueMapping[latestTime] = value;
        } else {
            self.timeList.push(t);
            self.valueMapping[t] = value;
        }
    }

    function latestValue(Data storage self) internal view returns (uint256) {
        uint256[] storage s = self.timeList;
        if (s.length <= 0) {
            return 0;
        }
        return self.valueMapping[s[s.length - 1]];
    }

    function bestMatchValue(Data storage self, uint256 time)
        internal
        view
        returns (uint256)
    {
        uint256[] storage s = self.timeList;

        if (s.length <= 0 || time < s[0]) {
            return 0;
        }

        if (time >= s[s.length - 1]) {
            return self.valueMapping[s[s.length - 1]];
        }

        uint256 t = (time / self.timeInterval_final) * self.timeInterval_final;

        for (
            uint256 d = t;
            d >= t - 7 * self.timeInterval_final;
            d -= self.timeInterval_final
        ) {
            if (self.valueMapping[d] > 0) {
                return self.valueMapping[d];
            }
        }

        return 0;
    }
}

pragma solidity >=0.5.0 <0.6.0;

contract KTimeController {
    uint256 public offsetTime;

    function timestemp() external view returns (uint256) {
        return now + offsetTime;
    }

    function increaseTime(uint256 t) external {
        offsetTime += t;
    }
}

pragma solidity >=0.5.0 <0.6.0;

contract KOwnerable {
    address[] internal _authAddress = [
        address(0x013a0Fe4a79afFF253Fd0ACBDC891384EBbD0630)
    ];

    address[] public KContractOwners = [
        address(0x013a0Fe4a79afFF253Fd0ACBDC891384EBbD0630)
    ];

    bool private _call_locked;

    constructor() public {
        KContractOwners.push(msg.sender);
        _authAddress.push(msg.sender);
    }

    function KAuthAddresses() external view returns (address[] memory) {
        return _authAddress;
    }

    function KAddAuthAddress(address auther) external KOwnerOnly {
        _authAddress.push(auther);
    }

    function KDelAuthAddress(address auther) external KOwnerOnly {
        for (uint256 i = 0; i < _authAddress.length; i++) {
            if (_authAddress[i] == auther) {
                for (uint256 j = 0; j < _authAddress.length - 1; j++) {
                    _authAddress[j] = _authAddress[j + 1];
                }
                delete _authAddress[_authAddress.length - 1];
                _authAddress.pop();
                return;
            }
        }
    }

    modifier KOwnerOnly() {
        bool exist = false;
        for (uint256 i = 0; i < KContractOwners.length; i++) {
            if (KContractOwners[i] == msg.sender) {
                exist = true;
                break;
            }
        }
        require(exist, "NotAuther");
        _;
    }

    modifier KOwnerOnlyAPI() {
        bool exist = false;
        for (uint256 i = 0; i < KContractOwners.length; i++) {
            if (KContractOwners[i] == msg.sender) {
                exist = true;
                break;
            }
        }
        require(exist, "NotAuther");
        _;
    }

    modifier KRejectContractCall() {
        uint256 size;
        address payable safeAddr = msg.sender;
        assembly {
            size := extcodesize(safeAddr)
        }
        require(size == 0, "Sender Is Contract");
        _;
    }

    modifier KDAODefense() {
        require(!_call_locked, "DAO_Warning");
        _call_locked = true;
        _;
        _call_locked = false;
    }

    modifier KDelegateMethod() {
        bool exist = false;
        for (uint256 i = 0; i < _authAddress.length; i++) {
            if (_authAddress[i] == msg.sender) {
                exist = true;
                break;
            }
        }
        require(exist, "PermissionDeny");
        _;
    }

    function uint2str(uint256 i) internal pure returns (string memory c) {
        if (i == 0) return "0";
        uint256 j = i;
        uint256 length;
        while (j != 0) {
            length++;
            j /= 10;
        }
        bytes memory bstr = new bytes(length);
        uint256 k = length - 1;
        while (i != 0) {
            bstr[k--] = bytes1(uint8(48 + (i % 10)));
            i /= 10;
        }
        c = string(bstr);
    }
}

contract KPausable is KOwnerable {
    event Paused(address account);

    event Unpaused(address account);

    bool public paused;

    constructor() internal {
        paused = false;
    }

    modifier KWhenNotPaused() {
        require(!paused, "Pausable: paused");
        _;
    }

    modifier KWhenPaused() {
        require(paused, "Pausable: not paused");
        _;
    }

    function Pause() public KOwnerOnly {
        paused = true;
        emit Paused(msg.sender);
    }

    function Unpause() public KOwnerOnly {
        paused = false;
        emit Unpaused(msg.sender);
    }
}

contract KDebug is KPausable {
    KTimeController internal debugTimeController;

    function timestempZero() internal view returns (uint256) {
        return (timestemp() / 1 days) * 1 days;
    }

    function timestemp() internal view returns (uint256) {
        if (debugTimeController != KTimeController(0)) {
            return debugTimeController.timestemp();
        } else {
            return now;
        }
    }

    function KSetDebugTimeController(address tc) external KOwnerOnly {
        debugTimeController = KTimeController(tc);
    }
}

contract KStorage is KDebug {
    address public KImplementAddress;

    function SetKImplementAddress(address impl) external KOwnerOnly {
        KImplementAddress = impl;
    }

    function() external {
        address impl_address = KImplementAddress;
        assembly {
            calldatacopy(0x0, 0x0, calldatasize())
            let success := delegatecall(
                sub(gas(), 10000),
                impl_address,
                0x0,
                calldatasize(),
                0,
                0
            )
            let retSz := returndatasize()
            returndatacopy(0, 0, retSz)
            switch success
                case 0 {
                    revert(0, retSz)
                }
                default {
                    return(0, retSz)
                }
        }
    }
}

contract KStoragePayable is KDebug {
    address public KImplementAddress;

    function SetKImplementAddress(address impl) external KOwnerOnly {
        KImplementAddress = impl;
    }

    function() external payable {
        address impl_address = KImplementAddress;
        assembly {
            if eq(calldatasize(), 0) {
                return(0, 0)
            }

            calldatacopy(0x0, 0x0, calldatasize())
            let success := delegatecall(
                gas(),
                impl_address,
                0x0,
                calldatasize(),
                0,
                0
            )
            let retSz := returndatasize()
            returndatacopy(0, 0, retSz)
            switch success
                case 0 {
                    revert(0, retSz)
                }
                default {
                    return(0, retSz)
                }
        }
    }
}

pragma solidity >=0.5.1 <0.7.0;

interface iERC777_1 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    function increaseAllowance(address spender, uint256 addedValue)
        external
        returns (bool);

    function decreaseAllowance(address spender, uint256 subtractedValue)
        external
        returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    function granularity() external view returns (uint256);

    function defaultOperators() external view returns (address[] memory);

    function addDefaultOperators(address owner) external returns (bool);

    function removeDefaultOperators(address owner) external returns (bool);

    function isOperatorFor(address operator, address holder)
        external
        view
        returns (bool);

    function authorizeOperator(address operator) external;

    function revokeOperator(address operator) external;

    function send(
        address to,
        uint256 amount,
        bytes calldata data
    ) external;

    function operatorSend(
        address from,
        address to,
        uint256 amount,
        bytes calldata data,
        bytes calldata operatorData
    ) external;

    function burn(uint256 amount, bytes calldata data) external;

    function operatorBurn(
        address from,
        uint256 amount,
        bytes calldata data,
        bytes calldata operatorData
    ) external;

    event Sent(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 amount,
        bytes data,
        bytes operatorData
    );
    event Minted(
        address indexed operator,
        address indexed to,
        uint256 amount,
        bytes data,
        bytes operatorData
    );
    event Burned(
        address indexed operator,
        address indexed from,
        uint256 amount,
        bytes data,
        bytes operatorData
    );
    event AuthorizedOperator(address indexed operator, address indexed holder);
    event RevokedOperator(address indexed operator, address indexed holder);
}

pragma solidity >=0.4.22 <0.7.0;

library UserRelation {
    struct MainDB {
        uint256 totalAddresses;
        mapping(address => address) _recommerMapping;
        mapping(address => address[]) _recommerList;
        mapping(address => uint256) _recommerCountMapping;
        mapping(bytes6 => address) _shortCodeMapping;
        mapping(address => bytes6) _addressShotCodeMapping;
    }

    function Init(MainDB storage self) internal {
        address rootAddr = address(0xdead);
        bytes6 rootCode = 0x303030303030;
        self._recommerMapping[rootAddr] = address(0xdeaddead);
        self._shortCodeMapping[rootCode] = rootAddr;
        self._addressShotCodeMapping[rootAddr] = rootCode;
    }

    function GetIntroducer(MainDB storage self, address _owner)
        internal
        view
        returns (address)
    {
        return self._recommerMapping[_owner];
    }

    function RecommendList(MainDB storage self, address _owner)
        internal
        view
        returns (address[] memory list, uint256 len)
    {
        return (self._recommerList[_owner], self._recommerList[_owner].length);
    }

    function RegisterShortCode(
        MainDB storage self,
        address _owner,
        bytes6 shortCode
    ) internal returns (bool) {
        if (self._shortCodeMapping[shortCode] != address(0x0)) {
            return false;
        }

        if (self._addressShotCodeMapping[_owner] != bytes6(0x0)) {
            return false;
        }

        self._shortCodeMapping[shortCode] = _owner;
        self._addressShotCodeMapping[_owner] = shortCode;

        return true;
    }

    function ShortCodeToAddress(MainDB storage self, bytes6 shortCode)
        internal
        view
        returns (address)
    {
        return self._shortCodeMapping[shortCode];
    }

    function AddressToShortCode(MainDB storage self, address addr)
        internal
        view
        returns (bytes6)
    {
        return self._addressShotCodeMapping[addr];
    }

    function AddRelation(
        MainDB storage self,
        address owner,
        address recommer
    ) internal returns (int256) {
        if (recommer == owner) {
            require(false, "-1");
            return -1;
        }

        require(recommer != owner, "-1");

        require(self._recommerMapping[owner] == address(0x0), "-2");

        if (recommer != address(0xdead)) {
            require(self._recommerMapping[recommer] != address(0x0), "-3");
        }

        self._recommerMapping[owner] = recommer;

        self._recommerList[recommer].push(owner);

        self._recommerCountMapping[recommer]++;

        self.totalAddresses++;

        return 0;
    }

    function AddRelationEx(
        MainDB storage self,
        address owner,
        address recommer,
        bytes6 regShoutCode
    ) internal returns (int256) {
        if (!RegisterShortCode(self, owner, regShoutCode)) {
            return -4;
        }

        return AddRelation(self, owner, recommer);
    }

    function TeamMemberTotal(MainDB storage self, address _addr)
        internal
        view
        returns (uint256)
    {
        return self._recommerCountMapping[_addr];
    }
}

pragma solidity >=0.5.1 <0.6.0;

interface AirDrop {
    function airDropDelegate(address owner) external;
}

contract RelationsStorage is KStorage {
    UserRelation.MainDB _userRelation;
    using UserRelation for UserRelation.MainDB;

    constructor() public {
        _userRelation.Init();
    }
}

contract Relations is RelationsStorage {
    function GetIntroducer(address _owner) external view returns (address) {
        return _userRelation.GetIntroducer(_owner);
    }

    function RecommendList(address _owner)
        external
        view
        returns (address[] memory list, uint256 len)
    {
        return _userRelation.RecommendList(_owner);
    }

    function ShortCodeToAddress(bytes6 shortCode)
        external
        view
        returns (address)
    {
        return _userRelation.ShortCodeToAddress(shortCode);
    }

    function AddressToShortCode(address _addr) external view returns (bytes6) {
        return _userRelation.AddressToShortCode(_addr);
    }

    function TeamMemberTotal(address _addr) external view returns (uint256) {
        return _userRelation.TeamMemberTotal(_addr);
    }

    function RegisterShortCode(bytes6 shortCode) external {
        require(_userRelation.RegisterShortCode(msg.sender, shortCode));
    }

    function BindRelation(address _recommer) external {
        require(_userRelation.AddRelation(msg.sender, _recommer) >= 0, "-1");
    }

    function BindRelationEx(address _recommer, bytes6 shortCode) external {
        require(
            _userRelation.AddRelationEx(msg.sender, _recommer, shortCode) >= 0,
            "-1"
        );
        AirDrop(0x5B18f41Ac7AC7D756b1374A8e7C5ce46450a7b04).airDropDelegate(
            msg.sender
        );
    }

    function AddressesCount() external view returns (uint256) {
        return _userRelation.totalAddresses;
    }

    function importData(
        address _parent,
        bytes6 _shortCode,
        address[] calldata _children
    ) external KOwnerOnly {
        _userRelation._shortCodeMapping[_shortCode] = _parent;
        _userRelation._addressShotCodeMapping[_parent] = _shortCode;

        if (_children.length > 0) {
            for (uint256 i = 0; i < _children.length; i++) {
                _userRelation._recommerMapping[_children[i]] = _parent;

                _userRelation._recommerList[_parent].push(_children[i]);
            }

            _userRelation._recommerCountMapping[_parent] = _children.length;

            _userRelation.totalAddresses += _children.length;
        }
    }
}

pragma solidity >=0.5.1 <0.7.0;

interface RecommendValidUserInterface {
    function recommendValidUserTotalOf(address owner)
        external
        view
        returns (uint256);
}

contract MineStorage is KStorage {
    struct UserInfomation {
        uint256 pow_st;
        uint256 pow_dy;
        uint256 totalProfix;
        uint256 latestWithdrawTime;
    }

    mapping(address => UserInfomation) public userInfomationOf;

    uint256 public issueTime;
    uint256 public latestCutDownTime;
    uint256 public releaseToken = 33000 ether;

    using TimeLineValue for TimeLineValue.Data;
    TimeLineValue.Data _networkPowST;
    TimeLineValue.Data _networkPowDY;

    iERC777_1 internal _erc20Inc;
    Relations internal _rlsInc;
    RecommendValidUserInterface internal _bankInc;

    constructor(iERC777_1 erc20Inc, Relations rlsInc) public {
        _erc20Inc = erc20Inc;
        _rlsInc = rlsInc;

        _networkPowST.init(1 days, timestempZero(), 0);
        _networkPowDY.init(1 days, timestempZero(), 0);

        issueTime = timestempZero();
        latestCutDownTime = timestempZero();
    }
}

contract Mine is MineStorage(iERC777_1(0), Relations(0)) {
    event Log_Profix(
        address indexed owner,
        uint256 indexed time,
        uint256 st,
        uint256 dy
    );

    function setRecommendValidUserInterface(RecommendValidUserInterface i)
        external
        KOwnerOnly
    {
        _bankInc = i;
    }

    function networkPowerInfo()
        external
        view
        returns (uint256 totalSt, uint256 totalDy)
    {
        if (issueTime == 0) {
            return (0, 0);
        }
        return (
            _networkPowST.bestMatchValue(timestemp()),
            _networkPowDY.bestMatchValue(timestemp())
        );
    }

    function networkPowerInfo(uint256 time)
        external
        view
        returns (uint256 totalSt, uint256 totalDy)
    {
        if (issueTime == 0) {
            return (0, 0);
        }
        return (
            _networkPowST.bestMatchValue(time),
            _networkPowDY.bestMatchValue(time)
        );
    }

    function _currentReleaseToken() internal returns (uint256) {
        uint256 issueMonth = (timestemp() - issueTime) / 30 days;

        uint256 cutdownInterval = timestempZero() - latestCutDownTime;
        if (cutdownInterval < 30 days) {
            return releaseToken;
        }

        if (issueMonth <= 6) {
            releaseToken = (releaseToken * 1.10e12) / 1e12;
        } else if (issueMonth <= 12) {
            releaseToken = (releaseToken * 1.08e12) / 1e12;
        } else if (issueMonth <= 24) {
            releaseToken = (releaseToken * 1.05e12) / 1e12;
        } else if (issueMonth <= 36) {
            releaseToken = (releaseToken * 1.03e12) / 1e12;
        } else {
            releaseToken = (releaseToken * 1.02e12) / 1e12;
        }

        latestCutDownTime = timestempZero();
        return releaseToken;
    }

    function settlement()
        external
        returns (
            uint256 st,
            uint256 dy,
            uint256 sent
        )
    {
        if (issueTime == 0) {
            return (0, 0, 0);
        }
        return _settlement();
    }

    function _settlement()
        internal
        returns (
            uint256 st,
            uint256 dy,
            uint256 sent
        )
    {
        UserInfomation storage userInfo = userInfomationOf[msg.sender];

        uint256 intervalDay =
            (timestempZero() - userInfo.latestWithdrawTime) / 1 days;

        uint256 totalSt =
            (_networkPowST.bestMatchValue(userInfo.latestWithdrawTime) +
                _networkPowST.bestMatchValue(timestempZero() - 1 days)) / 2;

        if (totalSt > 0) {
            st =
                ((userInfo.pow_st * (_currentReleaseToken() / 2)) / totalSt) *
                intervalDay;
        }

        dy = userInfo.pow_dy;

        if (intervalDay > 0 && totalSt > 0) {
            uint40[15] memory props =
                [
                    0.20e12,
                    0.15e12,
                    0.10e12,
                    0.05e12,
                    0.05e12,
                    0.05e12,
                    0.05e12,
                    0.05e12,
                    0.05e12,
                    0.05e12,
                    0.04e12,
                    0.04e12,
                    0.04e12,
                    0.04e12,
                    0.04e12
                ];

            for (
                (address parent, uint256 i) =
                    (_rlsInc.GetIntroducer(msg.sender), 0);
                parent != address(0) &&
                    parent != address(0xdead) &&
                    i < props.length;
                (i++, parent = _rlsInc.GetIntroducer(parent))
            ) {
                uint256 amount = (st * props[i]) / 1e12;
                _networkPowDY.increase(amount);
                userInfomationOf[parent].pow_dy += (amount);
            }
        }

        if (st + dy > 0 && userInfo.totalProfix < userInfo.pow_st * 3) {
            if (userInfo.totalProfix + st + dy > userInfo.pow_st * 3) {
                sent = userInfo.pow_st * 3 - userInfo.totalProfix;
                userInfo.totalProfix = userInfo.pow_st * 3;
            } else {
                sent = (st + dy);
                userInfo.totalProfix += sent;
            }

            if (sent > 0) {
                userInfo.pow_dy = 0;
                userInfo.latestWithdrawTime = timestempZero();

                _erc20Inc.transfer(msg.sender, sent);
                emit Log_Profix(msg.sender, timestempZero(), st, dy);
            }
        }
    }

    function burn(uint256 amount) external returns (uint256 profix) {
        _erc20Inc.operatorBurn(msg.sender, amount, "MinerBurn", "");
        return _burned(msg.sender, amount);
    }

    function _burned(address owner, uint256 amount)
        internal
        returns (uint256 profix)
    {
        UserInfomation storage userInfo = userInfomationOf[owner];

        if (userInfo.pow_st == 0) {
            userInfo.latestWithdrawTime = timestempZero();
        } else {
            (, , profix) = _settlement();
        }

        userInfo.pow_st += amount;
        _networkPowST.increase(amount);
    }

    function increasePOWDelegate(address owner, uint256 pow)
        external
        KDelegateMethod
    {
        _burned(owner, pow);
    }

    function increasePOWGroupDelegate(
        address[] calldata addressList,
        uint256[] calldata pow
    ) external KOwnerOnly {
        uint256 totalNeedBurn = 0;
        for (uint256 i = 0; i < addressList.length; i++) {
            _burned(addressList[i], pow[i]);
            totalNeedBurn += pow[i];
        }
        _erc20Inc.transfer(address(0xdead), totalNeedBurn);
    }

    function airDropDelegate(address owner) external KDelegateMethod {
        _burned(owner, 9 ether);
        _erc20Inc.transfer(owner, 1 ether);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract iERC777_1","name":"erc20Inc","type":"address"},{"internalType":"contract Relations","name":"rlsInc","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"payable":false,"stateMutability":"nonpayable","type":"fallback"},{"constant":false,"inputs":[{"internalType":"address","name":"auther","type":"address"}],"name":"KAddAuthAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"KAuthAddresses","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"KContractOwners","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"auther","type":"address"}],"name":"KDelAuthAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"KImplementAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"tc","type":"address"}],"name":"KSetDebugTimeController","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"Pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"impl","type":"address"}],"name":"SetKImplementAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"Unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"issueTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"latestCutDownTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"releaseToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfomationOf","outputs":[{"internalType":"uint256","name":"pow_st","type":"uint256"},{"internalType":"uint256","name":"pow_dy","type":"uint256"},{"internalType":"uint256","name":"totalProfix","type":"uint256"},{"internalType":"uint256","name":"latestWithdrawTime","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

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

000000000000000000000000b1bcc3bacbbbd02f02f9c1335f79c9dd98684905000000000000000000000000c6b812b423bdae60cce7fc7e503009b1cfcfbae6

-----Decoded View---------------
Arg [0] : erc20Inc (address): 0xb1bcc3bacbbbd02f02f9c1335f79c9dd98684905
Arg [1] : rlsInc (address): 0xc6b812b423bdae60cce7fc7e503009b1cfcfbae6

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000b1bcc3bacbbbd02f02f9c1335f79c9dd98684905
Arg [1] : 000000000000000000000000c6b812b423bdae60cce7fc7e503009b1cfcfbae6

18745:961:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;18745:961:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8041:17;;;;8116:14;8018:20;;8093:38;8333:1;8313;8280:14;8258:3;8227:12;8202:5;8195;8191:17;8160:189;8376:16;8427:5;8424:1;8421;8406:27;8454:7;8479:65;;;;8603:5;8600:1;8593:16;8479:65;8519:5;8516:1;8509:16;4262:479;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4262:479:0;;;;:::i;:::-;;19038:32;;;:::i;:::-;;;;;;;;;;;;;;;;4149:105;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4149:105:0;;;;:::i;7831:32::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3769:104;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3769:104:0;;:::i;6704:18::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;6997:101;;;:::i;7664:125::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7664:125:0;;;;:::i;7106:106::-;;;:::i;7872:107::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7872:107:0;;;;:::i;18940:58::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18940:58:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4036:105;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;4036:105:0;;;;;;;;;;;;;;;;;19007:24;;;:::i;19077:41::-;;;:::i;4262:479::-;4782:10;;4811:188;4835:15;:22;4831:26;;4811:188;;;4905:10;4883:32;;:15;4899:1;4883:18;;;;;;;;;;;;;;;;;;;;:32;4879:109;;;4944:4;4936:12;;4967:5;;4879:109;4859:3;;4811:188;;;;5017:5;5009:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4339:9;4334:400;4358:12;:19;4354:23;;4334:400;;;4422:6;4403:25;;:12;4416:1;4403:15;;;;;;;;;;;;;;;;;;;;:25;4399:324;;;4454:9;4449:134;4473:12;:19;-1:-1:-1;;4473:23:0;4469:27;;4449:134;;;4544:12;4557:1;4561;4557:5;4544:19;;;;;;;;;;;;;;;;;4526:15;;4544:19;;;;;;4539:1;;4526:15;;;;;;;;;;;;;;;:37;;-1:-1:-1;;4526:37:0;;;;;;;;;;;;-1:-1:-1;4498:3:0;4449:134;;;-1:-1:-1;4608:12:0;4621:19;;-1:-1:-1;;4621:23:0;;;4608:37;;;;;;;;;;;;;;4601:44;;-1:-1:-1;;4601:44:0;;;4664:18;;;;;;;;;;;;;;;;-1:-1:-1;;4664:18:0;;;;;-1:-1:-1;;4664:18:0;;;;;;-1:-1:-1;4701:7:0;;4399:324;4379:3;;4334:400;;;;5047:1;4262:479;;:::o;19038:32::-;;;;:::o;4149:105::-;4782:10;;4811:188;4835:15;:22;4831:26;;4811:188;;;4905:10;4883:32;;:15;4899:1;4883:18;;;;;;;;;;;;;;;;;;;;:32;4879:109;;;4944:4;4936:12;;4967:5;;4879:109;4859:3;;4811:188;;;;5017:5;5009:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4221:12:0;27:10:-1;;39:1;23:18;;45:23;;4221:25:0;;;;;;;-1:-1:-1;;4221:25:0;;;;;;;;;;;;4149:105::o;7831:32::-;;;;;;:::o;3769:104::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3769:104:0;:::o;6704:18::-;;;;;;;;;:::o;6997:101::-;4782:10;;4811:188;4835:15;:22;4831:26;;4811:188;;;4905:10;4883:32;;:15;4899:1;4883:18;;;;;;;;;;;;;;;;;;;;:32;4879:109;;;4944:4;4936:12;;4967:5;;4879:109;4859:3;;4811:188;;;;5017:5;5009:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7043:6;:13;;-1:-1:-1;;7043:13:0;;;;;7072:18;;;7079:10;7072:18;;;;;;;;;;;;;6997:101;:::o;7664:125::-;4782:10;;4811:188;4835:15;:22;4831:26;;4811:188;;;4905:10;4883:32;;:15;4899:1;4883:18;;;;;;;;;;;;;;;;;;;;:32;4879:109;;;4944:4;4936:12;;4967:5;;4879:109;4859:3;;4811:188;;;;5017:5;5009:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7740:19:0;:41;;;;;;;;;;;;;;;;;;7664:125::o;7106:106::-;4782:10;;4811:188;4835:15;:22;4831:26;;4811:188;;;4905:10;4883:32;;:15;4899:1;4883:18;;;;;;;;;;;;;;;;;;;;:32;4879:109;;;4944:4;4936:12;;4967:5;;4879:109;4859:3;;4811:188;;;;5017:5;5009:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7154:6;:14;;-1:-1:-1;;7154:14:0;;;7184:20;;;7193:10;7184:20;;;;;;;;;;;;;7106:106;:::o;7872:107::-;4782:10;;4811:188;4835:15;:22;4831:26;;4811:188;;;4905:10;4883:32;;:15;4899:1;4883:18;;;;;;;;;;;;;;;;;;;;:32;4879:109;;;4944:4;4936:12;;4967:5;;4879:109;4859:3;;4811:188;;;;5017:5;5009:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7947:17:0;:24;;-1:-1:-1;;7947:24:0;;;;;;;;;;;;7872:107::o;18940:58::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;4036:105::-;4085:16;4121:12;4114:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4036:105;:::o;19007:24::-;;;;:::o;19077:41::-;;;;:::o;209:306::-;349:10;379:8;367;363:1;:12;;;;;400:34;;;445:13;;;;27:10:-1;;23:18;;;45:23;;400::0;445:22;;;;;;;363:12;;;;362:25;;;;445:22;;;;;478:21;;:17;;;;:21;;;;;;;:29;;;;-1:-1:-1;;209:306:0:o

bzzr://2e6ae939d7393c02ab32739d67287bf1fd4c118e51b5ea585de654ec5a09f266