"""

        start = 0

        limit = min(len(line['line']), len(next_['line']))

        while start < limit and line['line'][start] == next_['line'][start]:

            start += 1

        end = -1

        limit -= start

        while -end <= limit and line['line'][end] == next_['line'][end]:

            end -= 1

        end += 1

        if start or end:

            def do(l):

                last = end + len(l['line'])

                if l['action'] == 'add':

                    tag = 'ins'

                else:

                    tag = 'del'

                l['line'] = '%s<%s>%s</%s>%s' % (

                    l['line'][:start],

                    tag,

                    l['line'][start:last],

                    tag,

                    l['line'][last:]

                )

            do(line)

            do(next_)

    def _get_header(self, diff_chunk):

        """

        parses the diff header, and returns parts, and leftover diff

        parts consists of 14 elements::

            a_path, b_path, similarity_index, rename_from, rename_to,

            old_mode, new_mode, new_file_mode, deleted_file_mode,

            a_blob_id, b_blob_id, b_mode, a_file, b_file

        :param diff_chunk:

        """

        if self.vcs == 'git':

            match = self._git_header_re.match(diff_chunk)

            diff = diff_chunk[match.end():]

            return match.groupdict(), imap(self._escaper, diff.splitlines(1))

        elif self.vcs == 'hg':

            match = self._hg_header_re.match(diff_chunk)

            diff = diff_chunk[match.end():]

            return match.groupdict(), imap(self._escaper, diff.splitlines(1))

        else:

            raise Exception('VCS type %s is not supported' % self.vcs)

    def _clean_line(self, line, command):

        if command in ['+', '-', ' ']:

            #only modify the line if it's actually a diff thing

            line = line[1:]

        return line

    def _parse_gitdiff(self, inline_diff=True):

        _files = []

        diff_container = lambda arg: arg

        ##split the diff in chunks of separate --git a/file b/file chunks

        for raw_diff in ('\n' + self._diff).split('\ndiff --git')[1:]:

            head, diff = self._get_header(raw_diff)

            op = None

            stats = {

                'added': 0,

                'deleted': 0,

                'binary': False,

                'ops': {},

            }

            if head['deleted_file_mode']:

                op = 'D'

                stats['binary'] = True

                stats['ops'][DEL_FILENODE] = 'deleted file'

            elif head['new_file_mode']:

                op = 'A'

                stats['binary'] = True

                stats['ops'][NEW_FILENODE] = 'new file %s' % head['new_file_mode']

            else:  # modify operation, can be cp, rename, chmod

                # CHMOD

                if head['new_mode'] and head['old_mode']:

                    op = 'M'

                    stats['binary'] = True

                    stats['ops'][CHMOD_FILENODE] = ('modified file chmod %s => %s'

                                        % (head['old_mode'], head['new_mode']))

                # RENAME

                if (head['rename_from'] and head['rename_to']

                      and head['rename_from'] != head['rename_to']):

                    op = 'M'

                    stats['binary'] = True

                    stats['ops'][RENAMED_FILENODE] = ('file renamed from %s to %s'

                                    % (head['rename_from'], head['rename_to']))

                # COPY

                    op = 'M'

                    stats['binary'] = True

                    stats['ops'][COPIED_FILENODE] = ('file copied from %s to %s'

                                        % (head['copy_from'], head['copy_to']))

                # FALL BACK: detect missed old style add or remove

                if op is None:

                    if not head['a_file'] and head['b_file']:

                        op = 'A'

                        stats['binary'] = True

                        stats['ops'][NEW_FILENODE] = 'new file'

                    elif head['a_file'] and not head['b_file']:

                        op = 'D'

                        stats['binary'] = True

                        stats['ops'][DEL_FILENODE] = 'deleted file'

                # it's not ADD not DELETE

                if op is None:

                    op = 'M'

                    stats['binary'] = True

                    stats['ops'][MOD_FILENODE] = 'modified file'

            # a real non-binary diff

            if head['a_file'] or head['b_file']:

                try:

                    chunks, _stats = self._parse_lines(diff)

                    stats['binary'] = False

                    stats['added'] = _stats[0]

                    stats['deleted'] = _stats[1]

                    # explicit mark that it's a modified file

                    if op == 'M':

                        stats['ops'][MOD_FILENODE] = 'modified file'

                except DiffLimitExceeded:

                    diff_container = lambda _diff: \

                        LimitedDiffContainer(self.diff_limit,

                                            self.cur_diff_size, _diff)

                    break

            else:  # GIT binary patch (or empty diff)

                # GIT Binary patch

                if head['bin_patch']:

                    stats['ops'][BIN_FILENODE] = 'binary diff not shown'

                chunks = []

            chunks.insert(0, [{

                'old_lineno': '',

                'new_lineno': '',

                'action':     'context',

                'line':       msg,

                } for _op, msg in stats['ops'].iteritems()

                  if _op not in [MOD_FILENODE]])

            _files.append({

                'filename':         head['b_path'],

                'old_revision':     head['a_blob_id'],

                'new_revision':     head['b_blob_id'],

                'chunks':           chunks,

                'operation':        op,

                'stats':            stats,

            })

        sorter = lambda info: {'A': 0, 'M': 1, 'D': 2}.get(info['operation'])

        if not inline_diff:

            return diff_container(sorted(_files, key=sorter))

        # highlight inline changes

        for diff_data in _files:

            for chunk in diff_data['chunks']:

                lineiter = iter(chunk)

                try:

                    while 1:

                        line = lineiter.next()

                        if line['action'] not in ['unmod', 'context']:

                            nextline = lineiter.next()

                            if nextline['action'] in ['unmod', 'context'] or \

                               nextline['action'] == line['action']:

                                continue

                            self.differ(line, nextline)

                except StopIteration:

                    pass

        return diff_container(sorted(_files, key=sorter))

    def _parse_udiff(self, inline_diff=True):

        raise NotImplementedError()

    def _parse_lines(self, diff):

        """

        Parse the diff an return data for the template.

        """

        lineiter = iter(diff)

        stats = [0, 0]

        try: