function core(uint256 _round, uint256 _pID, uint256 _eth) internal {
      Round memory current = rounds[currentRound];

      
      if (playerRoundData[_pID][_round].keys == 0) {
          updatePlayer(_pID);
      }
      
      if (block.timestamp > current.endTime) {
          
          finalize(players[_pID].referer);
          
          
          updatePlayer(_pID);
      }
      
      
      Round storage current_now = rounds[currentRound];
      
      
      uint256 _keys = keys(_eth);
      
      if (_keys <= 0) {
          
          
          players[_pID].wallet = _eth.add(players[_pID].wallet);
          return;
      }

      if (_keys >= decimals) {
          
          current_now.winner = players[_pID].addr;
          current_now.endTime = current_now.endTime.add(timeGap);
          if (current_now.endTime.sub(block.timestamp) > maxTimeRemain) {
              current_now.endTime = block.timestamp.add(maxTimeRemain);
          }
      }
      
      
      uint256 toOwner = _eth.sub(_eth.mul(ta) / 1000);
      toOwner = toOwner.sub(_eth.mul(tb) / 1000);
      toOwner = toOwner.sub(_eth.mul(tc) / 1000);
      toOwner = toOwner.sub(_eth.mul(td) / 1000);
      
      
      current_now.pool = (_eth.mul(ta) / 1000).add(current_now.pool);
      
      if (current_now.keys == 0) {
          
          toOwner = toOwner.add((_eth.mul(tb) / 1000));
          players[0].wallet = toOwner.add(players[0].wallet);
      } else {
          current_now.mask = current_now.mask.add((_eth.mul(tb) / 1000) / current_now.keys);
          
          
          uint256 dust = (_eth.mul(tb) / 1000).sub( _eth.mul(tb) / 1000 / current_now.keys * current_now.keys );
          players[0].wallet = toOwner.add(dust).add(players[0].wallet);
      }
      
      playerRoundData[_pID][currentRound].keys = _keys.add(playerRoundData[_pID][currentRound].keys);
      current_now.keys = _keys.add(current_now.keys);
      current_now.eth = _eth.add(current_now.eth);

      
      playerRoundData[_pID][currentRound].mask = current_now.mask.mul(_keys).add(playerRoundData[_pID][currentRound].mask);
      
      
      uint256 referer1 = players[_pID].referer;
      uint256 referer2 = players[referer1].referer;
      players[referer1].affiliate = (_eth.mul(tc) / 1000).add(players[referer1].affiliate);
      players[referer2].affiliate = (_eth.mul(td) / 1000).add(players[referer2].affiliate);
  }