@@ -1,41 +1,59 @@

 # [`readline-vim`][]

-Upgrade [Readline][] from [`vi`][] to [Vim][].

+Upgrade [Readline][] from [vi][] to [Vim][].

-[`readline-vim`][] is a Python program that generates [Readline][] macros that

-provide [Vim][] [motions][], [operators][] and [text objects][] (that are

-useful on a single line).

+[`readline-vim`][] is a [Python][] script that generates [Readline][] macros

+(4658 of them) that provide [Vim][] [motions][], [operators][] and [text

+objects][] (the ones that are useful on a single line) as well as functionality

+from the popular [`vim-surround`][].

 [`readline-vim`]: https://git.rcrnstn.net/rcrnstn/readline-vim

-[Python]: https://www.python.org

 [Readline]: https://en.wikipedia.org/wiki/Readline

-[`vi`]: https://en.wikipedia.org/wiki/vi

-[Vim]: https://en.wikipedia.org/wiki/Vim

+[vi]: https://en.wikipedia.org/wiki/vi

+[Vim]: https://en.wikipedia.org/wiki/Vim_(text_editor)

+[Python]: https://www.python.org

 [motions]: https://vimhelp.org/motion.txt.html

 [operators]: https://vimhelp.org/motion.txt.html#operator

 [text objects]: https://vimhelp.org/motion.txt.html#text-objects

+[`vim-surround`]: https://github.com/tpope/vim-surround

 ## Background

 [Readline][] is a library that provides line-editing for interactive

 command-line programs. It is used in a great many places, including shells such

-as [Bash][] (where it originated) and [REPL][]s such as [Python][] or

-[Octave][]. Using [`rlwrap`][], Readline can even be used with programs that

-doesn't have built in support for it, such as Matlab (as in `lrwrap -a matlab

--nodesktop -nosplash`). These factors make it fairly ubiquitous.

+as [Bash][] (where it originated) and [REPL][]s such as [Python][]'s or

+[Octave][]'s. Using [`rlwrap`][], Readline can even be used with programs that

+don't have built-in support for it, such as [MATLAB][] (as in `rlwrap -a matlab

+-nodesktop -nosplash`). There are bindings in many languages, so if you're a

+developer you can easily use it in your own projects. These factors make it

+fairly ubiquitous.

-Readline can be configured with an `inputrc` file, usually placed at

-`~/.inputrc`.

+Readline can be configured with an [`inputrc`][] file, usually placed at

+[`~/.inputrc`][], which supports an [`$include`][] directive useful for

+including other files, e.g. from `~/.inputrc.d/`.

 Readline uses [Emacs][]-like key bindings by default. If you're a Vim fan

-though, you probably use its `vi` mode, activated by `set editing-mode vi` in

-the configuration or through some mechanism in the containing program, such as

+though, you probably use its vi mode, activated by `set editing-mode vi` in the

+configuration or through some mechanism in the containing program, such as

 Bash's `set -o vi`.

 If you *are* a Vim fan though, this has the potential of landing you in a sort

-of [uncanny valley][] since (Readline's) `vi` (mode) does not include the many

+of [uncanny valley][] since (Readline's) vi (mode) does not include the many

 improvements contained in Vim that you have come to rely on, mainly [text

-objects][].

+objects][] and the related plugins. This is especially bad if you're using

+Readline inside Vim's own [`:terminal`][]. [`readline-vim`][] aims to fix this.

+

+[Bash]: https://en.wikipedia.org/wiki/Bash_(Unix_shell)

+[REPL]: https://en.wikipedia.org/wiki/Read-eval-print_loop

+[Octave]: https://en.wikipedia.org/wiki/GNU_Octave

+[`rlwrap`]: https://manpages.debian.org/rlwrap/rlwrap.1.html

+[MATLAB]: https://en.wikipedia.org/wiki/MATLAB

+[`inputrc`]: https://www.mankier.com/3/readline#Initialization_File

+[`~/.inputrc`]: https://www.mankier.com/3/readline#Files-~/.inputrc

+[`$include`]: https://www.mankier.com/3/readline#Initialization_File-Conditional_Constructs

+[Emacs]: https://en.wikipedia.org/wiki/Emacs

+[uncanny valley]: https://en.wikipedia.org/wiki/Uncanny_valley

+[`:terminal`]: https://vimhelp.org/terminal.txt.html#:terminal

 ## Usage

@@ -46,15 +64,151 @@ git clone https://git.rcrnstn.net/rcrnstn/readline-vim

 cd readline-vim

 ```

-and append the output to your `~/.inputrc`

+and either append the output to your `~/.inputrc`

 ```sh

 ./readline-vim >> ~/.inputrc

 ```

-## Similar projects

+or use a separate file and include it (recommended)

+

+```sh

+mkdir -p ~/.inputrc.d

+./readline-vim >| ~/.inputrc.d/readline-vim.inputrc

+```

+

+```sh

+cat >> ~/.inputrc << 'EOF'

+

+## `readline-vim`

+$include ~/.inputrc.d/readline-vim.inputrc

+EOF

+```

+

+### Use vi mode by default

+

+```sh

+cat >> ~/.inputrc << 'EOF'

+

+## Use vi editing mode

+set editing-mode vi

+EOF

+```

+

+### Indicate mode with cursor shape

+

+```sh

+cat >> ~/.inputrc << 'EOF'

+

+## Indicate mode with cursor shape

+set show-mode-in-prompt On

+$if term=linux

+    # https://www.kernel.org/doc/Documentation/admin-guide/vga-softcursor.rst

+    set vi-cmd-mode-string \1\e[?8c\2

+    set vi-ins-mode-string \1\e[?0c\2

+    set emacs-mode-string  \1\e[?0c\2

+$else

+    # https://vt100.net/docs/vt510-rm/DECSCUSR

+    # http://invisible-island.net/xterm/ctlseqs/ctlseqs.html

+    set vi-cmd-mode-string \1\e[1 q\2

+    set vi-ins-mode-string \1\e[5 q\2

+    set emacs-mode-string  \1\e[5 q\2

+$endif

+EOF

+```

+

+## Features

+

+-   Motions

+    -   vi (built-in)

+        -   Word (upper and lower case versions)

+            -   `w` *word beginning, forwards*

+            -   `e` *word end, forwards*

+            -   `b` *word beginning, backwards*

+        -   Other

+            -   `h`, `l` *left, right*

+            -   `0`, `^`, `$` *line beginning, first non-whitespace character,

+                end*.

+            -   `|` *(first) column*

+            -   `;`, `,` *next, previous searched character*

+            -   `%` *matching pair character*

+    -   Vim

+        -   Word (upper and lower case versions)

+            -   `ge` *word end, backwards*

+        -   Other

+            -   `g_` *last non-whitespace character*

+            -   `)`, `(` *sentence, forwards, backwards* (only works with

+                sentences after ".")

+-   Operators

+    -   vi

+        -   `d` *delete*

+        -   `c` *change*

+        -   `y` *[yank][]*

+    -   [`vim-surround`][]

+        -   `ds` *delete surroundings*

+        -   `cs` *change surroundings*

+        -   `ys` *add surroundings ("you surround")*

+-   Text objects

+    -   Motions (vi and Vim)

+    -   Implicit line (repeat last character of operator)

+    -   Vim words (`a` *an* and `i` *inner*, upper and lower case versions)

+        -   `w` *word*

+    -   Vim pairs (`a` *an* and `i` *inner* versions)

+        -   Distinct

+            -   Matching

+                -   `(`, `)`, `b`

+                -   `{`, `}`, `B`

+                -   `[`, `]`

+            -   Other

+                -   `<`, `>`

+        -   Nondistinct

+            -   Quotes

+                -   `"`, `'`, `` ` ``

+            -   Punctuation

+                -   `#`, `$`, `%`, `&`, `@`, `\\`, `^` `_`, `|`, `~`

+                -   `.`, `,`, `:`, `;`, `!`, `?`

+                -   `+`, `-`, `*`, `/`, `=`

+

+[yank]: https://en.wiktionary.org/wiki/yank

+

+## Bugs

+

+Some macros clobber the `a`, `b` and/or `c` marks.

+

+Only forward motions work as expected with the surround operators.

+

+Most known bugs exhibit themselves at the end, and sometimes the beginning, of

+line. This is sometimes unavoidable, sometimes a trade-off to produce correct

+behavior elsewhere, mostly single-character words and/or whitespace:

+

+-   `ge`/`gE` motions: Jumps past last word on line, does not jump past first

+    word on line.

+-   word/WORD text objects: Always excludes the last character on line.

+-   Implicit line text object (as used in e.g. `yss)`): Includes whitespace at

+    the beginning and end of line.

+

+## Implementation notes

+

+This is an honest attempt to solve this problem "optimally". However, Readline

+macros are not [Turing complete][Turing completeness] (in contrast to e.g.

+VimScript) which makes this kind of hard (and more fun :smile:).

--   [`bash-surround`](https://github.com/liloman/bash-surround)

+Testing suggests that marks are not supported by all applications when combined

+with operators in macros. No workaround has been found.

+

+Counts used in macros have to come before the operator. That is, `2cl` works

+but `c2l` does not.

+

+Macros are what Vim calls recursive, i.e. they can make use of other macros in

+their expansion. To use Readline commands (such as `upcase-word`) they need to

+be bound to a key sequence (if no binding exists already) before being used in

+macros.

+

+[Turing completeness]: https://en.wikipedia.org/wiki/Turing_completeness

+

+## Related projects

+

+-   [`bash-surround`][]

     Defines the macros manually and therefore "only" provides 234 of them,

     missing some functionality.

@@ -62,7 +216,7 @@ and append the output to your `~/.inputrc`

     The instructions are Bash centric, although it uses general Readline

     macros.

--   [Athame](https://github.com/ardagnir/athame)

+-   [Athame][]

     Patches Readline to route keystrokes through an actual Vim process. Also

     provides patches for [Zsh][]. This means that whatever your local Vim

@@ -71,14 +225,35 @@ and append the output to your `~/.inputrc`

     Can be a little unreliable if your local Vim has a ton of plugins,

     especially if they interact with the terminal in non-obvious ways.

--   [`readline-vim`](https://github.com/thlorenz/readline-vim)

+-   [Zsh][]

+

+    Has built-in [text objects][Zsh text objects] and [surround][Zsh surround]

+    support. It even has a Vim-like [Visual mode][Zsh Visual mode]. The popular

+    [Oh My Zsh][] Zsh configuration framework extends this with its

+    [`vi-mode`][Oh My Zsh `vi-mode`] plugin. There are also several other

+    plugins:

+

+    -   [`softmoth/zsh-vim-mode`][]

+    -   [`jeffreytse/zsh-vi-mode`][]

+

+-   [`thlorenz/readline-vim`][]

     Exclusive to [Node.js][] [`readline`][Node.js `readline`] and only defines

-    `vi` bindings, not Vim.

+    vi bindings, not Vim bindings.

+[`bash-surround`]: https://github.com/liloman/bash-surround

+[Athame]: https://github.com/ardagnir/athame

+[Zsh]: https://en.wikipedia.org/wiki/Zsh

+[Zsh text objects]: http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html#Text-Objects

+[Zsh surround]: https://sourceforge.net/p/zsh/code/ci/master/tree/Functions/Zle/surround

+[Zsh Visual mode]: http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html#index-visual_002dmode

+[Oh My Zsh]: https://ohmyz.sh

+[Oh My Zsh `vi-mode`]: https://github.com/ohmyzsh/ohmyzsh/tree/master/plugins/vi-mode

+[`softmoth/zsh-vim-mode`]: https://github.com/softmoth/zsh-vim-mode

+[`jeffreytse/zsh-vi-mode`]: https://github.com/jeffreytse/zsh-vi-mode

+[`thlorenz/readline-vim`]: https://github.com/thlorenz/readline-vim

 [Node.js]: https://nodejs.org

 [Node.js `readline`]: https://nodejs.org/api/readline.html#readline_readline

-[Zsh]: https://en.wikipedia.org/wiki/Zsh

 ## License

@@ -1 +1,357 @@

 #!/usr/bin/env python3

+

+

+# TODO:

+# - `ACTION_OVERRIDES` (`diw` as `lbcw\\e` etc).

+# - `ciw` and `ysiw)` should be undone with a single `u`. Can this be done by

+#   deleting and `vi-put`?

+# - Counts.

+# - Remove insert mode bindings and `bind_command`?

+

+

+import sys

+import os

+import string

+import itertools

+

+

+## Bindings

+

+

+def bind_macro(keyseq, macro):

+    keyseq, macro = escape([keyseq, macro])

+    print(f'"{keyseq}": "{macro}"')

+

+

+def bind_command(keyseq, command):

+    keyseq, = escape([keyseq])

+    print(f'"{keyseq}": {command}')

+

+

+def escape(strings):

+    return [string.replace('"', '\\"') for string in strings]

+

+

+def fmt(vars, strings):

+    return [string.format(**vars) for string in strings]

+

+

+## Insert mode

+

+

+# print('set keymap vi-insert')

+

+

+# PUT = '\C-r"'

+# UNDO_BREAK = '\C-gu'  # TODO: Use.

+

+# bind_command(PUT, '\\ePa')

+

+

+## Command mode

+

+

+print('set keymap vi-command')

+

+

+# Change casing.

+for op, case in [

+    ['gu', 'downcase'],

+    ['gU', 'upcase'],

+]:

+    for mov in ['w', 'e']:

+        bind_command(f'{op}{mov}', f'{case}-word')

+    bind_macro(f'{op}iw', f'lbg{op}w')

+

+

+def movop(len, op=''):

+    if len == 0:

+        return ''

+    dir = ['h', 'l'][len > 0]

+    count = abs(len)

+    if count == 1:

+        count = ''

+    return f'{count}{op}{dir}'

+

+

+### Motions

+# motion = mot, movs = mot, [mov]

+

+

+MOTIONS_VI_WORDS = [

+    'w', 'e', 'b',

+]

+MOTIONS_VI_OTHER = [

+    'h', 'l',

+    '0', '^', '$',

+    # 'g0', 'g^', 'g$',  # TODO: Where did I get these from? Do they belong in

+    # `MOTIONS_VIM_OTHER`?

+    '|',

+    ';', ',',

+    '%',

+]

+MOTIONS_VIM_WORDS = [

+    ['ge', 'helbbhe'],

+]

+MOTIONS_VIM_OTHER = [

+    # ['_',  '^'],

+    ['g_', '$bhe'],

+    ['(',  '2F.w'],

+    [')',  'f.w'],

+]

+

+

+def motions_unpack(motions):

+    for motion in motions:

+        if isinstance(motion, str):

+            mot, mov = motion, motion

+        else:

+            mot, mov = motion

+        yield mot, [mov]

+

+

+def motions_unpack_words(motions):

+    for mot, movs in motions_unpack(motions):

+        yield mot, movs

+        mot, *movs = mots_upper([mot, *movs])

+        yield mot, movs

+

+

+def mots_upper(mots):

+    for lower, *_ in motions_unpack(MOTIONS_VI_WORDS):

+        upper = lower.upper()

+        mots = [mot.replace(lower, upper) for mot in mots]

+    return mots

+

+

+for mot, [mov] in [

+    *motions_unpack([

+        *MOTIONS_VIM_OTHER,

+    ]),

+    *motions_unpack_words([

+        *MOTIONS_VIM_WORDS,

+    ]),

+]:

+    bind_macro(mot, mov)

+

+

+### Pairs

+# pair = sides, distincts = [sidea, sideb], [sidea?, sideb?, alt?]

+

+

+PAIRS_DISTINCT_MATCH = [

+    [['(', ')'], 'b'],

+    [['{', '}'], 'B'],

+    [['[', ']']],

+]

+PAIRS_DISTINCT_OTHER = [

+    [['<', '>']],

+]

+PAIRS_NONDISTINCT_QUOTES = [

+    '"', '\'', '`',

+]

+PAIRS_NONDISTINCT_PUNCT = [

+    [punct, '\\\\'][punct == '\\']

+    for punct in [*string.punctuation, ' ']

+    if punct not in itertools.chain(

+        *[sides for sides, *_ in [

+            *PAIRS_DISTINCT_MATCH,

+            *PAIRS_DISTINCT_OTHER,

+        ]],

+        PAIRS_NONDISTINCT_QUOTES,

+    )

+]

+PAIRS_MATCH = [

+    *PAIRS_DISTINCT_MATCH,

+]

+PAIRS_NONMATCH = [

+    *PAIRS_DISTINCT_OTHER,

+    *PAIRS_NONDISTINCT_QUOTES,

+    *PAIRS_NONDISTINCT_PUNCT,

+]

+PAIRS_ALL = [

+    *PAIRS_MATCH,

+    *PAIRS_NONMATCH,

+]

+

+

+def pairs_unpack(pairs):

+    for pair in pairs:

+        if isinstance(pair, str):

+            sides, distincts = [pair, pair], [pair]

+        else:

+            sides, *alt = pair

+            distincts = [*sides, *alt]

+        yield sides, distincts

+

+

+def pairs_classify(char):

+    char_cls = ''

+    for sides, *_ in pairs_unpack(PAIRS_ALL):

+        for side, cls in zip(sides, ['(', ')']):

+            if char == side:

+                char_cls += cls

+    if len(char_cls) > 1:

+        char_cls = '*'

+    return char_cls

+

+

+## Text objects

+# textobj = viobj, pref, obj, movs = viobj, pref, obj, [mova, movb]

+

+

+def textobjs_motions(viobj, motions):

+    for obj, [movb] in motions:

+        yield viobj, '', obj, ['', movb]

+

+

+def textobj_vi_motions_words():

+    return textobjs_motions(True, motions_unpack_words(MOTIONS_VI_WORDS))

+

+

+def textobj_vi_motions_other():

+    return textobjs_motions(True, motions_unpack(MOTIONS_VI_OTHER))

+

+

+def textobj_vim_motions_words():

+    return textobjs_motions(False, motions_unpack_words(MOTIONS_VIM_WORDS))

+

+

+def textobj_vim_motions_other():

+    return textobjs_motions(False, motions_unpack(MOTIONS_VIM_OTHER))

+

+

+def textobj_implicit_line():

+    yield True, '', '', ['0', '$']

+

+

+def textobj_vim_words():

+    for pref, movs in [

+        ['a', ['lb', 'wh']],

+        ['i', ['lb', 'he']],

+    ]:

+        for obj in ['w', 'W']:

+            yield False, pref, obj, [movs, mots_upper(movs)][obj.isupper()]

+

+

+def textobj_vim_pairs():

+    for pref in ['a', 'i']:

+        for pairs, movs in [

+            [PAIRS_MATCH,    ['lF{open}', '%'       ]],

+            [PAIRS_NONMATCH, ['lF{open}', 'f{close}']],

+        ]:

+            for [open, close], objs in pairs_unpack(pairs):

+                mova, movb = fmt(vars(), movs)

+                if pref == 'i':

+                    mova, movb = f'{mova}l', f'h{movb}h'

+                for obj in objs:

+                    yield False, pref, obj, [mova, movb]

+

+

+## Operators

+# operator = viop, op, subj, acts, off

+

+

+OPERATORS_VI = [

+    ['d', None],

+    ['c', None],

+    ['y', 0 ],

+]

+

+

+def operators_vi():

+    for op, off in OPERATORS_VI:

+        def operator(textobj, op=op, off=off):

+            return textobj, True, op, '', None, off

+        yield operator

+

+

+def operators_vim_surround():

+    def operator_s(textobj, op, subj, news):

+        if op == 'y':

+            oldlen = 0

+            acta, actb = 'i', 'a'

+        else:

+            viobj, pref, obj, movs = textobj

+            cls = pairs_classify(obj)

+            if cls == '' or pref != 'a':

+                return None

+            textobj = viobj, '', obj, movs

+            oldlen = [1, 2][cls == '(']

+            fwd = movop(oldlen, op)

+            bck = movop(1-oldlen)

+            acta, actb = f'{fwd}', f'{bck}{fwd}'

+        newa, newb = news

+        newlen = len(newa)

+        if op != 'd':

+            acta, actb = f'{acta}{newa}\\e', f'{actb}{newb}\\e'

+        return textobj, False, f'{op}s', subj, [acta, actb], newlen - oldlen

+

+    # ds - delete surroundings

+    def operator_ds(textobj):

+        return operator_s(textobj, 'd', '', ['', ''])

+    yield operator_ds

+

+    for [open, close], subjs in pairs_unpack(PAIRS_ALL):

+        for subj in subjs:

+            space = ['', ' '][pairs_classify(subj) == '(']

+            news = f'{open}{space}', f'{space}{close}'

+

+            # cs - change surroundings

+            def operator_cs(textobj, subj=subj, news=news):

+                return operator_s(textobj, 'c', subj, news)

+            yield operator_cs

+

+            # ys - add surroundings ("you surround")

+            def operator_ys(textobj, subj=subj, news=news):

+                return operator_s(textobj, 'y', subj, news)

+            yield operator_ys

+

+

+## Actions

+# action = operator(textobj) = textobj, *operator

+

+

+def action(operator, textobj):

+        # TODO: Special-case word/WORD macro objects, e.g. make `ciw` to use

+        # something like `lbcw`. Use regex?

+        action = operator(textobj)

+        if not action:

+            return

+        textobj, *operator = action

+        viop, op, subj, acts, off = operator

+        viobj, pref, obj, movs = textobj

+        if viop and viobj:

+            return

+        mova, movb = movs

+        if not obj:

+            obj = op[-1]

+        if not acts:

+            # TODO: This heuristic works today but is very ugly and is not

+            # guaranteed to work tomorrow. E.g. counts. Maybe use a regex here?

+            if len(movb.replace('f', '').replace('`', '')) <= 1:

+                macro = f'{mova}{op}{movb}'

+            else:

+                macro = f'{mova}ma{movb}lmb`a{op}`b'

+        else:

+            acta, actb = acts

+            macro = f'{mova}ma{movb}{actb}`a{acta}'

+        if off is not None:

+            macro = f'mc{macro}`c{movop(off)}'

+        bind_macro(f'{op}{pref}{obj}{subj}', macro)

+

+

+for operator in [

+    *operators_vi(),

+    *operators_vim_surround(),

+]:

+    for textobj in [

+        *textobj_vi_motions_words(),

+        *textobj_vi_motions_other(),

+        *textobj_vim_motions_words(),

+        *textobj_vim_motions_other(),

+        *textobj_vim_words(),

+        *textobj_vim_pairs(),

+        *textobj_implicit_line(),

+    ]:

+        action(operator, textobj)

new file mode 100644

@@ -0,0 +1,4762 @@

+set keymap vi-command

+"guw": downcase-word

+"gue": downcase-word

+"guiw": "lbgguw"

+"gUw": upcase-word

+"gUe": upcase-word

+"gUiw": "lbggUw"

+"g_": "$bhe"

+"(": "2F.w"

+")": "f.w"

+"ge": "helbbhe"

+"gE": "hElBBhE"

+"dge": "mahelbbhelmb`ad`b"

+"dgE": "mahElBBhElmb`ad`b"

+"dg_": "ma$bhelmb`ad`b"

+"d(": "ma2F.wlmb`ad`b"

+"d)": "maf.wlmb`ad`b"

+"daw": "lbmawhlmb`ad`b"

+"daW": "lBmaWhlmb`ad`b"

+"diw": "lbmahelmb`ad`b"

+"diW": "lBmahElmb`ad`b"

+"da(": "lF(d%"

+"da)": "lF(d%"

+"dab": "lF(d%"

+"da{": "lF{d%"

+"da}": "lF{d%"

+"daB": "lF{d%"

+"da[": "lF[d%"

+"da]": "lF[d%"

+"da<": "lF<df>"

+"da>": "lF<df>"

+"da\"": "lF\"df\""

+"da'": "lF'df'"

+"da`": "lF`df`"

+"da!": "lF!df!"

+"da#": "lF#df#"

+"da$": "lF$df$"

+"da%": "lF%df%"

+"da&": "lF&df&"

+"da*": "lF*df*"

+"da+": "lF+df+"

+"da,": "lF,df,"

+"da-": "lF-df-"

+"da.": "lF.df."

+"da/": "lF/df/"

+"da:": "lF:df:"

+"da;": "lF;df;"

+"da=": "lF=df="

+"da?": "lF?df?"

+"da@": "lF@df@"

+"da\\": "lF\\maf\\lmb`ad`b"

+"da^": "lF^df^"

+"da_": "lF_df_"

+"da|": "lF|df|"

+"da~": "lF~df~"

+"da ": "lF df "

+"di(": "lF(lmah%hlmb`ad`b"

+"di)": "lF(lmah%hlmb`ad`b"

+"dib": "lF(lmah%hlmb`ad`b"

+"di{": "lF{lmah%hlmb`ad`b"

+"di}": "lF{lmah%hlmb`ad`b"

+"diB": "lF{lmah%hlmb`ad`b"

+"di[": "lF[lmah%hlmb`ad`b"

+"di]": "lF[lmah%hlmb`ad`b"

+"di<": "lF<lmahf>hlmb`ad`b"

+"di>": "lF<lmahf>hlmb`ad`b"

+"di\"": "lF\"lmahf\"hlmb`ad`b"

+"di'": "lF'lmahf'hlmb`ad`b"

+"di`": "lF`lmahf`hlmb`ad`b"

+"di!": "lF!lmahf!hlmb`ad`b"

+"di#": "lF#lmahf#hlmb`ad`b"

+"di$": "lF$lmahf$hlmb`ad`b"

+"di%": "lF%lmahf%hlmb`ad`b"

+"di&": "lF&lmahf&hlmb`ad`b"

+"di*": "lF*lmahf*hlmb`ad`b"

+"di+": "lF+lmahf+hlmb`ad`b"

+"di,": "lF,lmahf,hlmb`ad`b"

+"di-": "lF-lmahf-hlmb`ad`b"

+"di.": "lF.lmahf.hlmb`ad`b"

+"di/": "lF/lmahf/hlmb`ad`b"

+"di:": "lF:lmahf:hlmb`ad`b"

+"di;": "lF;lmahf;hlmb`ad`b"

+"di=": "lF=lmahf=hlmb`ad`b"

+"di?": "lF?lmahf?hlmb`ad`b"

+"di@": "lF@lmahf@hlmb`ad`b"

+"di\\": "lF\\lmahf\\hlmb`ad`b"

+"di^": "lF^lmahf^hlmb`ad`b"

+"di_": "lF_lmahf_hlmb`ad`b"

+"di|": "lF|lmahf|hlmb`ad`b"

+"di~": "lF~lmahf~hlmb`ad`b"

+"di ": "lF lmahf hlmb`ad`b"

+"cge": "mahelbbhelmb`ac`b"

+"cgE": "mahElBBhElmb`ac`b"

+"cg_": "ma$bhelmb`ac`b"

+"c(": "ma2F.wlmb`ac`b"

+"c)": "maf.wlmb`ac`b"

+"caw": "lbmawhlmb`ac`b"

+"caW": "lBmaWhlmb`ac`b"

+"ciw": "lbmahelmb`ac`b"

+"ciW": "lBmahElmb`ac`b"

+"ca(": "lF(c%"

+"ca)": "lF(c%"

+"cab": "lF(c%"

+"ca{": "lF{c%"

+"ca}": "lF{c%"

+"caB": "lF{c%"

+"ca[": "lF[c%"

+"ca]": "lF[c%"

+"ca<": "lF<cf>"

+"ca>": "lF<cf>"

+"ca\"": "lF\"cf\""

+"ca'": "lF'cf'"

+"ca`": "lF`cf`"

+"ca!": "lF!cf!"

+"ca#": "lF#cf#"

+"ca$": "lF$cf$"

+"ca%": "lF%cf%"

+"ca&": "lF&cf&"

+"ca*": "lF*cf*"

+"ca+": "lF+cf+"

+"ca,": "lF,cf,"

+"ca-": "lF-cf-"

+"ca.": "lF.cf."

+"ca/": "lF/cf/"

+"ca:": "lF:cf:"

+"ca;": "lF;cf;"

+"ca=": "lF=cf="

+"ca?": "lF?cf?"

+"ca@": "lF@cf@"

+"ca\\": "lF\\maf\\lmb`ac`b"

+"ca^": "lF^cf^"

+"ca_": "lF_cf_"

+"ca|": "lF|cf|"

+"ca~": "lF~cf~"

+"ca ": "lF cf "

+"ci(": "lF(lmah%hlmb`ac`b"

+"ci)": "lF(lmah%hlmb`ac`b"

+"cib": "lF(lmah%hlmb`ac`b"

+"ci{": "lF{lmah%hlmb`ac`b"

+"ci}": "lF{lmah%hlmb`ac`b"

+"ciB": "lF{lmah%hlmb`ac`b"

+"ci[": "lF[lmah%hlmb`ac`b"

+"ci]": "lF[lmah%hlmb`ac`b"

+"ci<": "lF<lmahf>hlmb`ac`b"

+"ci>": "lF<lmahf>hlmb`ac`b"

+"ci\"": "lF\"lmahf\"hlmb`ac`b"

+"ci'": "lF'lmahf'hlmb`ac`b"

+"ci`": "lF`lmahf`hlmb`ac`b"

+"ci!": "lF!lmahf!hlmb`ac`b"

+"ci#": "lF#lmahf#hlmb`ac`b"

+"ci$": "lF$lmahf$hlmb`ac`b"

+"ci%": "lF%lmahf%hlmb`ac`b"

+"ci&": "lF&lmahf&hlmb`ac`b"

+"ci*": "lF*lmahf*hlmb`ac`b"

+"ci+": "lF+lmahf+hlmb`ac`b"

+"ci,": "lF,lmahf,hlmb`ac`b"

+"ci-": "lF-lmahf-hlmb`ac`b"

+"ci.": "lF.lmahf.hlmb`ac`b"

+"ci/": "lF/lmahf/hlmb`ac`b"

+"ci:": "lF:lmahf:hlmb`ac`b"

+"ci;": "lF;lmahf;hlmb`ac`b"

+"ci=": "lF=lmahf=hlmb`ac`b"

+"ci?": "lF?lmahf?hlmb`ac`b"

+"ci@": "lF@lmahf@hlmb`ac`b"

+"ci\\": "lF\\lmahf\\hlmb`ac`b"

+"ci^": "lF^lmahf^hlmb`ac`b"

+"ci_": "lF_lmahf_hlmb`ac`b"

+"ci|": "lF|lmahf|hlmb`ac`b"

+"ci~": "lF~lmahf~hlmb`ac`b"

+"ci ": "lF lmahf hlmb`ac`b"

+"yge": "mcmahelbbhelmb`ay`b`c"

+"ygE": "mcmahElBBhElmb`ay`b`c"

+"yg_": "mcma$bhelmb`ay`b`c"

+"y(": "mcma2F.wlmb`ay`b`c"

+"y)": "mcmaf.wlmb`ay`b`c"

+"yaw": "mclbmawhlmb`ay`b`c"

+"yaW": "mclBmaWhlmb`ay`b`c"

+"yiw": "mclbmahelmb`ay`b`c"

+"yiW": "mclBmahElmb`ay`b`c"

+"ya(": "mclF(y%`c"

+"ya)": "mclF(y%`c"

+"yab": "mclF(y%`c"

+"ya{": "mclF{y%`c"

+"ya}": "mclF{y%`c"

+"yaB": "mclF{y%`c"

+"ya[": "mclF[y%`c"

+"ya]": "mclF[y%`c"

+"ya<": "mclF<yf>`c"

+"ya>": "mclF<yf>`c"

+"ya\"": "mclF\"yf\"`c"

+"ya'": "mclF'yf'`c"

+"ya`": "mclF`yf``c"

+"ya!": "mclF!yf!`c"

+"ya#": "mclF#yf#`c"

+"ya$": "mclF$yf$`c"

+"ya%": "mclF%yf%`c"

+"ya&": "mclF&yf&`c"

+"ya*": "mclF*yf*`c"

+"ya+": "mclF+yf+`c"

+"ya,": "mclF,yf,`c"

+"ya-": "mclF-yf-`c"

+"ya.": "mclF.yf.`c"

+"ya/": "mclF/yf/`c"

+"ya:": "mclF:yf:`c"

+"ya;": "mclF;yf;`c"

+"ya=": "mclF=yf=`c"

+"ya?": "mclF?yf?`c"

+"ya@": "mclF@yf@`c"

+"ya\\": "mclF\\maf\\lmb`ay`b`c"

+"ya^": "mclF^yf^`c"

+"ya_": "mclF_yf_`c"

+"ya|": "mclF|yf|`c"

+"ya~": "mclF~yf~`c"

+"ya ": "mclF yf `c"

+"yi(": "mclF(lmah%hlmb`ay`b`c"

+"yi)": "mclF(lmah%hlmb`ay`b`c"

+"yib": "mclF(lmah%hlmb`ay`b`c"

+"yi{": "mclF{lmah%hlmb`ay`b`c"

+"yi}": "mclF{lmah%hlmb`ay`b`c"

+"yiB": "mclF{lmah%hlmb`ay`b`c"

+"yi[": "mclF[lmah%hlmb`ay`b`c"

+"yi]": "mclF[lmah%hlmb`ay`b`c"

+"yi<": "mclF<lmahf>hlmb`ay`b`c"

+"yi>": "mclF<lmahf>hlmb`ay`b`c"

+"yi\"": "mclF\"lmahf\"hlmb`ay`b`c"

+"yi'": "mclF'lmahf'hlmb`ay`b`c"

+"yi`": "mclF`lmahf`hlmb`ay`b`c"

+"yi!": "mclF!lmahf!hlmb`ay`b`c"

+"yi#": "mclF#lmahf#hlmb`ay`b`c"

+"yi$": "mclF$lmahf$hlmb`ay`b`c"

+"yi%": "mclF%lmahf%hlmb`ay`b`c"

+"yi&": "mclF&lmahf&hlmb`ay`b`c"

+"yi*": "mclF*lmahf*hlmb`ay`b`c"

+"yi+": "mclF+lmahf+hlmb`ay`b`c"

+"yi,": "mclF,lmahf,hlmb`ay`b`c"

+"yi-": "mclF-lmahf-hlmb`ay`b`c"

+"yi.": "mclF.lmahf.hlmb`ay`b`c"

+"yi/": "mclF/lmahf/hlmb`ay`b`c"

+"yi:": "mclF:lmahf:hlmb`ay`b`c"

+"yi;": "mclF;lmahf;hlmb`ay`b`c"

+"yi=": "mclF=lmahf=hlmb`ay`b`c"

+"yi?": "mclF?lmahf?hlmb`ay`b`c"