Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at gnosisscan.io on 2022-08-04
*/

pragma solidity ^0.4.26;
contract NBZZ { 
    function balanceOf(address _address) public view returns(uint256);
    function transfer(address _to,uint256 _amount) public returns(bool);
    function transferFrom(address _from, address _to, uint256 _value) public returns(bool);
}


contract Glod{
    address glodaddress = 0x6cCCc6C3ece1CEB7671c5C5DE08Ce1715936B66D;
    address public founder = 0x0;
    string public  name;
    string public  symbol;
    uint256 public decimals;
    uint256 public technologyLockUp;
    address public technologyAddress;
    uint256 public TheTotalDrop;
    constructor(string _name,string _symbol,uint256 _decimals,uint256 _technologyLockUp,address _technologyAddress,uint256 _TheTotalDrop) public{
        founder = msg.sender;
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        technologyLockUp = _technologyLockUp;
        technologyAddress = _technologyAddress;
        TheTotalDrop = _TheTotalDrop;
    }
    address[] addressWhitelist;
    function checkAddressWhitelist() public view returns(address[]){
        return addressWhitelist;
    }
    function addAddressWhitelist(address _address) public returns(bool){
        require(msg.sender == founder);
        if(inquireAddressWhitelist(_address) == false){
             addressWhitelist.push(_address);
        }
        return true;
    }
    function deleteAddressWhitelist(address _address) public returns(bool){
        require(msg.sender == founder);
        require(inquireAddressWhitelist(_address));
        if(addressWhitelist.length == 1){
            return false;
        }
        for(uint i=0; i < addressWhitelist.length; i++){
          if(_address == addressWhitelist[i] && i != addressWhitelist.length - 1){
              addressWhitelist[i] = addressWhitelist[i+1];
          }
        }
        addressWhitelist.length --;
        return true;
    }
    function inquireAddressWhitelist(address _address)  internal view returns(bool){
        for(uint i=0; i<addressWhitelist.length; i++){
           if(_address == addressWhitelist[i]){
               return true;
           }
        }
        return false;
    }
    uint256 public contractBalancesLockup;
    mapping(address => uint256) public balancesLockup;
    uint256 releaseAmountOfBlock = 345600;
    mapping(address => lockups) lockupBalances;
    struct lockups{
        uint256[] lockupsnumber;
        uint256[] lockupsnumberRemaining;
        uint256[] lockupsStartNode;
        uint256[] lockupsLastNode;
    }
    address[] lockupAddressAll;
    mapping(address => bool) lockupAddressAllBool;  
    mapping(uint256 => address[]) lockupAddressAllPage;
    uint256 lockupAddressAllPageNum;
    function addLockup(address _address,uint256 _amount,uint256 _block) public returns(bool){
        require(inquireAddressWhitelist(msg.sender));
        lockupBalances[_address].lockupsnumber.push(_amount);
        lockupBalances[_address].lockupsnumberRemaining.push(_amount);
        lockupBalances[_address].lockupsStartNode.push(_block);
        lockupBalances[_address].lockupsLastNode.push(_block);
        balancesLockup[_address] +=_amount;
        contractBalancesLockup +=_amount;
        if(lockupAddressAllBool[_address] == false){
            lockupAddressAllBool[_address] = true;
            uint256 p = (lockupAddressAll.length / 1000) + 1;
            lockupAddressAllPage[p].push(_address);
            lockupAddressAllPageNum = p;
            lockupAddressAll.push(_address);
        }
        return true;
    }
    function lockupDetail(address _address) public view returns(uint256[] a,uint256[] b,uint256[] c,uint256[] d){
        return (lockupBalances[_address].lockupsnumber,lockupBalances[_address].lockupsnumberRemaining,lockupBalances[_address].lockupsStartNode,lockupBalances[_address].lockupsLastNode);
    }
    function remaininglockupRelease(address _address) public view returns(uint256){
        uint256 thisnumber = 0;
        uint256 thisnumbera = 0;
        uint256 thisblock = block.number;
        for(uint i=0; i < lockupBalances[_address].lockupsnumberRemaining.length; i++){
            if(lockupBalances[_address].lockupsnumberRemaining[i] > 0){
                thisnumber += lockupBalances[_address].lockupsnumberRemaining[i];
                if((lockupBalances[_address].lockupsnumber[i]*(thisblock - lockupBalances[_address].lockupsLastNode[i])/releaseAmountOfBlock) < lockupBalances[_address].lockupsnumberRemaining[i]){
                    thisnumbera += lockupBalances[_address].lockupsnumber[i]*(thisblock- lockupBalances[_address].lockupsLastNode[i])/releaseAmountOfBlock;
                }else{
                    thisnumbera += lockupBalances[_address].lockupsnumberRemaining[i];
                }
            }
        }
        return thisnumber - thisnumbera;
    }
    function setlockupRelease(address _address) public view returns(uint256){
        if(lockupBalances[_address].lockupsnumber.length > 0){
            uint256 thisnumber = 0;
            uint256 thisblock = block.number;
            for(uint i=0; i < lockupBalances[_address].lockupsnumber.length; i++){
                if(lockupBalances[_address].lockupsnumberRemaining[i] > 0){
                    if((lockupBalances[_address].lockupsnumber[i]*(thisblock - lockupBalances[_address].lockupsLastNode[i])/releaseAmountOfBlock) < lockupBalances[_address].lockupsnumberRemaining[i]){
                        thisnumber += lockupBalances[_address].lockupsnumber[i]*(thisblock- lockupBalances[_address].lockupsLastNode[i])/releaseAmountOfBlock;
                    }else{
                        thisnumber += lockupBalances[_address].lockupsnumberRemaining[i];
                    }
                }
            }
        }
        return thisnumber;
    }
    function lockupRelease(address _address) public returns(bool){
        if(lockupBalances[_address].lockupsnumber.length > 0){
            uint256 thisnumber = 0;
            uint256 thisblock = block.number;
            for(uint i=0; i < lockupBalances[_address].lockupsnumber.length; i++){
                if(lockupBalances[_address].lockupsnumberRemaining[i] > 0){
                    if((lockupBalances[_address].lockupsnumber[i]*(thisblock - lockupBalances[_address].lockupsLastNode[i])/releaseAmountOfBlock) < lockupBalances[_address].lockupsnumberRemaining[i]){
                        thisnumber += lockupBalances[_address].lockupsnumber[i]*(thisblock- lockupBalances[_address].lockupsLastNode[i])/releaseAmountOfBlock;
                        lockupBalances[_address].lockupsnumberRemaining[i] -= lockupBalances[_address].lockupsnumber[i]*(thisblock- lockupBalances[_address].lockupsLastNode[i])/releaseAmountOfBlock;
                    }else{
                        thisnumber += lockupBalances[_address].lockupsnumberRemaining[i];
                        lockupBalances[_address].lockupsnumberRemaining[i] -=lockupBalances[_address].lockupsnumberRemaining[i];
                    }
                    
                }
                lockupBalances[_address].lockupsLastNode[i] = thisblock;
            }
        }
        require(contractBalancesLockup >= thisnumber);
        require(thisnumber > 0);
        contractBalancesLockup -= thisnumber;
        NBZZ nbzz = NBZZ(glodaddress);
        nbzz.transfer(_address,thisnumber);
        return true;
    }
    uint256 NumberOfNodesOnline = 0;
    function releaseTechnologyLockup(uint256 _amount,uint256 _NumberOfNodesOnline) public returns(bool){
        require(inquireAddressWhitelist(msg.sender));
        if(technologyLockUp >= _amount && _NumberOfNodesOnline > NumberOfNodesOnline){
            NumberOfNodesOnline = _NumberOfNodesOnline;
            technologyLockUp -= _amount;
            NBZZ nbzz = NBZZ(glodaddress);
            nbzz.transfer(technologyAddress,_amount);
        }
            
        return true;
    }
    uint256 public contractBalancesPledge;
    uint256 minPledge = 15 * (10**decimals);
    mapping(address => uint256) public minPledgeBlock;
    uint256 freezingTime = 7776000;
    mapping(address => uint256) public freezingNumber;
    mapping(address => uint256) public freezingTimeOf;
    bool public pledged = true;
    mapping(address => uint256) public airdropQuantity;
    mapping(address => uint256) public balancesPledge;
    address[] PledgeAddressAll;
    mapping(address => bool) PledgeAddressAllBool;  
    mapping(uint256 => address[]) PledgeAddressAllPage;
    uint256 PledgeAddressAllPageNum;
    uint256 public TheTotalDropOn = 0;
    function dropThePledge(address[] _address,uint[] _amount) public returns (bool){
        require(msg.sender == founder);
        require(_address.length == _amount.length);
        for(uint i = 0; i < _address.length; i++){
            TheTotalDropOn += _amount[i];
            require(TheTotalDrop >= TheTotalDropOn);
            airdropQuantity[_address[i]] += _amount[i];
            contractBalancesPledge += _amount[i];
            balancesPledge[_address[i]] += _amount[i];
            if(PledgeAddressAllBool[_address[i]] == false){
                PledgeAddressAllBool[_address[i]] = true;
                uint256 p = (PledgeAddressAll.length / 1000) + 1;
                PledgeAddressAllPage[p].push(_address[i]);
                PledgeAddressAllPageNum = p;
                PledgeAddressAll.push(_address[i]);
            }
            if(balancesPledge[_address[i]] >= minPledge && minPledgeBlock[_address[i]] == 0){
                minPledgeBlock[_address[i]] = block.number;
            }
        }
        return true;
    }
    function thePledge(uint256 _amount) public returns (bool){
        require(freezingNumber[msg.sender] == 0);
        NBZZ nbzz = NBZZ(glodaddress);
        nbzz.transferFrom(msg.sender,this,_amount);
        contractBalancesPledge += _amount;
        balancesPledge[msg.sender] += _amount;
        if(PledgeAddressAllBool[msg.sender] == false){
            PledgeAddressAllBool[msg.sender] = true;
            uint256 p = (PledgeAddressAll.length / 1000) + 1;
            PledgeAddressAllPage[p].push(msg.sender);
            PledgeAddressAllPageNum = p;
            PledgeAddressAll.push(msg.sender);
        }
        if(balancesPledge[msg.sender] >= minPledge && minPledgeBlock[msg.sender] == 0){
            minPledgeBlock[msg.sender] = block.number;
        }
        return true;
    }
    function theUnpack(address _address) public returns(bool){
        require(inquireAddressWhitelist(msg.sender));
        require(balancesPledge[_address] > 0);
        require(freezingNumber[_address] == 0);
        freezingNumber[_address] += balancesPledge[_address];
        balancesPledge[_address] -= balancesPledge[_address];
        freezingTimeOf[_address] = now;
        minPledgeBlock[_address] = 0;
        return true;
    }
    function cancelTheUnpack(address _address) public returns(bool){
        require(inquireAddressWhitelist(msg.sender));
        require(freezingNumber[_address] > 0);
        balancesPledge[_address] += freezingNumber[_address];
        freezingNumber[_address] -= freezingNumber[_address];
        freezingTimeOf[_address] = 0;
        if(balancesPledge[_address] >= minPledge && minPledgeBlock[_address] == 0){
            minPledgeBlock[_address] = block.number;
        }
        return true;
    }
    function unpackState(address _address) public view returns(uint256 number,uint256 times){
        return (freezingNumber[_address],freezingTimeOf[_address]);
    }
    function unpackToExtract() public returns(bool){
        require(freezingNumber[msg.sender] > 0);
        require((now-freezingTimeOf[msg.sender]) > freezingTime);
        contractBalancesPledge -= freezingNumber[msg.sender];
        NBZZ nbzz = NBZZ(glodaddress);
        nbzz.transfer(msg.sender,freezingNumber[msg.sender]);
        freezingNumber[msg.sender] -= freezingNumber[msg.sender];
        freezingTimeOf[msg.sender] = 0;
        
        return true;
    }
    function punishment(address _address,uint256 _amount) public returns(bool){
        require(inquireAddressWhitelist(msg.sender));
        uint256 punishmentnum = 0;
        NBZZ nbzz = NBZZ(glodaddress);
        if(nbzz.balanceOf(_address) < _amount){
            punishmentnum = nbzz.balanceOf(_address);
        }else{
            punishmentnum = _amount;
        }
        balancesPledge[_address] -= punishmentnum;
        return true;
    }
    function contractOf() public view returns (uint256) {
        require(balanceOf(this) >= contractBalancesLockup+contractBalancesPledge+technologyLockUp);
        NBZZ nbzz = NBZZ(glodaddress);
        return nbzz.balanceOf(this) - contractBalancesLockup - contractBalancesPledge - technologyLockUp;
    }
    function balanceOf(address _address) public view returns (uint256) {
        NBZZ nbzz = NBZZ(glodaddress);
        return nbzz.balanceOf(_address);
    }
    function modifyOwnerFounder(address newFounder) public returns(address){
        require(msg.sender == founder);
        founder = newFounder;
        return founder;
    }
    function distribute(uint256[] _amount, address[] _to) public returns (bool){
        require(inquireAddressWhitelist(msg.sender));
        require(_amount.length == _to.length);
        NBZZ nbzz = NBZZ(glodaddress);
        for(uint i = 0; i < _to.length; i++){
            require(contractOf() >= _amount[i]);
            nbzz.transfer(_to[i],_amount[i]);
        }
        return true;
    }
    function distributeFrom(uint256 _amount, address _to) public returns (bool){
        require(inquireAddressWhitelist(msg.sender));
        require(contractOf() >= _amount);
        NBZZ nbzz = NBZZ(glodaddress);
        nbzz.transfer(_to,_amount);
        return true;
    }
    function setPledged(bool _bool) public returns(bool){
        require(msg.sender == founder);
        pledged = _bool;
        return pledged;
    }
    function setTechnologyAddress(address _address) public returns(address){
        require(msg.sender == founder);
        technologyAddress = _address;
        return technologyAddress;
    }
    
    
}


contract Alias  {
    uint256 public baseStartTime;
    address public founder = 0x0;
    mapping(address =>string) addressAlias;
    mapping(address =>address) addressMapping;
    mapping(address =>uint256) mappingNum;
    mapping(address =>bool) mappingBool;
    address[] AddressAll;
    mapping(address => bool) AddressAllBool;  
    mapping(uint256 => address[]) AddressAllPage;
    uint256 AddressAllPageNum;
    constructor() public{
        founder = msg.sender;
        baseStartTime = block.timestamp;
    }
    function addressAliasOf(address _address) public view returns(string){
        return addressAlias[_address];
    }
    function addressMappingOf(address _address) public view returns(address){
        return addressMapping[_address];
    }
    function mappingNumOf(address _address) public view returns(uint256){
        return mappingNum[_address];
    }
    function setAddressAlias(string _string) public returns(string){
        addressAlias[msg.sender] = _string;
        return addressAlias[msg.sender];
    }
    function  setAddressMapping(address _address) public returns(address){
        require(msg.sender != _address);
        mappingNum[addressMapping[msg.sender]] -= 1;
        mappingNum[_address] += 1;
        if(mappingBool[_address] == false){
            mappingBool[_address] = true;
            uint256 p = (AddressAll.length / 1000) + 1;
            AddressAllPage[p].push(_address);
            AddressAllPageNum = p;
            AddressAll.push(_address);
        }
        addressMapping[msg.sender] = _address;
        return addressMapping[msg.sender];
    }
    function AddressAllPaged(uint256 _page) public view returns(address[]){
        return AddressAllPage[_page];
    }
    function AddressAllPageNumOf() public view returns(uint256){
        return AddressAllPageNum;
    }
    function AddressAllNum() public view returns(uint256){
        return AddressAll.length;
    }
    function killContract() public returns(bool){
        require(msg.sender == founder);
        selfdestruct(founder);
        return true;
    }
}

contract Model{
    address constant private glodaddress = 0x399251C48F94Ace8736b6bd7Ab029ac53971043D;
    Glod private _glod;
    address constant private aliasaddress = 0x41e2Ca2B9C93bb460E5AeBF3dfF9ebcA9Ab8be5e;
    Alias private _alias;
    address founder = 0x0;
    uint256 public baseStartTime;
    uint256 public decimals;
    constructor() public{
        founder = msg.sender;
        baseStartTime = now;
        _glod = Glod(glodaddress);
        _alias = Alias(aliasaddress);
        decimals = _glod.decimals();
    }
    mapping(address => node) public trustNode;
    struct node{
        bool status;
        bool ishave;
        uint256 lastBlockNumber;
    }
    address[] public trustNodes;
    event addingATrustNode(address _address);
    event deletingATrustedNode(address _address);
    function setTrustNode(address _address) public returns (bool){
        require(msg.sender == founder);
        if(trustNode[_address].ishave){
            trustNode[_address].status = true;
        }else{
            trustNode[_address].status = true;
            trustNode[_address].ishave = true;
            trustNodes.push(_address);
        }
        emit addingATrustNode(_address);
        return true;
    }
    function delTrustNode(address _address) public returns(bool){
        require(msg.sender == founder);
        if(trustNode[_address].ishave){
            if(trustNode[_address].status){
                trustNode[_address].status = false;
            }
        }
        emit deletingATrustedNode(_address);
        return true;
    }
    function seeTrustNode() public view returns(address[] nodeaddress){
        return trustNodes;
    }
    function seeTrustNodeDetails(address _address) public view returns(bool){
        if(trustNode[_address].ishave){
            return trustNode[_address].status;
        }else{
            return false;
        }
    }
    mapping(address => node_f) fishingNode;
    struct node_f{
        bool status;
        bool ishave;
    }
    address[] public fishingNodes;
    function setFishingNode(address _address) public returns (bool){
        require(msg.sender == founder);
        if(fishingNode[_address].ishave){
            fishingNode[_address].status = true;
        }else{
            fishingNode[_address].status = true;
            fishingNode[_address].ishave = true;
            fishingNodes.push(_address);
        }
        return true;
    }
    function delFishingNode(address _address) public returns(bool){
        require(msg.sender == founder);
        if(fishingNode[_address].ishave){
            if(fishingNode[_address].status){
                fishingNode[_address].status = false;
            }
        }
        return true;
    }
    function seeFishingNode() public view returns(address[] nodeaddress){
        return fishingNodes;
    }
    function seeFishingNodeDetails(address _address) public view returns(bool){
        if(fishingNode[_address].ishave){
            return fishingNode[_address].status;
        }else{
            return false;
        }
    }
    uint256 public pledgeAmount = 15 * (10**decimals);
    uint256 public NumberOfPenalties = 15 * (10**decimals);
    mapping(address => nodes) nodeStatus;     
    struct nodes{
        uint256 firstOnline;
        bool status;
        bool nodeConfirmation;
        address _address_a;
        string _address_b;
    }
    uint256 public NumberOfNodesOnline = 0; 
    uint256 public OnlineNumber = 0;
    event nodeOnlineOf(address _address);
    event nodeOfflineOf(address _address);
    event nodeConfirmOf(address _address);
    event PunishmentNode(address _address, uint256 _amount);
    event nodeReward(address _address, uint256 _blocknumber);
    function theUnpack() public returns(bool){
        nodeStatus[msg.sender].status = false;
        if(nodeStatus[msg.sender].nodeConfirmation){
            OnlineNumber -= 1;
        }
        nodeStatus[msg.sender].nodeConfirmation = false;
        emit nodeOfflineOf(msg.sender);
        return _glod.theUnpack(msg.sender);
    }
    function cancelTheUnpack() public returns(bool){
        return _glod.cancelTheUnpack(msg.sender);
    }
    function nodeOnline(address _addressa,string _addressb) public returns(bool){
        require(_glod.balancesPledge(msg.sender) >= pledgeAmount);
        if(nodeStatus[msg.sender].firstOnline == 0){
            NumberOfNodesOnline += 1;
            Technicaldividend();
        }
        nodeStatus[msg.sender].status = true;
        nodeStatus[msg.sender].nodeConfirmation = false;
        nodeStatus[msg.sender]._address_a = _addressa;
        nodeStatus[msg.sender]._address_b = _addressb;
        nodeStatus[msg.sender].firstOnline = now;
        emit nodeOnlineOf(msg.sender);
        return true;
    }
    function nodeOffline() public returns(bool){
        nodeStatus[msg.sender].status = false;
        if(nodeStatus[msg.sender].nodeConfirmation){
            OnlineNumber -= 1;
        }
        nodeStatus[msg.sender].nodeConfirmation = false;
        emit nodeOfflineOf(msg.sender);
        return true;
    }
    function nodeAllOffline(address[] _address) public returns(bool){
        require(fishingNode[msg.sender].ishave && fishingNode[msg.sender].status);
        require(_address.length >= 0);
        for(uint256 i = 0; i < _address.length; i++){
            nodeStatus[_address[i]].status = false;
            if(nodeStatus[_address[i]].nodeConfirmation){
                OnlineNumber -= 1;
            }
            nodeStatus[_address[i]].nodeConfirmation = false;
            emit nodeOfflineOf(_address[i]);
        }
        return true;
    }
    function nodeConfirmationed(address[] _address) public returns(bool){
        require(fishingNode[msg.sender].ishave && fishingNode[msg.sender].status);
        require(_address.length >= 0);
        for(uint256 iii = 0; iii < _address.length; iii++){
            nodeStatus[_address[iii]].nodeConfirmation = true;
            emit nodeConfirmOf(_address[iii]);
            OnlineNumber += 1;
        }
        return true;
    }
    function nodeState(address _address) public view returns(bool a,bool b,address c,string d){
        return (nodeStatus[_address].status,nodeStatus[_address].nodeConfirmation,nodeStatus[_address]._address_a,nodeStatus[_address]._address_b);
    }
    function setPledgeAmount(uint256 _amount) public returns(uint256){
        require(msg.sender == founder);
        pledgeAmount = _amount;
        return _amount;
    }
    function setNumberOfPenalties(uint256 _amount) public returns(uint256){
        require(msg.sender == founder);
        NumberOfPenalties = _amount;
        return _amount;
    }
    function penaltyNode(address _address) public returns(bool){
        require(fishingNode[msg.sender].ishave && fishingNode[msg.sender].status);
        _glod.punishment(_address,NumberOfPenalties);
        nodeStatus[_address].status = false;
        if(nodeStatus[_address].nodeConfirmation){
            OnlineNumber -= 1;
        }
        nodeStatus[_address].nodeConfirmation = false;
        emit nodeOfflineOf(_address);
        emit PunishmentNode(_address,NumberOfPenalties);
        return true;
    }
    uint256 public lastBlockNumber = 0;
    uint256 public blockInterval = 32;
    uint256 public startBlockHeight = 0;
    uint256 blockConstant = 0;
    uint256 blockYield = 2507201646090535000 * blockInterval;
    uint256 public allNum = 0;
    function setBlockInterval(uint256 _blockInterval) public returns(uint256){
        require(msg.sender == founder);
        blockInterval = _blockInterval;
        return blockInterval;
    }
    mapping(uint256 => bool) public BlockReleaseState;
    function queryLastBlockNumber(address _address) public view returns(uint256){
        return trustNode[_address].lastBlockNumber;
    }
    function toDailyoutput(address[] _nodeaddress,uint256 _blocknumber) public returns(bool){
        require(trustNode[msg.sender].ishave && trustNode[msg.sender].status);
        require(BlockReleaseState[_blocknumber] == false || startBlockHeight == 0);
        require((_blocknumber - startBlockHeight)%blockInterval == 0 || startBlockHeight == 0);
        require((startBlockHeight<_blocknumber || startBlockHeight==0) && _blocknumber < block.number);
        if(startBlockHeight == 0){
            startBlockHeight = _blocknumber;
            blockConstant = _blocknumber;
        }
        BlockReleaseState[_blocknumber] = true;
        trustNode[msg.sender].lastBlockNumber = _blocknumber;
        if((block.number-blockConstant)/12614400 == 1){
            blockConstant = block.number;
            blockYield = blockYield/2;
        }
        allNum += blockYield;
        _glod.distributeFrom(blockYield*70/1000,msg.sender);//2/10*35/100
        _glod.addLockup(msg.sender,blockYield*130/1000,block.number);
        for(uint256 i = 0; i < _nodeaddress.length; i++){
            uint256 thisnumber = blockYield*8/10/_nodeaddress.length;
            if(_alias.addressMappingOf(_nodeaddress[i]) != 0x00){
                 _nodeaddress[i] = _alias.addressMappingOf(_nodeaddress[i]);
            }
            _glod.distributeFrom(thisnumber*35/100,_nodeaddress[i]);
            _glod.addLockup(_nodeaddress[i],thisnumber*65/100,block.number);
        }
        lastBlockNumber = _blocknumber;
        emit nodeReward(msg.sender,_blocknumber);
        return true;
    }   
    function NumberOfLegalPledges(uint256 _x) internal pure returns (uint256){
        uint z = (_x + 1 ) / 2;
        uint y = _x;
        while(z < y){
            y = z;
            z = ( _x / z + z ) / 2;
        }
        return y;
    }
    uint256 public technicalupTime = 0;
    uint256 public technicalupnum = 0;
    function Technicaldividend() internal returns(bool){
        uint256 ls = NumberOfNodesOnline/5000;
        if(ls == 1 && technicalupnum != ls){
            technicalupTime = now;
            technicalupnum = ls;
            _glod.releaseTechnologyLockup(31250 * (10**decimals),NumberOfNodesOnline);
        }
        if(ls != 0 && ls != 1  && ls < 10 && now-technicalupTime >=2592000 && technicalupnum != ls){
            technicalupTime = now;
            technicalupnum = ls;
            _glod.releaseTechnologyLockup(31250 * (10**decimals),NumberOfNodesOnline);

        }
        if(ls == 10  && now - baseStartTime >= 31536000 && technicalupnum != ls){
            technicalupTime = now;
            _glod.releaseTechnologyLockup(31250 * (10**decimals),NumberOfNodesOnline);
        }
        return true;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"constant":true,"inputs":[],"name":"baseStartTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"killContract","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_address","type":"address"}],"name":"mappingNumOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_address","type":"address"}],"name":"addressMappingOf","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"AddressAllPageNumOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_address","type":"address"}],"name":"addressAliasOf","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"founder","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_address","type":"address"}],"name":"setAddressMapping","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_string","type":"string"}],"name":"setAddressAlias","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"AddressAllNum","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_page","type":"uint256"}],"name":"AddressAllPaged","outputs":[{"name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"}]

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