docs: private Entry insertHere(Entry newEntry, Node currentNode,
  	        Entry parentEntry, ClusKernel carriedBuffer, Budget budget,
  	        long timestamp) {
  	
  	    int numFreeEntries = currentNode.numFreeEntries();
  	
  	    // Insert the buffer that we carry.
  	    if (!carriedBuffer.isEmpty()) {
  	        Entry bufferEntry = new Entry(this.numberDimensions,
  	                carriedBuffer, timestamp, parentEntry, currentNode);
  	
  	        if (numFreeEntries <= 1) {
  	            // Distance from buffer to entries.
  	            Entry nearestEntryToCarriedBuffer =
  	                    currentNode.nearestEntry(newEntry);
  	            double distanceNearestEntryToBuffer =
  	                    nearestEntryToCarriedBuffer.calcDistance(newEntry);
  	
  	            // Distance between buffer and point to insert.
  	            double distanceBufferNewEntry =
  	                    newEntry.calcDistance(carriedBuffer);
  	
  	            // Best distance between Entrys in the Node.
  	            BestMergeInNode bestMergeInNode =
  	                    calculateBestMergeInNode(currentNode);
  	
  	            // See what the minimal distance is and do the correspoding
  	            // action.
  	            if (distanceNearestEntryToBuffer <= distanceBufferNewEntry
  	                    && distanceNearestEntryToBuffer <= bestMergeInNode.distance) {
  	                // Aggregate buffer entry to nearest entry in node.
  	                nearestEntryToCarriedBuffer.aggregateEntry(bufferEntry,
  	                        timestamp, this.negLambda);
  	            } else if (distanceBufferNewEntry <= distanceNearestEntryToBuffer
  	                    && distanceBufferNewEntry <= bestMergeInNode.distance) {
  	                newEntry.mergeWith(bufferEntry);
  	            } else {
  	                currentNode.mergeEntries(bestMergeInNode.entryPos1,
  	                        bestMergeInNode.entryPos2);
  	                currentNode.addEntry(bufferEntry, timestamp);
  	            }
  	
  	        } else {
  	            assert (currentNode.isLeaf());
  	            currentNode.addEntry(bufferEntry, timestamp);
  	        }
  	    }
  	
  	    // Normally the insertion of the carries buffer does not change the
  	    // number of free entries, but in case of future changes we calculate
  	    // the number again.
  	    numFreeEntries = currentNode.numFreeEntries();
  	
  	    // Search for an Entry with a weight under the threshold.
  	    Entry irrelevantEntry = currentNode.getIrrelevantEntry(this.weightThreshold);
  	    if (currentNode.isLeaf() && irrelevantEntry != null) {
  	        irrelevantEntry.overwriteOldEntry(newEntry);
  	    } else if (numFreeEntries >= 1) {
  	        currentNode.addEntry(newEntry, timestamp);
  	    } else {
  	        if (currentNode.isLeaf() && (this.hasMaximalSize()
  	                || !budget.hasMoreTime())) {
  	            mergeEntryWithoutSplit(currentNode, newEntry,
  	                    timestamp);
  	        } else {
  	            // We have to split.
  	            return split(newEntry, currentNode, parentEntry, timestamp);
  	        }
  	    }
  	
  	    return null;
  	}