/**

	 * This method takes an LCS result interspersed with zeros (i.e. empty slots 

	 * from the LCS algorithm), compacts it and shifts the LCS chunks as far towards 

	 * the front as possible. This tends to produce good results most of the time.

	 * 

	 * @param lcsSide A subsequence of original, presumably it is the LCS of it and

	 *            some other collection of lines

	 * @param length The number of non-empty (i.e non-zero) entries in LCS

	 * @param comparator The comparator used to generate the LCS

	 */

	 private void compactAndShiftLCS(int[] lcsSide, int length,

			IRangeComparator comparator) {

		// If the LCS is empty, just return

		if (length == 0)

			return;

		// Skip any leading empty slots

		int j = 0;

		while (lcsSide[j] == 0) {

			j++;

		}

		// Put the first non-empty value in position 0

		lcsSide[0] = lcsSide[j];

		j++;

		// Push all non-empty values down into the first N slots (where N is the length)

		for (int i = 1; i < length; i++) {

			while (lcsSide[j] == 0) {

				j++;

			}

			// Push the difference down as far as possible by comparing the line at the 

			// start of the diff with the line and the end and adjusting if they are the same

			int nextLine = lcsSide[i - 1] + 1;

			if (nextLine != lcsSide[j] && comparator.rangesEqual(nextLine - 1, comparator, lcsSide[j] - 1)) {

				lcsSide[i] = nextLine;

			} else {

				lcsSide[i] = lcsSide[j];

			}

			j++;

		}

		// Zero all slots after the length

		for (int i = length; i < lcsSide.length; i++) {

			lcsSide[i] = 0;

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.compare.internal.LCS#longestCommonSubsequence(org.eclipse.core.runtime.SubMonitor)

	 */

	public void longestCommonSubsequence(SubMonitor subMonitor) {

		super.longestCommonSubsequence(subMonitor);

		if (lcs != null) { // The LCS can be null if one of the sides is empty

			compactAndShiftLCS(lcs[0], getLength(), comparator1);

			compactAndShiftLCS(lcs[1], getLength(), comparator2);

		}

	}