docs: private Entry insert(ClusKernel pointToInsert, ClusKernel carriedBuffer,
              Node currentNode, Entry parentEntry, Budget budget, long timestamp) {
          assert (currentNode != null);
          assert (currentNode.isLeaf()
                  || currentNode.getEntries()[0].getChild() != null);
  
          currentNode.makeOlder(timestamp, this.negLambda);
  
          // This variable will be changed from to null to an actual reference
          // in the following if-else block if we have to insert something here,
          // either because this is a leaf, or because of split propagation.
          Entry toInsertHere = null;
  
          if (currentNode.isLeaf()) {
              // At the end of the function the entry will be inserted.
              toInsertHere = new Entry(this.numberDimensions,
                      pointToInsert, timestamp, parentEntry, currentNode);
          } else {
  
              Entry bestEntry = currentNode.nearestEntry(pointToInsert);
              bestEntry.aggregateCluster(pointToInsert, timestamp,
                      this.negLambda);
  
              boolean isCarriedBufferEmpty = carriedBuffer.isEmpty();
  
              Entry bestBufferEntry = null;
              if (!isCarriedBufferEmpty) {
                  bestBufferEntry = currentNode.nearestEntry(carriedBuffer);
                  bestBufferEntry.aggregateCluster(carriedBuffer, timestamp,
                          this.negLambda);
              }
  
              if (!budget.hasMoreTime()) {
                  bestEntry.aggregateToBuffer(pointToInsert, timestamp,
                          this.negLambda);
                  if (!isCarriedBufferEmpty) {
                      bestBufferEntry.aggregateToBuffer(carriedBuffer,
                              timestamp, this.negLambda);
                  }
                  return null;
              }
  
              // If the way of the buffer differs from the way of the point to
              // be inserted, leave the buffer here.
              if (!isCarriedBufferEmpty && (bestEntry != bestBufferEntry)) {
                  bestBufferEntry.aggregateToBuffer(carriedBuffer, timestamp,
                          this.negLambda);
                  carriedBuffer.clear();
              }
              // Take the buffer of the best entry for the point to be inserted
              // along.
              ClusKernel takeAlongBuffer = bestEntry.emptyBuffer(timestamp,
                      this.negLambda);
              carriedBuffer.add(takeAlongBuffer);
  
              // Recursive call.
              toInsertHere = insert(pointToInsert, carriedBuffer,
                      bestEntry.getChild(), bestEntry, budget, timestamp);
          }
  
          // If the above block has a new Entry for this place insert it.
          if (toInsertHere != null) {
              return this.insertHere(toInsertHere, currentNode, parentEntry,
                      carriedBuffer, budget, timestamp);
          }
  
          // If nothing else needs to be done in all the above levels
          // return null to signalize it.
          return null;
      }