This is the nkeymaps Reference Manual, version 1.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Wed Mar 15 07:06:37 2023 GMT+0.
The main system appears first, followed by any subsystem dependency.
nkeymapsGeneral-purpose keymap management à-la Emacs.
Atlas Engineer LLC
BSD 3-Clause
1.0.0
alexandria (system).
fset (system).
trivial-package-local-nicknames (system).
uiop (system).
types.lisp (file).
conditions.lisp (file).
package.lisp (file).
keymap.lisp (file).
modifiers.lisp (file).
translators.lisp (file).
keyscheme-map.lisp (file).
keyschemes.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
nkeymaps/nkeymaps.asdnkeymaps/types.lispnkeymaps/conditions.lispnkeymaps/package.lispnkeymaps/keymap.lispnkeymaps/modifiers.lispnkeymaps/translators.lispnkeymaps/keyscheme-map.lispnkeymaps/keyschemes.lispnkeymaps/types.lispnkeymaps (system).
list-of (type).
list-of-key-p (function).
list-of-keymap-p (function).
list-of-keyscheme-p (function).
list-of-p (function).
list-of-string-p (function).
nkeymaps/conditions.lisptypes.lisp (file).
nkeymaps (system).
bad-keyspec (condition).
bad-modifier (condition).
cycle (condition).
duplicate-modifiers (condition).
empty-keyspec (condition).
empty-modifiers (condition).
empty-value (condition).
make-key-required-arg (condition).
override-existing-binding (condition).
error-condition (reader method).
(setf error-condition) (writer method).
existing-binding-value (reader method).
(setf existing-binding-value) (writer method).
keymap (reader method).
(setf keymap) (writer method).
keyspec (reader method).
keyspec (reader method).
(setf keyspec) (writer method).
(setf keyspec) (writer method).
message (reader method).
message (reader method).
message (reader method).
message (reader method).
message (reader method).
(setf message) (writer method).
(setf message) (writer method).
(setf message) (writer method).
(setf message) (writer method).
(setf message) (writer method).
modifiers (reader method).
(setf modifiers) (writer method).
nkeymaps/package.lispconditions.lisp (file).
nkeymaps (system).
nkeymaps/keymap.lisppackage.lisp (file).
nkeymaps (system).
*print-shortcut* (special variable).
*translator* (special variable).
binding-keys (function).
bound-type (reader method).
(setf bound-type) (writer method).
compare (method).
compare (method).
compose (function).
copy-key (function).
define-key (compiler macro).
define-key (function).
define-modifier (function).
key (structure).
key-code (reader).
(setf key-code) (writer).
key-modifiers (reader).
(setf key-modifiers) (writer).
key-status (reader).
(setf key-status) (writer).
key-value (reader).
(setf key-value) (writer).
key= (function).
keymap (class).
keymap->map (function).
keymap-p (function).
keymap-with-parents->map (function).
keys->keyspecs (function).
lookup-key (function).
make-key (function).
make-keymap (function).
modifier= (function).
modifiers (reader method).
(setf modifiers) (writer method).
name (reader method).
(setf name) (writer method).
parents (reader method).
(setf parents) (writer method).
print-object (method).
%copy-key (function).
%make-key (function).
*default-bound-type* (special variable).
*modifier-list* (special variable).
bind-key (function).
binding-keys* (function).
copy-keymap (function).
copy-modifier (function).
entries (reader method).
(setf entries) (writer method).
key->keyspec (function).
key-p (function).
key-status-type (type).
keymap->map* (function).
keymap-tree->list (function).
keymap-with-parents (function).
keyspec->key (function).
keyspecs->keys (function).
keyspecs-type (type).
legal-modifiers-p (function).
lookup-key* (function).
lookup-keys-in-keymap (function).
make-modifier (function).
modifier (structure).
modifier-p (function).
modifier-shortcut (reader).
(setf modifier-shortcut) (writer).
modifier-string (reader).
(setf modifier-string) (writer).
modspec->modifier (function).
modspecs->modifiers (function).
string-join (function).
nkeymaps/modifiers.lispkeymap.lisp (file).
nkeymaps (system).
nkeymaps/translators.lispmodifiers.lisp (file).
nkeymaps (system).
translate-remove-but-first-control (function).
translate-remove-shift (function).
translate-remove-shift-but-first-control (function).
translate-remove-shift-but-first-control-toggle-case (function).
translate-remove-shift-toggle-case (function).
translate-shift-control-combinations (function).
toggle-case (function).
nkeymaps/keyscheme-map.lisptranslators.lisp (file).
nkeymaps (system).
bound-type (reader method).
(setf bound-type) (writer method).
define-keyscheme-map (compiler macro).
define-keyscheme-map (function).
get-keymap (function).
keyscheme (class).
keyscheme-map (type).
keyscheme-map-p (function).
keyscheme-p (function).
make-keyscheme (function).
make-keyscheme-map (function).
modifiers (reader method).
(setf modifiers) (writer method).
name (reader method).
(setf name) (writer method).
parents (reader method).
(setf parents) (writer method).
print-object (method).
copy-keyscheme-map (function).
quoted-symbol-p (function).
nkeymaps/keyschemes.lispkeyscheme-map.lisp (file).
nkeymaps (system).
Packages are listed by definition order.
nkeymaps/corenkeymaps/conditionsnkeymaps/keyschemenkeymaps/modifiernkeymaps/translatornkeymapsnkeymaps/typesnkeymaps/coreSee the ‘nkeymaps’ package documentation.
common-lisp.
nkeymaps/conditions.
nkeymaps/types.
*print-shortcut* (special variable).
*translator* (special variable).
binding-keys (function).
bound-type (generic reader).
(setf bound-type) (generic writer).
compose (function).
copy-key (function).
define-key (compiler macro).
define-key (function).
define-keyscheme-map (compiler macro).
define-keyscheme-map (function).
define-modifier (function).
get-keymap (function).
key (structure).
key-code (reader).
(setf key-code) (writer).
key-modifiers (reader).
(setf key-modifiers) (writer).
key-status (reader).
(setf key-status) (writer).
key-value (reader).
(setf key-value) (writer).
key= (function).
keymap (class).
keymap->map (function).
keymap-p (function).
keymap-with-parents->map (function).
keys->keyspecs (function).
keyscheme (class).
keyscheme-map (type).
keyscheme-map-p (function).
keyscheme-p (function).
lookup-key (function).
make-key (function).
make-keymap (function).
make-keyscheme (function).
make-keyscheme-map (function).
modifier= (function).
modifiers (generic reader).
(setf modifiers) (generic writer).
name (generic reader).
(setf name) (generic writer).
parents (generic reader).
(setf parents) (generic writer).
%copy-key (function).
%make-key (function).
*default-bound-type* (special variable).
*modifier-list* (special variable).
bind-key (function).
binding-keys* (function).
copy-keymap (function).
copy-keyscheme-map (function).
copy-modifier (function).
entries (generic reader).
(setf entries) (generic writer).
key->keyspec (function).
key-p (function).
key-status-type (type).
keymap->map* (function).
keymap-tree->list (function).
keymap-with-parents (function).
keyspec->key (function).
keyspecs->keys (function).
keyspecs-type (type).
legal-modifiers-p (function).
lookup-key* (function).
lookup-keys-in-keymap (function).
make-modifier (function).
modifier (structure).
modifier-p (function).
modifier-shortcut (reader).
(setf modifier-shortcut) (writer).
modifier-string (reader).
(setf modifier-string) (writer).
modspec->modifier (function).
modspecs->modifiers (function).
quoted-symbol-p (function).
string-join (function).
nkeymaps/conditionsPackage listing conditions.
common-lisp.
bad-keyspec (condition).
bad-modifier (condition).
cycle (condition).
duplicate-modifiers (condition).
empty-keyspec (condition).
empty-modifiers (condition).
empty-value (condition).
make-key-required-arg (condition).
override-existing-binding (condition).
error-condition (generic reader).
(setf error-condition) (generic writer).
existing-binding-value (generic reader).
(setf existing-binding-value) (generic writer).
keymap (generic reader).
(setf keymap) (generic writer).
keyspec (generic reader).
(setf keyspec) (generic writer).
message (generic reader).
(setf message) (generic writer).
modifiers (generic reader).
(setf modifiers) (generic writer).
nkeymaps/keyschemePackage holding the list of well-known keyschemes.
We use a dedicated package so that keyschemes can easily be listed and completed.
common-lisp.
nkeymaps/modifierPackage holding the list of predefined modifiers.
We use a dedicated package so that modifiers can easily be listed and completed.
See ‘nkeymaps:define-modifier’.
common-lisp.
nkeymaps/translatorPackage holding the list of predefined translators.
We use a dedicated package so that modifiers can easily be listed and completed.
See ‘nkeymaps:*translator*’.
common-lisp.
nkeymaps/core.
nkeymaps/modifier.
translate-remove-but-first-control (function).
translate-remove-shift (function).
translate-remove-shift-but-first-control (function).
translate-remove-shift-but-first-control-toggle-case (function).
translate-remove-shift-toggle-case (function).
translate-shift-control-combinations (function).
toggle-case (function).
nkeymapsThe workflow goes as follows:
- Make a keymap with ‘nkeymaps:make-keymap’.
- Define a binding on it with ‘nkeymaps:define-key’.
- Lookup this binding with ‘nkeymaps:lookup-key’.
Example:
(let* ((parent-keymap (nkeymaps:make-keymap "parent-keymap"))
(my-keymap (nkeymaps:make-keymap "my-keymap" parent-keymap)))
(nkeymaps:define-key parent-keymap
"C-c" ’copy
"C-v" ’paste)
(nkeymaps:define-key my-keymap
"C-x" ’cut)
(values
(nkeymaps:lookup-key "C-x" parent-keymap)
(nkeymaps:lookup-key "C-x" my-keymap)
(nkeymaps:lookup-key "C-c" my-keymap)))
;; => NIL, CUT, COPY
Another workflow is to use ‘nkeymaps:keyscheme’s which allow to compose
different binding styles.
Example:
(nkeymaps:define-keyscheme-map "test" ()
nkeymaps:cua ’("C-c" copy
"C-v" paste)
nkeymaps:emacs ’("C-x" cut))
The default keyschemes can be listed from the ‘nkeymaps/keyscheme:’ package
exported symbols.
New keyschemes can be created with ‘nkeymaps:make-keyscheme’.
Keys can be created with ‘nkeymaps:make-key’, which gives you more fine-tuning
compared to the "keyspecs" above:
(nkeymaps:make-key :code 38 :value "a" :modifiers ’("C"))
You can also specify key codes from the keyspec directly. For instance,
"C-#10" corresponds to keycode 10 with the ‘nkeymaps:+control+’.
The reverse-action of ‘nkeymaps:lookup-key’ is ‘nkeymaps:binding-keys’.
Keymaps can be composed with ‘nkeymaps:compose’.
New modifiers can be defined with ‘nkeymaps:define-modifier’.
(nkeymaps:define-modifier :string "duper" :shortcut "D")
Some globals can be tweaked to customize the library to your needs:
- ‘nkeymaps:*translator*’: The function to infer the right binding when
the exact binding hits nothing.
- ‘nkeymaps:*print-shortcut*’: Print modifiers using their short form instead of the
full name, e.g. "C" instead of "control".
nkeymaps/typesPackage for types.
It’s useful to have a separate package because some types may need to generate
functions for the ‘satisfies’ type condition.
common-lisp.
list-of (type).
list-of-key-p (function).
list-of-keymap-p (function).
list-of-keyscheme-p (function).
list-of-p (function).
list-of-string-p (function).
Definitions are sorted by export status, category, package, and then by lexicographic order.
Whether to print the short form of the modifiers.
Key translator to use in ‘keymap’ objects.
When no binding is found, call this function to
generate new bindings to lookup. The function takes a list of ‘key’ objects and
returns a list of list of keys.
Ths parameter can be let-bound around ‘lookup-key’ calls.
We need a compiler macro to check that bindings are valid at compile time.
This is because most Common Lisp implementations are not capable of checking
types that use ‘satisfies’ for non-top-level symbols.
We can verify this with:
(compile nil (lambda () (nkeymaps::define-key keymap "C-x C-f" ’open-file)))
See the ‘define-key’ compiler-macro for why we need one here too.
Return the list of ‘keyspec’s bound to BINDING in KEYMAP-OR-KEYMAPS.
The order of the result is dictated by the order of KEYMAP-OR-KEYMAPS.
As a second value, return an alist of (keyspec keymap) for all the
‘keyspec’s bound to BINDING in KEYMAP.
Comparison against BINDING is done with TEST.
Duplicates and shadowed bindings are removed.
For instance, to list all keymaps that have a binding, call:
(mapcar #’second (nth-value 1 (binding-keys ...)))
Return a new keymap that’s the composition of all given KEYMAPS.
KEYMAPS are composed by order of precedence, first keymap being the one with
highest precedence.
Bind KEYS to BOUND-VALUE in KEYMAP.
Return KEYMAP.
KEYSPECS is either a ‘keyspecs-type’, or a list of arguments passed to invocations
of ‘make-key’s, or (:REMAP OTHER-VALUE &OPTIONAL OTHER-KEYMAP).
BOUND-VALUE can be anything. If NIL, the binding is removed.
With (:REMAP OTHER-VALUE &OPTIONAL OTHER-KEYMAP), define-key maps the binding of
OTHER-VALUE in OTHER-KEYMAP (default to KEYMAP) to BOUND-VALUE.
In other words, it remaps OTHER-VALUE to VALUE.
Examples:
(define-key foo-map "C-x C-f" ’open-file)
(define-key foo-map
"C-x C-f" ’open-file
"C-h k" ’describe-key)
"C-M-1 x" on a QWERTY:
(define-key foo-map ’((:code 10 :modifiers ("C" "M") (:value "x"))) ’open-file)
or the shorter:
(define-key foo-map "C-M-#1" ’open-file)
Remapping keys:
(define-key foo-map ’(:remap foo-a) ’foo-value)
(define-key foo-map ‘(:remap foo-a ,bar-map) ’new-value)
Return a keyscheme-map, a hash table with ‘keyscheme’s as key and ‘keymap’s
holding BINDINGS as value.
The keymap names are prefixed with NAME-PREFIX and suffixed with "-map".
OPTIONS is list of keyword arguments.
For now the only supported option is IMPORT.
When given a ‘keyscheme-map’ to IMPORT, it is used as initial values for the new
keyscheme-map. The content is copied. Further alteration to the imported
keyscheme-map won’t reflect on this newly define keyscheme-map.
This is a macro like ‘define-key’ so that it can type-check the BINDINGS
keyspecs at compile-time.
Example:
(define-keyscheme-map "my-mode" ’()
nkeymaps/keyscheme:cua (list
"C-c" ’copy
"C-v" ’paste)
nkeymaps/keyscheme:emacs ’("M-w" copy
"M-y" paste))
‘nkeymaps/keyscheme:cua’ and ‘nkeymaps/keyscheme:emacs’ are pre-defined keyschemes.
To define a new keyscheme, see ‘make-keyscheme’.
‘nkeymaps/keyscheme:cua’ is a parent of ‘nkeymaps/keyscheme:emacs’; thus, in the
above example, the Emacs keymap will have the CUA keymap as parent.
The keyscheme-map keymaps are named "my-mode-cua-map" and
"my-mode-emacs-map".
Return a new modifier.
It is registered globally and can be used from any new keymap, unless the keymap
filters out the modifier in its ‘modifiers’ slot.
Return keymap corresponding to KEYSCHEME in KEYSCHEME-MAP.
If no keymap is found, try with KEYSCHEME’s ‘parents’.
For instance, if KEYSCHEME has a ‘nkeymaps/keyscheme:cua’ keymap and no
‘nkeymaps/keyscheme:emacs’ keymap, this function returns the
‘nkeymaps/keyscheme:cua’ keymap when NAME is ‘nkeymaps/keyscheme:emacs’.
Return nil if nothing is found.
Two keys are equal if the have the same modifiers, status and key code.
If codes don’t match, the values are compared instead. This way, code-matching
keys match before the value which is usually what the users want when they
specify a key-code binding.
Return a hash-table of (KEYSPEC BOUND-VALUE) from KEYMAP.
Parent bindings are not listed; see ‘keymap-with-parents->map’ instead.
This is convenient if the caller wants to list all the bindings.
When multiple keymaps are provided, return the union of the ‘fset:map’ of each arguments.
Keymaps are ordered by precedence, highest precedence comes first.
List bindings in KEYMAP and all its parents. See ‘keymap->map’.
Return the keyspecs (a list of ‘keyspec’) for KEYS. See ‘key->keyspec’ for the details.
Return the value bound to KEYS-OR-KEYSPECS in KEYMAP-OR-KEYMAPS.
As a second value, return the matching keymap.
As a third value, return the possibly translated KEYS.
Return NIL if no value is found.
The successive keymaps from KEYMAP-OR-KEYMAPS (if a list) are looked up one
after the other.
If no binding is found, the direct parents are looked up in the same order.
And so on if the binding is still not found.
Return new ‘key’.
Modifiers can be either a ‘modifier’ type or a string that will be looked up in
‘*modifier-list*’.
Return a new ‘keyscheme’ object.
The scheme name inherits from the optional PARENTS, ordered by priority.
Example:
(defvar emacs (make-keyscheme "emacs" cua))
In the above, we define a new scheme name called ‘emacs‘ which inherits from the existing keyscheme ‘cua‘.
Return a new scheme associating KEYSCHEME to KEYMAP.
With MORE-KEYSCHEME+KEYMAP-PAIRS, include those names and keymaps as well. This is
useful in complement to ‘define-keyscheme-map’ to make a scheme with pre-existing
keymaps.
With control, keys without control except for the first key: ’C-x C-c’ -> ’C-x c’.
With shift, keys without shift: ’shift-a’ -> ’a’.
With control and shift, keys without control except for the first key and without shift everywhere: ’C-shift-C C-shift-f’ -> ’C-C f.
With control and shift, keys without control except for the first key and without shift everywhere: ’C-shift-C C-shift-f’ -> ’C-c F.
With shift, keys without shift and with their key value case reversed: ’shift-a shift-B’ -> ’A b’.
Return the successive translations of
- ‘translate-remove-shift’,
- ‘translate-remove-shift-toggle-case’,
- ‘translate-remove-but-first-control’,
- ‘translate-remove-shift-but-first-control’,
- ‘translate-remove-shift-but-first-control-toggle-case’.
We first remove shift before toggle the case because we want ’s-A’ to match an ’A’ binding before matching ’a’.
keyscheme)) ¶keyscheme)) ¶Type of the bound-value.
The type is enforced in ‘define-keyscheme-map’ at macro-expansion time.
Type should allow ‘keymap’s, so it should probably be in the form
(or keymap NON-KEYMAP-BOUND-TYPE).
keymap)) ¶keymap)) ¶Type of the bound-value.
The type is enforced in ‘define-key’ at macro-expansion time.
Type should allow ‘keymap’s, so it should probably be in the form
(or keymap NON-KEYMAP-BOUND-TYPE).
key) (y key)) ¶Needed to use the KEY structure as keys in Fset maps.
Would we use the default comparison function, case-sensitivity would be lost on
key values because ‘fset:equal?‘ folds case.
fset.
modifier) (y modifier)) ¶Modifier sets need this comparison function to be ordered, so that ("C" "M") is the same as ("M" "C").
fset.
Warning raised when trying to derive a key from an illegal keyspec.
warning.
(quote "illegal keyspec")
:message
(quote (alexandria:required-argument (quote nkeymaps/conditions::error-condition)))
:error-condition
Condition raised when we didn’t get a modifier as expected.
error.
(quote "")
:message
Warning raised when keymap has cycles.
This is possible if a bound value is a keymap that occured before.
Warning raised when a keyspec contains multiple occurences of the same modifiers.
warning.
(quote "duplicate modifiers")
:message
(quote (alexandria:required-argument (quote nkeymaps/conditions::modifiers)))
:modifiers
error.
error.
(quote (alexandria:required-argument (quote nkeymaps/conditions::keyspec)))
:keyspec
error.
(quote (alexandria:required-argument (quote nkeymaps/conditions::keyspec)))
:keyspec
error.
Warning raised overriding an existing binding.
warning.
(quote "key was bound to")
:message
(quote (alexandria:required-argument (quote nkeymaps/conditions::existing-binding-value)))
:existing-binding-value
structure-object.
integer
0
string
""
fset:wb-set
(fset:set)
nkeymaps/core::key-status-type
:pressed
Name of the keymap.
Used for documentation purposes, e.g. referring to a keymap by a well known name.
string
"anonymous"
:name
name.
Hash table of which the keys are key-chords and the values are a symbol or a keymap.
fset:wb-map
(fset:empty-map)
:entries
Type of the bound-value.
The type is enforced in ‘define-key’ at macro-expansion time.
Type should allow ‘keymap’s, so it should probably be in the form
(or keymap NON-KEYMAP-BOUND-TYPE).
nkeymaps/core::*default-bound-type*
:bound-type
List of parent keymaps.
Parents are ordered by priority, the first parent has highest priority.
(nkeymaps/types:list-of nkeymaps/core:keymap)
:parents
Accepted modifiers for this ‘keymap’.
fset:wb-set
(fset:convert (quote fset:set) nkeymaps/core::*modifier-list*)
:modifiers
The list of parents. When a scheme is defined, the
keymap parents are automatically set to the keymaps corresponding to the given
keyschemes. See ‘define-keyscheme-map’.
(nkeymaps/types:list-of nkeymaps/core:keyscheme)
(quote nil)
:parents
Type of the bound-value.
The type is enforced in ‘define-keyscheme-map’ at macro-expansion time.
Type should allow ‘keymap’s, so it should probably be in the form
(or keymap NON-KEYMAP-BOUND-TYPE).
nkeymaps/core::*default-bound-type*
:bound-type
Accepted modifiers for this ‘keyscheme’.
fset:wb-set
(fset:convert (quote fset:set) nkeymaps/core::*modifier-list*)
:modifiers
Default value for the ‘bound-type’ slot of ‘keymap’.
Do not change this, instead create new ‘scheme-name’s or subclass ‘keymap’.
List of known modifiers.
‘make-key’ and ‘define-key’ raise an error when setting a modifier that is not
in this list.
Recursively bind the KEYS to keymaps starting from KEYMAP.
The last key is bound to BOUND-VALUE.
If BOUND-VALUE is nil, the key is unbound.
If KEYS has modifiers that are not allowed in KEYMAP, do nothing.
Return KEYMAP.
Return a the list of ‘keyspec’s bound to BINDING in KEYMAP. The list is sorted alphabetically to ensure reproducible results. Comparison against BINDING is done with TEST.
Return the keyspec of KEY.
If the key has a code, return it prefixed with ’#’.
For now the status is not encoded in the keyspec, this may change in the future.
Return a map of (KEYSPEC SYM) from KEYMAP.
Flatten the KEYMAPS into a list.
It traverses KEYMAPS first, then traverses the each keymap ‘parent’ layer after layer.
Example:
- keymap1 has parents (k1a k1b)
- k1a has parents (k1ap)
- keymap2 has parents (k2a)
Return (keymap1 keymap2 k1a k1b k2a k1ap).
Return the list of keymap and all its parents.
Parse STRING and return a new ‘key’.
The specifier is expected to be in the form
MOFIFIERS-CODE/VALUE
MODIFIERS are hyphen-separated modifiers as per ‘*modifier-list*’.
CODE/VALUE is either a code that starts with ’#’ or a key symbol.
Note that ’-’ or ’#’ as a last character is supported, e.g. ’control–’ and ’control-#’ are valid.
Parse SPEC and return corresponding list of keys.
Whether KEY’s modifiers are allowed in KEYMAP.
Return non-nil if LIST contains only elements of the given TYPE.
Internal function, see ‘lookup-key’ for the user-facing function.
VISITED is used to detect cycles.
As a second value, return the matching keymap.
Return bound value or keymap for KEYS. Return nil when KEYS is not found in KEYMAP. VISITED is used to detect cycles.
Return the ‘modifier’ corresponding to STRING-OR-MODIFIER.
Return the list of ‘modifier’s corresponding to STRINGS-OR-MODIFIERS.
Adapted from ‘serapeum:string-join’.
Return the input with reversed case if it has only one character.
bad-keyspec)) ¶bad-keyspec)) ¶override-existing-binding)) ¶override-existing-binding)) ¶empty-modifiers)) ¶empty-modifiers)) ¶empty-value)) ¶empty-value)) ¶bad-keyspec)) ¶bad-keyspec)) ¶bad-modifier)) ¶bad-modifier)) ¶override-existing-binding)) ¶override-existing-binding)) ¶duplicate-modifiers)) ¶duplicate-modifiers)) ¶duplicate-modifiers)) ¶duplicate-modifiers)) ¶| Jump to: | %
(
B C D E F G K L M N P Q S T |
|---|
| Jump to: | %
(
B C D E F G K L M N P Q S T |
|---|
| Jump to: | *
+
B C D E K M N P S V |
|---|
| Jump to: | *
+
B C D E K M N P S V |
|---|
| Jump to: | B C D E F K L M N O P S T |
|---|
| Jump to: | B C D E F K L M N O P S T |
|---|