return '<'

            if groups[2]:

                return '>'

            if groups[3]:

                return '<u>\t</u>'

            if groups[4]:

                return '<u class="cr"></u>'

            if groups[5]:

                return ' <i></i>'

            assert False

        return self._escape_re.sub(substitute, safe_unicode(string))

    def _line_counter(self, l):

        """

        Checks each line and bumps total adds/removes for this diff

        :param l:

        """

        if l.startswith('+') and not l.startswith('+++'):

            self.adds += 1

        elif l.startswith('-') and not l.startswith('---'):

            self.removes += 1

        return safe_unicode(l)

    def _highlight_line_difflib(self, line, next_):

        """

        Highlight inline changes in both lines.

        """

        if line['action'] == 'del':

            old, new = line, next_

        else:

            old, new = next_, line

        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 _highlight_line_udiff(self, line, next_):

        """

        Highlight inline changes in both lines.

        """

        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:

        """

        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)

        groups = 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 diff header: %r followed by %r' % (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 groups, difflines

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

                                        % (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 = []

            if op == 'D' and chunks:

                # a way of seeing deleted content could perhaps be nice - but

                # not with the current UI

                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,

            })

        if not inline_diff:

            return diff_container(_files)

        # 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(_files)

    def _parse_udiff(self, inline_diff=True):

        raise NotImplementedError()

    def _parse_lines(self, diff):

        """

        Parse the diff and return data for the template.

        """

        stats = [0, 0]

        (old_line, old_end, new_line, new_end) = (None, None, None, None)

        try:

            chunks = []

            line = diff.next()

            while True:

                lines = []

                chunks.append(lines)

                match = self._chunk_re.match(line)

                if not match:

                    raise Exception('error parsing diff @@ line %r' % line)

                gr = match.groups()

                (old_line, old_end,

                 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'

                        stats[0] += 1

                    elif command == '-':

                        affects_old = True

                        action = 'del'

                        stats[1] += 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':         self._clean_line(line, command)

                        })

                    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':         self._clean_line(line, command)

                        })

                        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, stats

    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', "_", '%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'l return a list

        of dicts with diff information

        """

        parsed = self._parser(inline_diff=inline_diff)

        self.parsed = True

        self.parsed_diff = parsed

        return parsed

    def as_raw(self, diff_lines=None):

        """

        Returns raw string diff

        """

        return self._diff

        #return u''.join(imap(self._line_counter, self._diff.splitlines(1)))

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

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

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

        """

        Return given diff as html table with customized css classes

        """

        def _link_to_if(condition, label, url):

            """

            Generates a link if condition is meet or just the label if not.

            """

            if condition:

                return '''<a href="%(url)s">%(label)s</a>''' % {

                    'url': url,

                    'label': label

                }

            else:

                return label

        if not self.parsed:

            self.prepare()

        diff_lines = self.parsed_diff

        if parsed_lines:

            diff_lines = parsed_lines

        _html_empty = True

        _html = []

        _html.append('''<table class="%(table_class)s">\n''' % {

            'table_class': table_class

        })

        for diff in diff_lines:

            for line in diff['chunks']:

                _html_empty = False

                for change in line:

                    _html.append('''<tr class="%(lc)s %(action)s">\n''' % {

                        'lc': line_class,

                        'action': change['action']

                    })

                    anchor_old_id = ''

                    anchor_new_id = ''

                    anchor_old = "%(filename)s_o%(oldline_no)s" % {

                        'filename': self._safe_id(diff['filename']),

                        'oldline_no': change['old_lineno']

                    }

                    anchor_new = "%(filename)s_n%(oldline_no)s" % {

                        'filename': self._safe_id(diff['filename']),

                        'oldline_no': change['new_lineno']

                    }

                    cond_old = (change['old_lineno'] != '...' and

                                change['old_lineno'])

                    cond_new = (change['new_lineno'] != '...' and

                                change['new_lineno'])

                    if cond_old:

                        anchor_old_id = 'id="%s"' % anchor_old

                    if cond_new:

                        anchor_new_id = 'id="%s"' % anchor_new

                    ###########################################################

                    # OLD LINE NUMBER

                    ###########################################################

                        'a_id': anchor_old_id,

                    })

                    _html.append('''%(link)s''' % {

                        'link': _link_to_if(True, change['old_lineno'],

                                            '#%s' % anchor_old)

                    })

                    _html.append('''</td>\n''')

                    ###########################################################

                    # NEW LINE NUMBER

                    ###########################################################

                    ###########################################################

                    # CODE

                    ###########################################################

                    comments = '' if enable_comments else 'no-comment'

                    _html.append('''\t<td class="%(cc)s %(inc)s">''' % {

                        'cc': code_class,

                        'inc': comments

                    })

                    _html.append('''\n\t\t<div class="add-bubble"><div>&nbsp;</div></div><pre>%(code)s</pre>\n''' % {

                        'code': change['line']

                    })

                    _html.append('''\t</td>''')

                    _html.append('''\n</tr>\n''')

        _html.append('''</table>''')

        if _html_empty:

            return None

        return ''.join(_html)

    def stat(self):

        """

        Returns tuple of added, and removed lines for this instance

        """

        return self.adds, self.removes

    padding: 1px;

}

.inline-comments .comment .meta {

    background: #f8f8f8;

    padding: 4px;

    border-bottom: 1px solid #ddd;

    min-height: 20px;

    overflow: auto;

}

.inline-comments .comment .meta img {

    vertical-align: middle;

}

.inline-comments .comment .meta .user {

    font-weight: bold;

    float: left;

    padding: 3px;

}

.inline-comments .comment .meta .date {

    float: left;

    padding: 3px;

}

.inline-comments .comment .text {

    background-color: #FAFAFA;

}

.inline-comments .comments-number {

    padding: 0px 0px 10px 0px;

    font-weight: bold;

    color: #666;

    font-size: 16px;

}

.inline-comments-button .add-comment {

    margin: 2px 0px 8px 5px !important

}

.notification-paginator {

    padding: 0px 0px 4px 16px;

}

#context-pages .pull-request span,

.menu_link_notifications {

    padding: 4px 4px !important;

    text-align: center;

    color: #888 !important;

    background-color: #DEDEDE !important;

    border-radius: 4px !important;

    -webkit-border-radius: 4px !important;

}

#context-pages .forks span,

.menu_link_notifications {

    padding: 4px 4px !important;

    text-align: center;

    color: #888 !important;

    background-color: #DEDEDE !important;

    border-radius: 4px !important;

    -webkit-border-radius: 4px !important;

}

.notification-header {

    padding-top: 6px;

}

.notification-header .desc {

    font-size: 16px;

    height: 24px;

    float: left

}

.notification-list .container.unread {

    background: none repeat scroll 0 0 rgba(255, 255, 180, 0.6);

}

.notification-header .gravatar {

    background: none repeat scroll 0 0 transparent;

    padding: 0px 0px 0px 8px;

}

.notification-list .container .notification-header .desc {

    font-weight: bold;

    font-size: 17px;

}

.notification-table {

    border: 1px solid #ccc;

    -webkit-border-radius: 6px 6px 6px 6px;

    border-radius: 6px 6px 6px 6px;

    clear: both;

    margin: 0px 20px 0px 20px;

}

.notification-header .delete-notifications {

    float: right;

    padding-top: 8px;

    cursor: pointer;

}

.notification-header .read-notifications {

    float: right;

    padding-top: 8px;

    cursor: pointer;

}

.notification-subject {

    clear: both;

    border-bottom: 1px solid #eee;

    padding: 5px 0px 5px 38px;

}

.notification-body {

    clear: both;

    margin: 34px 2px 2px 8px

}

/****

PULL REQUESTS

*****/

.pullrequests_section_head {

    padding: 10px 10px 10px 0px;

    margin: 0 20px;

    font-size: 16px;

    font-weight: bold;

}

div.pr-details-title.closed {

    color: #555;

    background: #eee;

}

div.pr-details-title {

    font-size: 1.6em;

    padding: 5px 0px 5px 10px;

}

div.pr {

    margin: 0px 20px;

    padding: 4px 4px;

}

div.pr-desc {

    margin: 0px 20px;

}

tr.pr-closed td {

    background-color: #eee !important;

    color: #555 !important;

}

span.pr-closed-tag {

    margin-bottom: 1px;

    margin-right: 1px;

    padding: 1px 3px;

    font-size: 10px;

    padding: 1px 3px 1px 3px;

    font-size: 10px;

    color: #577632;

    white-space: nowrap;

    -webkit-border-radius: 4px;

    border-radius: 4px;

    border: 1px solid #d9e8f8;

    line-height: 1.5em;

}

.pr-box {

    max-width: 978px;

}

#s2id_org_ref,

#s2id_other_ref,

#s2id_org_repo,

#s2id_other_repo {

    min-width: 150px;

    margin: 5px;

}

#pr-summary .msg-div {

    margin: 5px 0;

}

/****

  PERMS

*****/

#perms .perms_section_head {

    padding: 10px 10px 10px 0px;

    font-size: 16px;

    font-weight: bold;

    text-transform: capitalize;

}

#perms .perm_tag {

    padding: 1px 3px 1px 3px;

    font-size: 10px;

    font-weight: bold;

    text-transform: uppercase;

    white-space: nowrap;

    -webkit-border-radius: 3px;

    border-radius: 3px;

}

#perms .perm_tag.admin {

    background-color: #B94A48;

    color: #ffffff;

}

#perms .perm_tag.write {

    background-color: #DB7525;

    color: #ffffff;

}

#perms .perm_tag.read {

    background-color: #468847;

    color: #ffffff;

}

#perms .perm_tag.none {

    background-color: #bfbfbf;

    color: #ffffff;

}

.perm-gravatar {

    vertical-align: middle;

    padding: 2px;

}

.perm-gravatar-ac {

    vertical-align: middle;

    padding: 2px;

    width: 14px;

    height: 14px;

}

/*****************************************************************************

                                  DIFFS CSS

******************************************************************************/

.diff-collapse {

    text-align: center;

    margin-bottom: -15px;

}

.diff-collapse-button {

    cursor: pointer;

    color: #666;

    font-size: 16px;

}

.diff-container {

}

.diff-container.hidden {

    display: none;

    overflow: hidden;

}

div.diffblock {

    overflow: auto;

    padding: 0px;

    border: 1px solid #ccc;

    background: #f8f8f8;

    font-size: 100%;

    line-height: 100%;

    /* new */

    line-height: 125%;

    -webkit-border-radius: 6px 6px 0px 0px;

    border-radius: 6px 6px 0px 0px;

}

div.diffblock.margined {

    margin: 0px 20px 0px 20px;

}

div.diffblock .code-header {

    border-bottom: 1px solid #CCCCCC;

    background: #EEEEEE;

    padding: 10px 0 10px 0;

    min-height: 14px;

}

div.diffblock .code-header.banner {

    border-bottom: 1px solid #CCCCCC;

    background: #EEEEEE;

    height: 14px;

    margin: 0;

    padding: 3px 100px 11px 100px;

}

div.diffblock .code-header-title {

    padding: 0px 0px 10px 5px !important;

    margin: 0 !important;

}

div.diffblock .code-header .hash {

    float: left;

    padding: 2px 0 0 2px;

}

div.diffblock .code-header .date {

    float: left;

    text-transform: uppercase;

    padding: 2px 0px 0px 2px;

}

div.diffblock .code-header div {

    margin-left: 4px;

    font-weight: bold;

    font-size: 14px;

}

div.diffblock .parents {

    float: left;

    min-height: 26px;

    font-size: 10px;

    font-weight: 400;

    vertical-align: middle;

    padding: 0px 2px 2px 2px;

    background-color: #eeeeee;

    border-bottom: 1px solid #CCCCCC;

}

div.diffblock .children {

    float: right;

    min-height: 26px;

    font-size: 10px;

    font-weight: 400;

    vertical-align: middle;

    text-align: right;

    padding: 0px 2px 2px 2px;

    background-color: #eeeeee;

    border-bottom: 1px solid #CCCCCC;

}

div.diffblock .code-body {

    background: #FFFFFF;

    clear: both;

}

div.diffblock pre.raw {

    background: #FFFFFF;

    color: #000000;

}

table.code-difftable {

    border-collapse: collapse;

    width: 99%;

    border-radius: 0px !important;

}

table.code-difftable td {

    padding: 0 !important;

    background: none !important;

    border: 0 !important;

    vertical-align: baseline !important

}

table.code-difftable .context {

    background: none repeat scroll 0 0 #DDE7EF;

    color: #999;

}

table.code-difftable .add {

    background: none repeat scroll 0 0 #DDFFDD;

}

table.code-difftable .add ins {

    background: none repeat scroll 0 0 #AAFFAA;

    text-decoration: none;

}

table.code-difftable .del {

    background: none repeat scroll 0 0 #FFDDDD;

}

table.code-difftable .del del {

    background: none repeat scroll 0 0 #FFAAAA;

    text-decoration: none;

}

table.code-highlighttable div.code-highlight pre u:before,

table.code-difftable td.code pre u:before {

    content: "\21a6";

    display: inline-block;

    width: 0;

}

table.code-highlighttable div.code-highlight pre u.cr:before,

table.code-difftable td.code pre u.cr:before {

    content: "\21a4";