$ymid = $ymids[$this->lcs];        for ($n = 0; $n < $nchunks - 1; $n++) {            $x1 = $xoff + (int)(($numer + ($xlim - $xoff) * $n) / $nchunks);            $y1 = $ymid[$n] + 1;            $seps[] = $flip ? array($y1, $x1) : array($x1, $y1);        }        $seps[] = $flip ? array($ylim, $xlim) : array($xlim, $ylim);        return array($this->lcs, $seps);    }    function _lcsPos($ypos)    {        $end = $this->lcs;        if ($end == 0 || $ypos > $this->seq[$end]) {            $this->seq[++$this->lcs] = $ypos;            $this->in_seq[$ypos] = 1;            return $this->lcs;        }        $beg = 1;        while ($beg < $end) {            $mid = (int)(($beg + $end) / 2);            if ($ypos > $this->seq[$mid]) {                $beg = $mid + 1;            } else {                $end = $mid;            }        }        assert($ypos != $this->seq[$end]);        $this->in_seq[$this->seq[$end]] = false;        $this->seq[$end] = $ypos;        $this->in_seq[$ypos] = 1;        return $end;    }    /**     * Finds LCS of two sequences.     *     * The results are recorded in the vectors $this->{x,y}changed[], by     * storing a 1 in the element for each line that is an insertion or     * deletion (ie. is not in the LCS).     *     * The subsequence of file 0 is (XOFF, XLIM) and likewise for file 1.     *     * Note that XLIM, YLIM are exclusive bounds.  All line numbers are     * origin-0 and discarded lines are not counted.     */    function _compareseq ($xoff, $xlim, $yoff, $ylim)    {        /* Slide down the bottom initial diagonal. */        while ($xoff < $xlim && $yoff < $ylim               && $this->xv[$xoff] == $this->yv[$yoff]) {            ++$xoff;            ++$yoff;        }        /* Slide up the top initial diagonal. */        while ($xlim > $xoff && $ylim > $yoff               && $this->xv[$xlim - 1] == $this->yv[$ylim - 1]) {            --$xlim;            --$ylim;        }        if ($xoff == $xlim || $yoff == $ylim) {            $lcs = 0;        } else {            /* This is ad hoc but seems to work well.  $nchunks =             * sqrt(min($xlim - $xoff, $ylim - $yoff) / 2.5); $nchunks =             * max(2,min(8,(int)$nchunks)); */            $nchunks = min(7, $xlim - $xoff, $ylim - $yoff) + 1;            list($lcs, $seps)                = $this->_diag($xoff, $xlim, $yoff, $ylim, $nchunks);        }        if ($lcs == 0) {            /* X and Y sequences have no common subsequence: mark all             * changed. */            while ($yoff < $ylim) {                $this->ychanged[$this->yind[$yoff++]] = 1;            }            while ($xoff < $xlim) {                $this->xchanged[$this->xind[$xoff++]] = 1;            }        } else {            /* Use the partitions to split this problem into subproblems. */            reset($seps);            $pt1 = $seps[0];            while ($pt2 = next($seps)) {                $this->_compareseq ($pt1[0], $pt2[0], $pt1[1], $pt2[1]);                $pt1 = $pt2;            }        }    }    /**     * Adjusts inserts/deletes of identical lines to join changes as much as     * possible.     *     * We do something when a run of changed lines include a line at one end     * and has an excluded, identical line at the other.  We are free to     * choose which identical line is included.  `compareseq' usually chooses     * the one at the beginning, but usually it is cleaner to consider the     * following identical line to be the "change".     *     * This is extracted verbatim from analyze.c (GNU diffutils-2.7).     */    function _shiftBoundaries($lines, &$changed, $other_changed)    {        $i = 0;        $j = 0;        assert('count($lines) == count($changed)');        $len = count($lines);        $other_len = count($other_changed);        while (1) {            /* Scan forward to find the beginning of another run of             * changes. Also keep track of the corresponding point in the             * other file.             *             * Throughout this code, $i and $j are adjusted together so that             * the first $i elements of $changed and the first $j elements of             * $other_changed both contain the same number of zeros (unchanged             * lines).             *             * Furthermore, $j is always kept so that $j == $other_len or             * $other_changed[$j] == false. */            while ($j < $other_len && $other_changed[$j]) {                $j++;            }            while ($i < $len && ! $changed[$i]) {                assert('$j < $other_len && ! $other_changed[$j]');                $i++; $j++;                while ($j < $other_len && $other_changed[$j]) {                    $j++;                }            }            if ($i == $len) {                break;            }            $start = $i;            /* Find the end of this run of changes. */            while (++$i < $len && $changed[$i]) {                continue;            }            do {                /* Record the length of this run of changes, so that we can                 * later determine whether the run has grown. */                $runlength = $i - $start;                /* Move the changed region back, so long as the previous                 * unchanged line matches the last changed one.  This merges                 * with previous changed regions. */                while ($start > 0 && $lines[$start - 1] == $lines[$i - 1]) {                    $changed[--$start] = 1;                    $changed[--$i] = false;                    while ($start > 0 && $changed[$start - 1]) {                        $start--;                    }                    assert('$j > 0');                    while ($other_changed[--$j]) {                        continue;                    }                    assert('$j >= 0 && !$other_changed[$j]');                }                /* Set CORRESPONDING to the end of the changed run, at the                 * last point where it corresponds to a changed run in the                 * other file. CORRESPONDING == LEN means no such point has                 * been found. */                $corresponding = $j < $other_len ? $i : $len;                /* Move the changed region forward, so long as the first                 * changed line matches the following unchanged one.  This                 * merges with following changed regions.  Do this second, so                 * that if there are no merges, the changed region is moved                 * forward as far as possible. */                while ($i < $len && $lines[$start] == $lines[$i]) {                    $changed[$start++] = false;                    $changed[$i++] = 1;                    while ($i < $len && $changed[$i]) {                        $i++;                    }                    assert('$j < $other_len && ! $other_changed[$j]');                    $j++;                    if ($j < $other_len && $other_changed[$j]) {                        $corresponding = $i;                        while ($j < $other_len && $other_changed[$j]) {                            $j++;                        }                    }                }            } while ($runlength != $i - $start);            /* If possible, move the fully-merged run of changes back to a             * corresponding run in the other file. */            while ($corresponding < $i) {                $changed[--$start] = 1;                $changed[--$i] = 0;                assert('$j > 0');                while ($other_changed[--$j]) {                    continue;                }                assert('$j >= 0 && !$other_changed[$j]');            }        }    }}