function updateTerm(uint256 num) external onlyOwner() {
         term = num;
 
         emit UpdateTerm(
             term
         );
     }
 

     function requestDailyActionReward(address referrer) external whenNotPaused() {
         require(!isInTerm(msg.sender), "this sender got daily reward within term");
 
         emit Action(
             msg.sender,
             referrer,
             block.timestamp
         );
 
         latestActionTime[msg.sender] = block.timestamp;
     }
 

     function isInTerm(address sender) public view returns (bool) {
         if (latestActionTime[sender] == 0) {
             return false;
         } else if (block.timestamp >= latestActionTime[sender].add(term)) {
             return false;
         }
         return true;
     }
 

     event UpdateTerm(
         uint256 term
     );
 

     event Action(
         address indexed user,
         address indexed referrer,
         uint256 at
     );
 

     function updateMinimumAmount(uint256 _newMinimumAmount) external onlyOwner() {
         minimumAmount = _newMinimumAmount;
     }
 

     function updateEthBackRate(uint256 _newEthBackRate) external onlyOwner() {
         ethBackRate = _newEthBackRate;
     }
 

     function withdrawEther() external onlyOwner() {
         owner().transfer(address(this).balance);
     }
 

     function buy(address _referrer) external payable whenNotPaused() {
         require(msg.value >= minimumAmount, "msg.value should be more than minimum ether amount");
         
         address referrer;
         if (_referrer == msg.sender){
             referrer = address(0x0);
         } else {
             referrer = _referrer;
         }
         if ((referrer != address(0x0)) && isReferrer(referrer)) {
             referrer.transfer(msg.value.mul(ethBackRate).div(100));
         }
         emit Sold(
             msg.sender,
             referrer,
             msg.value,
             block.timestamp
         );
     }
 

     function getEthBackRate() external onlyOwner() view returns (uint256) {
         return ethBackRate;
     }
 

     event Sold(
         address indexed user,
         address indexed referrer,
         uint256 value,
         uint256 at
     );
 

   function transferOwnership(address newOwner) public onlyOwner {
     _transferOwnership(newOwner);
   }
 

   function renounceOwnership() public onlyOwner {
     emit OwnershipRenounced(_owner);
     _owner = address(0);
   }
 

   function isOwner() public view returns(bool) {
     return msg.sender == _owner;
   }
 

   function owner() public view returns(address) {
     return _owner;
   }
 

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

   event OwnershipRenounced(address indexed previousOwner);
 

   function pause() public onlyPauser whenNotPaused {
     _paused = true;
     emit Paused();
   }
 

   function unpause() public onlyPauser whenPaused {
     _paused = false;
     emit Unpaused();
   }
 

   function paused() public view returns(bool) {
     return _paused;
   }
 

   event Unpaused();
 

   event Paused();
 

   function addPauser(address account) public onlyPauser {
     pausers.add(account);
     emit PauserAdded(account);
   }
 

   function renouncePauser() public {
     pausers.remove(msg.sender);
   }
 

   function isPauser(address account) public view returns (bool) {
     return pausers.has(account);
   }
 

   constructor() public {
     pausers.add(msg.sender);
   }
 

   event PauserRemoved(address indexed account);
 

   event PauserAdded(address indexed account);
 

     function addReferrer(address account) public onlyOwner() {
         referrers.add(account);
         emit ReferrerAdded(account);
     }
 

     function removeReferrer(address account) public onlyOwner() {
         referrers.remove(account);
         emit ReferrerRemoved(account);
     }
 

     function isReferrer(address account) public view returns (bool) {
         return referrers.has(account);
     }
 

     event ReferrerRemoved(address indexed account);
 

     event ReferrerAdded(address indexed account);
 

     mapping(address => uint256) public latestActionTime;
 

     uint256 public term;