docs: private int gatherInfo(LblTree aT, int postorder) {
  		int currentSize = 0;
  		int childrenCount = 0;
  		int descSizes = 0;
  		int krSizesSum = 0;
  		int revkrSizesSum = 0;
  		int preorder = preorderTmp;
  
  		int heavyChild = -1;
  		int leftChild = -1;
  		int rightChild = -1;
  		int weight = -1;
  		int maxWeight = -1;
  		int currentPostorder = -1;
  		int oldHeavyChild = -1;
  
  		ArrayList<Integer> heavyRelSubtreesTmp = new ArrayList<>();
  		ArrayList<Integer> leftRelSubtreesTmp = new ArrayList<>();
  		ArrayList<Integer> rightRelSubtreesTmp = new ArrayList<>();
  
  		ArrayList<Integer> childrenPostorders = new ArrayList<>();
  
  		preorderTmp++;
  
  		// enumerate over children of current node
  		for (Enumeration<?> e = aT.children(); e.hasMoreElements(); ) {
  			childrenCount++;
  
  			postorder = gatherInfo((LblTree) e.nextElement(), postorder);
  
  			childrenPostorders.add(postorder);
  
  			currentPostorder = postorder;
  
  			// heavy path
  			weight = sizeTmp + 1;
  			if (weight >= maxWeight) {
  				maxWeight = weight;
  				oldHeavyChild = heavyChild;
  				heavyChild = currentPostorder;
  			} else {
  				heavyRelSubtreesTmp.add(currentPostorder);
  			}
  			if (oldHeavyChild != -1) {
  				heavyRelSubtreesTmp.add(oldHeavyChild);
  				oldHeavyChild = -1;
  			}
  
  			// left path
  			if (childrenCount == 1) {
  				leftChild = currentPostorder;
  			} else {
  				leftRelSubtreesTmp.add(currentPostorder);
  			}
  
  			// right path
  			rightChild = currentPostorder;
  			if (e.hasMoreElements()) {
  				rightRelSubtreesTmp.add(currentPostorder);
  			}
  
  			// subtree size
  			currentSize += 1 + sizeTmp;
  
  			descSizes += descSizesTmp;
  
  			if (childrenCount > 1) {
  				krSizesSum += krSizesSumTmp + sizeTmp + 1;
  			} else {
  				krSizesSum += krSizesSumTmp;
  				nodeType[LEFT][currentPostorder] = true;
  			}
  
  			if (e.hasMoreElements()) {
  				revkrSizesSum += revkrSizesSumTmp + sizeTmp + 1;
  			} else {
  				revkrSizesSum += revkrSizesSumTmp;
  				nodeType[RIGHT][currentPostorder] = true;
  			}
  		}
  
  		postorder++;
  
  		// postorder
  		aT.setTmpData(postorder);
  
  		int currentDescSizes = descSizes + currentSize + 1;
  		info[POST2_DESC_SUM][postorder] =
  				(currentSize + 1) * (currentSize + 1 + 3) / 2 - currentDescSizes;
  		info[POST2_KR_SUM][postorder] = krSizesSum + currentSize + 1;
  		info[POST2_REV_KR_SUM][postorder] = revkrSizesSum + currentSize + 1;
  
  		// POST2_LABEL
  		// labels[rootNumber] = ld.store(aT.getLabel());
  		info[POST2_LABEL][postorder] = ld.store(aT.getLabel());
  
  		// POST2_PARENT
  		for (Integer i : childrenPostorders) {
  			info[POST2_PARENT][i] = postorder;
  		}
  
  		// POST2_SIZE
  		info[POST2_SIZE][postorder] = currentSize + 1;
  		if (currentSize == 0) {
  			leafCount++;
  		}
  
  		// POST2_PRE
  		info[POST2_PRE][postorder] = preorder;
  
  		// PRE2_POST
  		info[PRE2_POST][preorder] = postorder;
  
  		// RPOST2_POST
  		info[RPOST2_POST][treeSize - 1 - preorder] = postorder;
  
  		// heavy path
  		if (heavyChild != -1) {
  			paths[HEAVY][postorder] = heavyChild;
  			nodeType[HEAVY][heavyChild] = true;
  
  			if (leftChild < heavyChild && heavyChild < rightChild) {
  				info[POST2_STRATEGY][postorder] = BOTH;
  			} else if (heavyChild == leftChild) {
  				info[POST2_STRATEGY][postorder] = RIGHT;
  			} else if (heavyChild == rightChild) {
  				info[POST2_STRATEGY][postorder] = LEFT;
  			}
  		} else {
  			info[POST2_STRATEGY][postorder] = RIGHT;
  		}
  
  		// left path
  		if (leftChild != -1) {
  			paths[LEFT][postorder] = leftChild;
  		}
  		// right path
  		if (rightChild != -1) {
  			paths[RIGHT][postorder] = rightChild;
  		}
  
  		// heavy/left/right relevant subtrees
  		relSubtrees[HEAVY][postorder] = toIntArray(heavyRelSubtreesTmp);
  		relSubtrees[RIGHT][postorder] = toIntArray(rightRelSubtreesTmp);
  		relSubtrees[LEFT][postorder] = toIntArray(leftRelSubtreesTmp);
  
  		descSizesTmp = currentDescSizes;
  		sizeTmp = currentSize;
  		krSizesSumTmp = krSizesSum;
  		revkrSizesSumTmp = revkrSizesSum;
  
  		return postorder;
  	}