assert old['action'] == 'del'

        assert new['action'] == 'add'

        oldwords = self._token_re.split(old['line'])

        newwords = self._token_re.split(new['line'])

        sequence = difflib.SequenceMatcher(None, oldwords, newwords)

        oldfragments, newfragments = [], []

        for tag, i1, i2, j1, j2 in sequence.get_opcodes():

            oldfrag = ''.join(oldwords[i1:i2])

            newfrag = ''.join(newwords[j1:j2])

            if tag != 'equal':

                if oldfrag:

                    oldfrag = '<del>%s</del>' % oldfrag

                if newfrag:

                    newfrag = '<ins>%s</ins>' % newfrag

            oldfragments.append(oldfrag)

            newfragments.append(newfrag)

        old['line'] = "".join(oldfragments)

        new['line'] = "".join(newfragments)

    def _get_header(self, diff_chunk):

        """

        Parses a Git diff for a single file (header and chunks) and returns a tuple with:

        1. A dict with meta info:

            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

        2. An iterator yielding lines with simple HTML markup.

        """

        match = None

        if self.vcs == 'git':

            match = self._git_header_re.match(diff_chunk)

        elif self.vcs == 'hg':

            match = self._hg_header_re.match(diff_chunk)

        if match is None:

            raise Exception('diff not recognized as valid %s diff' % self.vcs)

        meta_info = match.groupdict()

        rest = diff_chunk[match.end():]

        if rest and not rest.startswith('@') and not rest.startswith('literal ') and not rest.startswith('delta '):

            raise Exception('cannot parse %s diff header: %r followed by %r' % (self.vcs, diff_chunk[:match.end()], rest[:1000]))

        difflines = imap(self._escaper, re.findall(r'.*\n|.+$', rest)) # don't split on \r as str.splitlines do

        return meta_info, difflines

    def _parse_gitdiff(self, inline_diff=True):

        """Parse self._diff and return a list of dicts with meta info and chunks for each file.

        If diff is truncated, wrap it in LimitedDiffContainer.

        Optionally, do an extra pass and to extra markup of one-liner changes.

        """

        _files = [] # list of dicts with meta info and chunks

        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 = 'R'

                    stats['binary'] = True

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

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

                # COPY

                if head.get('copy_from') and head.get('copy_to'):

                    op = 'M'

                    stats['binary'] = True

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

                 new_line, new_end) = [int(x or 1) for x in gr[:-1]]

                old_line -= 1

                new_line -= 1

                context = len(gr) == 5

                old_end += old_line

                new_end += new_line

                if context:

                    # skip context only if it's first line

                    if int(gr[0]) > 1:

                        lines.append({

                            'old_lineno': '...',

                            'new_lineno': '...',

                            'action':     'context',

                            'line':       line,

                        })

                line = diff.next()

                while old_line < old_end or new_line < new_end:

                    if not line:

                        raise Exception('error parsing diff - empty line at -%s+%s' % (old_line, new_line))

                    affects_old = affects_new = False

                    command = line[0]

                    if command == '+':

                        affects_new = True

                        action = 'add'

                        added += 1

                    elif command == '-':

                        affects_old = True

                        action = 'del'

                        deleted += 1

                    elif command == ' ':

                        affects_old = affects_new = True

                        action = 'unmod'

                    else:

                        raise Exception('error parsing diff - unknown command in line %r at -%s+%s' % (line, old_line, new_line))

                    if not self._newline_marker.match(line):

                        old_line += affects_old

                        new_line += affects_new

                        lines.append({

                            'old_lineno':   affects_old and old_line or '',

                            'new_lineno':   affects_new and new_line or '',

                            'action':       action,

                        })

                    line = diff.next()

                    if self._newline_marker.match(line):

                        # we need to append to lines, since this is not

                        # counted in the line specs of diff

                        lines.append({

                            'old_lineno':   '...',

                            'new_lineno':   '...',

                            'action':       'context',

                        })

                        line = diff.next()

                if old_line > old_end:

                    raise Exception('error parsing diff - more than %s "-" lines at -%s+%s' % (old_end, old_line, new_line))

                if new_line > new_end:

                    raise Exception('error parsing diff - more than %s "+" lines at -%s+%s' % (new_end, old_line, new_line))

        except StopIteration:

            pass

        if old_line != old_end or new_line != new_end:

            raise Exception('diff processing broken when old %s<>%s or new %s<>%s line %r' % (old_line, old_end, new_line, new_end, line))

        return chunks, added, deleted

    def _safe_id(self, idstring):

        """Make a string safe for including in an id attribute.

        The HTML spec says that id attributes 'must begin with

        a letter ([A-Za-z]) and may be followed by any number

        of letters, digits ([0-9]), hyphens ("-"), underscores

        ("_"), colons (":"), and periods (".")'. These regexps

        are slightly over-zealous, in that they remove colons

        and periods unnecessarily.

        Whitespace is transformed into underscores, and then

        anything which is not a hyphen or a character that

        matches \w (alphanumerics and underscore) is removed.

        """

        # Transform all whitespace to underscore

        idstring = re.sub(r'\s', "_", idstring)

        # Remove everything that is not a hyphen or a member of \w

        idstring = re.sub(r'(?!-)\W', "", idstring).lower()

        return idstring

    def prepare(self, inline_diff=True):

        """

        Prepare the passed udiff for HTML rendering. It'll return a list

        of dicts with diff information

        """

        parsed = self._parse_gitdiff(inline_diff=inline_diff)

        self.parsed = True

        self.parsed_diff = parsed

        return parsed

    def as_html(self, table_class='code-difftable', line_class='line',

                old_lineno_class='lineno old', new_lineno_class='lineno new',

                no_lineno_class='lineno',

                code_class='code', enable_comments=False, parsed_lines=None):