# Copyright (C) 2016, 2018, 2021  Stefan Vargyas
# 
# This file is part of Trie-Gen.
# 
# Trie-Gen is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# 
# Trie-Gen is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with Trie-Gen.  If not, see <http://www.gnu.org/licenses/>.

#
# trie test suite
#
$ . ~/regtest2.sh
$ alias regtest='regtest2-selftest -f test.txt -B'

# list all available tests:
$ regtest -N
...

# run all tests:
$ regtest -A

#
# BASH BUG:
#

$ hex() { hexdump -ve '1/1 "%02x" "\n"'; }
$ echo $'\x01'|hex
01
0a
# the '01' below should have not been duplicated:
$ cat <(echo $'\x01')|hex
01
01
0a
# the same output is obtained when 'print' replaces 'echo':
$ print() { printf '%s\n' "$@"; }
$ print $'\x1'|hex
01
0a
$ cat <(print $'\x1')|hex
01
01
0a
$

--[ prereq ]--------------------------------------------------------------------

$ print() { printf '%s\n' "$@"; }
$

--[ help ]----------------------------------------------------------------------

$ ../src/trie -?
usage: trie [OPTION]...
where the options are:
  -t|--node-type=NODE      use the specified node type; any of: i[nt], f[loat] or
                             s[tr[ing]]; the default is string
  -T|--trie-type=TRIE      use the specified trie type: any of array or ternary;
                             the default is ternary
  -o|--output-type=OUT     generate output of the specified type: o[bj[ect]],
                             c[-code], t[rie] or e[xpr]; the default is object
  -g|--gen-type=GEN        when printing output of type c-code, trie or expr, generate
                             it according to the specification: c[omp[act]] or w[ide];
                             the default is wide
  -P|--path-type=PATH      when printing output of type compact c-code, produce the trie
                             path matching code of specified type: either e[xpanded] or
                             f[unction]; the default is expanded
  -p|--prefix-func=NAME    when printing output of type compact c-code with path code of
                             type function, use the given name for the prefix function;
                             the default name is prefix
  -q|--equal-func=NAME     when printing output of type compact c-code with path code of
                             type function, use the given name for the equal function;
                             the default name is equal
  -u|--[no-]unique-prefix  when printing output of type compact c-code, generate it such
                             that to accept unique -- i.e. non-ambiguous -- prefixes of
                             input keywords; `--no-unique-prefix' specifies the code
                             to accept only complete keywords (default)
  -z|--[no-]zero-start     when trie node type is numeric, start keyword indexing at 0,
                             or otherwise at 1 (default at 1)
  -c|--escape-chars=STR    when printing output of type expr, escape the specified chars
  -e|--expr-type=EXPR      when printing output of type expr, generate the expression of
                             given type: any of c[xxpy], p[erl] or b[ash]; the default
                             is cxxpy
  -D|--[expr-]depth=NUM    use the specified maximum depth for the generated expression
                             when printing output of type expr
  -a|--[no-][print-]attrs  put annotation attributes in structure print outs
                             or otherwise do not (default not)
  -s|--[no-][print-]stats  print out some statistics information
                             or otherwise do not (default not)
  -d|--[no-][print-]dots   put indenting dots in structure print outs
                             or otherwise do not (default not)
     --debug[=LEVEL]       do print some debugging output; LEVEL is [0-9], default 1;
     --no-debug            do not print debugging output at all (default)
     --dump-opt[ion]s      print options and exit
  -V|--[no-]verbose        be verbose (cumulative) or not (default not)
  -v|--version             print version numbers and exit
     --help                display this help info and exit
$

--[ opts ]----------------------------------------------------------------------

$ trie() { ../src/trie --dump-opts "$@"; }
$ trie
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --node-type int --node-type string
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --node-type int --node-type str
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --node-type int
node-type:     int
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --node-type float
node-type:     float
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --node-type foo
trie: error: invalid argument for 'node-type' option: 'foo'
command failed: trie --node-type foo
$ trie --trie-type array --trie-type ternary
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --trie-type array
node-type:     string
trie-type:     array
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --trie-type foo
trie: error: invalid argument for 'trie-type' option: 'foo'
command failed: trie --trie-type foo
$ trie --output-type c-code --output-type object
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --output-type c-code --output-type obj
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --output-type c-code --output-type o
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --output-type c-code
node-type:     string
trie-type:     ternary
output-type:   c-code
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --output-type c
node-type:     string
trie-type:     ternary
output-type:   c-code
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --output-type foo
trie: error: invalid argument for 'output-type' option: 'foo'
command failed: trie --output-type foo
$ trie --gen-type wide --gen-type compact
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      compact
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --gen-type wide --gen-type comp
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      compact
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --gen-type wide --gen-type c
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      compact
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --gen-type wide
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --gen-type w
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --gen-type foo
trie: error: invalid argument for 'gen-type' option: 'foo'
command failed: trie --gen-type foo
$ trie --debug
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         1
verbose:       0
argc:          0
$ trie --debug=0
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --debug=1
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         1
verbose:       0
argc:          0
$ trie --debug=2
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         2
verbose:       0
argc:          0
$ trie --debug=3
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         3
verbose:       0
argc:          0
$ trie --debug=4
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         4
verbose:       0
argc:          0
$ trie --debug=5
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         5
verbose:       0
argc:          0
$ trie --debug=6
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         6
verbose:       0
argc:          0
$ trie --debug=7
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         7
verbose:       0
argc:          0
$ trie --debug=8
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         8
verbose:       0
argc:          0
$ trie --debug=9
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         9
verbose:       0
argc:          0
$ trie --debug=10
trie: error: invalid argument for 'debug' option: '10'
command failed: trie --debug=10
$ trie --debug=100
trie: error: invalid argument for 'debug' option: '100'
command failed: trie --debug=100
$ trie --debug --no-debug
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --no-debug=
trie: error: option '--no-debug' does not allow an argument
command failed: trie --no-debug=
$ trie --no-verbose
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie --verbose
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       1
argc:          0
$ trie --verbose --verbose
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       2
argc:          0
$ trie --verbose --verbose --verbose
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       3
argc:          0
$ trie --verbose --verbose --verbose --verbose
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       3
argc:          0
$ trie --verbose --verbose --verbose --verbose --no-verbose
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       0
argc:          0
$ trie -V
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       1
argc:          0
$ trie -VV
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       2
argc:          0
$ trie -VVV
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       3
argc:          0
$ trie -VVVV
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       3
argc:          0
$ trie -VVVVV
node-type:     string
trie-type:     ternary
output-type:   object
gen-type:      wide
path-type:     expanded
equal-func:    equal
prefix-func:   prefix
unique-prefix: no
zero-start:    no
escape-chars:  -
expr-type:     cxxpy
expr-depth:    0
print-attrs:   no
print-stats:   no
print-dots:    no
debug:         0
verbose:       3
argc:          0
$

--[ base ]----------------------------------------------------------------------

$ trie() { ../src/trie --trie=array --dots "$@"; }
$ print test-str test-string test-int test-float|trie --node=int
{
.   't' {
.   .   'e' {
.   .   .   's' {
.   .   .   .   't' {
.   .   .   .   .   '-' {
.   .   .   .   .   .   'f' {
.   .   .   .   .   .   .   'l' {
.   .   .   .   .   .   .   .   'o' {
.   .   .   .   .   .   .   .   .   'a' {
.   .   .   .   .   .   .   .   .   .   't': 4
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   'i' {
.   .   .   .   .   .   .   'n' {
.   .   .   .   .   .   .   .   't': 3
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   's' {
.   .   .   .   .   .   .   't' {
.   .   .   .   .   .   .   .   'r': 1 {
.   .   .   .   .   .   .   .   .   'i' {
.   .   .   .   .   .   .   .   .   .   'n' {
.   .   .   .   .   .   .   .   .   .   .   'g': 2
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print test-str test-string test-int test-float|trie --node=float
{
.   't' {
.   .   'e' {
.   .   .   's' {
.   .   .   .   't' {
.   .   .   .   .   '-' {
.   .   .   .   .   .   'f' {
.   .   .   .   .   .   .   'l' {
.   .   .   .   .   .   .   .   'o' {
.   .   .   .   .   .   .   .   .   'a' {
.   .   .   .   .   .   .   .   .   .   't': 4.0
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   'i' {
.   .   .   .   .   .   .   'n' {
.   .   .   .   .   .   .   .   't': 3.0
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   's' {
.   .   .   .   .   .   .   't' {
.   .   .   .   .   .   .   .   'r': 1.0 {
.   .   .   .   .   .   .   .   .   'i' {
.   .   .   .   .   .   .   .   .   .   'n' {
.   .   .   .   .   .   .   .   .   .   .   'g': 2.0
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print test-str test-string test-int test-float|trie --node=str
{
.   't' {
.   .   'e' {
.   .   .   's' {
.   .   .   .   't' {
.   .   .   .   .   '-' {
.   .   .   .   .   .   'f' {
.   .   .   .   .   .   .   'l' {
.   .   .   .   .   .   .   .   'o' {
.   .   .   .   .   .   .   .   .   'a' {
.   .   .   .   .   .   .   .   .   .   't': "test-float"
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   'i' {
.   .   .   .   .   .   .   'n' {
.   .   .   .   .   .   .   .   't': "test-int"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   's' {
.   .   .   .   .   .   .   't' {
.   .   .   .   .   .   .   .   'r': "test-str" {
.   .   .   .   .   .   .   .   .   'i' {
.   .   .   .   .   .   .   .   .   .   'n' {
.   .   .   .   .   .   .   .   .   .   .   'g': "test-string"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ trie() { ../src/trie --trie=ternary --dots "$@"; }
$ print test-str test-string test-int test-float|trie --node=int
{
.   .ch: 't'
.   .eq {
.   .   .ch: 'e'
.   .   .eq {
.   .   .   .ch: 's'
.   .   .   .eq {
.   .   .   .   .ch: 't'
.   .   .   .   .eq {
.   .   .   .   .   .ch: '-'
.   .   .   .   .   .eq {
.   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .lo {
.   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .lo {
.   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: 4
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .val: 3
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .val: 1
.   .   .   .   .   .   .   .   .   .hi {
.   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: 2
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print test-str test-string test-int test-float|trie --node=float
{
.   .ch: 't'
.   .eq {
.   .   .ch: 'e'
.   .   .eq {
.   .   .   .ch: 's'
.   .   .   .eq {
.   .   .   .   .ch: 't'
.   .   .   .   .eq {
.   .   .   .   .   .ch: '-'
.   .   .   .   .   .eq {
.   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .lo {
.   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .lo {
.   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: 4.0
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .val: 3.0
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .val: 1.0
.   .   .   .   .   .   .   .   .   .hi {
.   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: 2.0
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print test-str test-string test-int test-float|trie --node=str
{
.   .ch: 't'
.   .eq {
.   .   .ch: 'e'
.   .   .eq {
.   .   .   .ch: 's'
.   .   .   .eq {
.   .   .   .   .ch: 't'
.   .   .   .   .eq {
.   .   .   .   .   .ch: '-'
.   .   .   .   .   .eq {
.   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .lo {
.   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .lo {
.   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: "test-float"
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .val: "test-int"
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .val: "test-str"
.   .   .   .   .   .   .   .   .   .hi {
.   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .eq {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: "test-string"
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$

--[ dup ]-----------------------------------------------------------------------

$ trie() { set -o pipefail && ../src/trie --node=int --stats -VV "$@" 2>&1|sed -r 's|^#|\\\0|'; }
$ print a a|trie --trie=array
\# adding "a":
\# node size:  2072
\# node count: 1
\# nodes size: 2072
\# adding "a":
\# node size:  2072
\# node count: 2
\# nodes size: 4144
{
    'a': 1
}
\# final trie:
\# node size:  2072
\# node count: 2
\# nodes size: 4144
{
    'a': 2
}
$ print a a|trie --trie=ternary
\# adding "a":
\# node size:  48
\# node count: 0
\# nodes size: 0
\# adding "a":
\# node size:  48
\# node count: 2
\# nodes size: 96
{
    .ch: 'a'
    .eq {
        .val: 1
    }
}
\# final trie:
\# node size:  48
\# node count: 2
\# nodes size: 96
{
    .ch: 'a'
    .eq {
        .val: 2
    }
}
$

--[ print-obj-base0-array ]-----------------------------------------------------

$ trie() { ../src/trie --node=str --trie=array "$@"; }
$ print a|trie
{
    'a': "a"
}
$ print a ab|trie
{
    'a': "a" {
        'b': "ab"
    }
}
$ print a ab abc|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc"
        }
    }
}
$ print a b|trie
{
    'a': "a"
    'b': "b"
}
$ print a b abc bac abd|trie
{
    'a': "a" {
        'b' {
            'c': "abc"
            'd': "abd"
        }
    }
    'b': "b" {
        'a' {
            'c': "bac"
        }
    }
}
$ print a bb ba c|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c': "c"
}
$ print a bb ba cc|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c': "cc"
    }
}
$ print a bb ba ccc|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print a bb ba cde|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e': "cde"
        }
    }
}
$ print a bb ba cdef|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e' {
                'f': "cdef"
            }
        }
    }
}
$ print a bb ba cdef cdefg|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e' {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print a bb bac cdef|trie
{
    'a': "a"
    'b' {
        'a' {
            'c': "bac"
        }
        'b': "bb"
    }
    'c' {
        'd' {
            'e' {
                'f': "cdef"
            }
        }
    }
}
$ print a bbx ba ccc|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b' {
            'x': "bbx"
        }
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print a bbx bay ccc|trie
{
    'a': "a"
    'b' {
        'a' {
            'y': "bay"
        }
        'b' {
            'x': "bbx"
        }
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print a cde cdef|trie
{
    'a': "a"
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef"
            }
        }
    }
}
$ print a cde cdef cdefg|trie
{
    'a': "a"
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print a cde cdef cdefgh|trie
{
    'a': "a"
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef" {
                    'g' {
                        'h': "cdefgh"
                    }
                }
            }
        }
    }
}
$ print a cdef cdefg|trie
{
    'a': "a"
    'c' {
        'd' {
            'e' {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print ab|trie
{
    'a' {
        'b': "ab"
    }
}
$ print ab bb ba ccc|trie
{
    'a' {
        'b': "ab"
    }
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print ab bb ba cde|trie
{
    'a' {
        'b': "ab"
    }
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e': "cde"
        }
    }
}
$ print ab bbx ba ccc|trie
{
    'a' {
        'b': "ab"
    }
    'b' {
        'a': "ba"
        'b' {
            'x': "bbx"
        }
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print ab c|trie
{
    'a' {
        'b': "ab"
    }
    'c': "c"
}
$ print abc bb ba ccc|trie
{
    'a' {
        'b' {
            'c': "abc"
        }
    }
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print abcd abde abef|trie
{
    'a' {
        'b' {
            'c' {
                'd': "abcd"
            }
            'd' {
                'e': "abde"
            }
            'e' {
                'f': "abef"
            }
        }
    }
}
$ print abg a abc ab abd|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc"
            'd': "abd"
            'g': "abg"
        }
    }
}
$ print ac ab|trie
{
    'a' {
        'b': "ab"
        'c': "ac"
    }
}
$ print aef ae abg a abc ab abd|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc"
            'd': "abd"
            'g': "abg"
        }
        'e': "ae" {
            'f': "aef"
        }
    }
}
$ print cde cdef cdefgh|trie
{
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef" {
                    'g' {
                        'h': "cdefgh"
                    }
                }
            }
        }
    }
}
$ print cdef cdefg|trie
{
    'c' {
        'd' {
            'e' {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print cdex cdfy cdgz cdhw|trie
{
    'c' {
        'd' {
            'e' {
                'x': "cdex"
            }
            'f' {
                'y': "cdfy"
            }
            'g' {
                'z': "cdgz"
            }
            'h' {
                'w': "cdhw"
            }
        }
    }
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    'c' {
        'd' {
            'e' {
                'x': "cdex"
            }
            'f' {
                'y': "cdfy"
            }
            'g' {
                'z': "cdgz"
            }
            'h' {
                'w': "cdhw"
            }
        }
        'e': "ce"
    }
}
$ print pot potato pottery tattoo tempo|trie
{
    'p' {
        'o' {
            't': "pot" {
                'a' {
                    't' {
                        'o': "potato"
                    }
                }
                't' {
                    'e' {
                        'r' {
                            'y': "pottery"
                        }
                    }
                }
            }
        }
    }
    't' {
        'a' {
            't' {
                't' {
                    'o' {
                        'o': "tattoo"
                    }
                }
            }
        }
        'e' {
            'm' {
                'p' {
                    'o': "tempo"
                }
            }
        }
    }
}
$

--[ print-obj-base0-ternary ]---------------------------------------------------

$ trie() { ../src/trie --node=str --trie=ternary "$@"; }
$ print a|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
}
$ print a ab|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
        .hi {
            .ch: 'b'
            .eq {
                .val: "ab"
            }
        }
    }
}
$ print a ab abc|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
        .hi {
            .ch: 'b'
            .eq {
                .val: "ab"
                .hi {
                    .ch: 'c'
                    .eq {
                        .val: "abc"
                    }
                }
            }
        }
    }
}
$ print a b|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .val: "b"
        }
    }
}
$ print a b abc bac abd|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
        .hi {
            .ch: 'b'
            .eq {
                .ch: 'c'
                .eq {
                    .val: "abc"
                }
                .hi {
                    .ch: 'd'
                    .eq {
                        .val: "abd"
                    }
                }
            }
        }
    }
    .hi {
        .ch: 'b'
        .eq {
            .val: "b"
            .hi {
                .ch: 'a'
                .eq {
                    .ch: 'c'
                    .eq {
                        .val: "bac"
                    }
                }
            }
        }
    }
}
$ print a bb ba c|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .val: "bb"
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .val: "c"
            }
        }
    }
}
$ print a bb ba cc|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .val: "bb"
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'c'
                .eq {
                    .val: "cc"
                }
            }
        }
    }
}
$ print a bb ba ccc|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .val: "bb"
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'c'
                .eq {
                    .ch: 'c'
                    .eq {
                        .val: "ccc"
                    }
                }
            }
        }
    }
}
$ print a bb ba cde|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .val: "bb"
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'd'
                .eq {
                    .ch: 'e'
                    .eq {
                        .val: "cde"
                    }
                }
            }
        }
    }
}
$ print a bb ba cdef|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .val: "bb"
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'd'
                .eq {
                    .ch: 'e'
                    .eq {
                        .ch: 'f'
                        .eq {
                            .val: "cdef"
                        }
                    }
                }
            }
        }
    }
}
$ print a bb ba cdef cdefg|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .val: "bb"
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'd'
                .eq {
                    .ch: 'e'
                    .eq {
                        .ch: 'f'
                        .eq {
                            .val: "cdef"
                            .hi {
                                .ch: 'g'
                                .eq {
                                    .val: "cdefg"
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
$ print a bb bac cdef|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .ch: 'c'
                    .eq {
                        .val: "bac"
                    }
                }
            }
            .eq {
                .val: "bb"
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'd'
                .eq {
                    .ch: 'e'
                    .eq {
                        .ch: 'f'
                        .eq {
                            .val: "cdef"
                        }
                    }
                }
            }
        }
    }
}
$ print a bbx ba ccc|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .ch: 'x'
                .eq {
                    .val: "bbx"
                }
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'c'
                .eq {
                    .ch: 'c'
                    .eq {
                        .val: "ccc"
                    }
                }
            }
        }
    }
}
$ print a bbx bay ccc|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .ch: 'y'
                    .eq {
                        .val: "bay"
                    }
                }
            }
            .eq {
                .ch: 'x'
                .eq {
                    .val: "bbx"
                }
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'c'
                .eq {
                    .ch: 'c'
                    .eq {
                        .val: "ccc"
                    }
                }
            }
        }
    }
}
$ print a cde cdef|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'c'
        .eq {
            .ch: 'd'
            .eq {
                .ch: 'e'
                .eq {
                    .val: "cde"
                    .hi {
                        .ch: 'f'
                        .eq {
                            .val: "cdef"
                        }
                    }
                }
            }
        }
    }
}
$ print a cde cdef cdefg|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'c'
        .eq {
            .ch: 'd'
            .eq {
                .ch: 'e'
                .eq {
                    .val: "cde"
                    .hi {
                        .ch: 'f'
                        .eq {
                            .val: "cdef"
                            .hi {
                                .ch: 'g'
                                .eq {
                                    .val: "cdefg"
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
$ print a cde cdef cdefgh|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'c'
        .eq {
            .ch: 'd'
            .eq {
                .ch: 'e'
                .eq {
                    .val: "cde"
                    .hi {
                        .ch: 'f'
                        .eq {
                            .val: "cdef"
                            .hi {
                                .ch: 'g'
                                .eq {
                                    .ch: 'h'
                                    .eq {
                                        .val: "cdefgh"
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
$ print a cdef cdefg|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'c'
        .eq {
            .ch: 'd'
            .eq {
                .ch: 'e'
                .eq {
                    .ch: 'f'
                    .eq {
                        .val: "cdef"
                        .hi {
                            .ch: 'g'
                            .eq {
                                .val: "cdefg"
                            }
                        }
                    }
                }
            }
        }
    }
}
$ print ab|trie
{
    .ch: 'a'
    .eq {
        .ch: 'b'
        .eq {
            .val: "ab"
        }
    }
}
$ print ab bb ba ccc|trie
{
    .ch: 'a'
    .eq {
        .ch: 'b'
        .eq {
            .val: "ab"
        }
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .val: "bb"
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'c'
                .eq {
                    .ch: 'c'
                    .eq {
                        .val: "ccc"
                    }
                }
            }
        }
    }
}
$ print ab bb ba cde|trie
{
    .ch: 'a'
    .eq {
        .ch: 'b'
        .eq {
            .val: "ab"
        }
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .val: "bb"
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'd'
                .eq {
                    .ch: 'e'
                    .eq {
                        .val: "cde"
                    }
                }
            }
        }
    }
}
$ print ab bbx ba ccc|trie
{
    .ch: 'a'
    .eq {
        .ch: 'b'
        .eq {
            .val: "ab"
        }
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .ch: 'x'
                .eq {
                    .val: "bbx"
                }
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'c'
                .eq {
                    .ch: 'c'
                    .eq {
                        .val: "ccc"
                    }
                }
            }
        }
    }
}
$ print ab c|trie
{
    .ch: 'a'
    .eq {
        .ch: 'b'
        .eq {
            .val: "ab"
        }
    }
    .hi {
        .ch: 'c'
        .eq {
            .val: "c"
        }
    }
}
$ print abc bb ba ccc|trie
{
    .ch: 'a'
    .eq {
        .ch: 'b'
        .eq {
            .ch: 'c'
            .eq {
                .val: "abc"
            }
        }
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .lo {
                .ch: 'a'
                .eq {
                    .val: "ba"
                }
            }
            .eq {
                .val: "bb"
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'c'
                .eq {
                    .ch: 'c'
                    .eq {
                        .val: "ccc"
                    }
                }
            }
        }
    }
}
$ print abcd abde abef|trie
{
    .ch: 'a'
    .eq {
        .ch: 'b'
        .eq {
            .ch: 'c'
            .eq {
                .ch: 'd'
                .eq {
                    .val: "abcd"
                }
            }
            .hi {
                .ch: 'd'
                .eq {
                    .ch: 'e'
                    .eq {
                        .val: "abde"
                    }
                }
                .hi {
                    .ch: 'e'
                    .eq {
                        .ch: 'f'
                        .eq {
                            .val: "abef"
                        }
                    }
                }
            }
        }
    }
}
$ print abg a abc ab abd|trie
{
    .ch: 'a'
    .eq {
        .ch: 'b'
        .lo {
            .val: "a"
        }
        .eq {
            .ch: 'g'
            .lo {
                .ch: 'c'
                .lo {
                    .val: "ab"
                }
                .eq {
                    .val: "abc"
                }
                .hi {
                    .ch: 'd'
                    .eq {
                        .val: "abd"
                    }
                }
            }
            .eq {
                .val: "abg"
            }
        }
    }
}
$ print ac ab|trie
{
    .ch: 'a'
    .eq {
        .ch: 'c'
        .lo {
            .ch: 'b'
            .eq {
                .val: "ab"
            }
        }
        .eq {
            .val: "ac"
        }
    }
}
$ print aef ae abg a abc ab abd|trie
{
    .ch: 'a'
    .eq {
        .ch: 'e'
        .lo {
            .ch: 'b'
            .lo {
                .val: "a"
            }
            .eq {
                .ch: 'g'
                .lo {
                    .ch: 'c'
                    .lo {
                        .val: "ab"
                    }
                    .eq {
                        .val: "abc"
                    }
                    .hi {
                        .ch: 'd'
                        .eq {
                            .val: "abd"
                        }
                    }
                }
                .eq {
                    .val: "abg"
                }
            }
        }
        .eq {
            .ch: 'f'
            .lo {
                .val: "ae"
            }
            .eq {
                .val: "aef"
            }
        }
    }
}
$ print cde cdef cdefgh|trie
{
    .ch: 'c'
    .eq {
        .ch: 'd'
        .eq {
            .ch: 'e'
            .eq {
                .val: "cde"
                .hi {
                    .ch: 'f'
                    .eq {
                        .val: "cdef"
                        .hi {
                            .ch: 'g'
                            .eq {
                                .ch: 'h'
                                .eq {
                                    .val: "cdefgh"
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
$ print cdef cdefg|trie
{
    .ch: 'c'
    .eq {
        .ch: 'd'
        .eq {
            .ch: 'e'
            .eq {
                .ch: 'f'
                .eq {
                    .val: "cdef"
                    .hi {
                        .ch: 'g'
                        .eq {
                            .val: "cdefg"
                        }
                    }
                }
            }
        }
    }
}
$ print cdex cdfy cdgz cdhw|trie
{
    .ch: 'c'
    .eq {
        .ch: 'd'
        .eq {
            .ch: 'e'
            .eq {
                .ch: 'x'
                .eq {
                    .val: "cdex"
                }
            }
            .hi {
                .ch: 'f'
                .eq {
                    .ch: 'y'
                    .eq {
                        .val: "cdfy"
                    }
                }
                .hi {
                    .ch: 'g'
                    .eq {
                        .ch: 'z'
                        .eq {
                            .val: "cdgz"
                        }
                    }
                    .hi {
                        .ch: 'h'
                        .eq {
                            .ch: 'w'
                            .eq {
                                .val: "cdhw"
                            }
                        }
                    }
                }
            }
        }
    }
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    .ch: 'c'
    .eq {
        .ch: 'e'
        .lo {
            .ch: 'd'
            .eq {
                .ch: 'e'
                .eq {
                    .ch: 'x'
                    .eq {
                        .val: "cdex"
                    }
                }
                .hi {
                    .ch: 'f'
                    .eq {
                        .ch: 'y'
                        .eq {
                            .val: "cdfy"
                        }
                    }
                    .hi {
                        .ch: 'g'
                        .eq {
                            .ch: 'z'
                            .eq {
                                .val: "cdgz"
                            }
                        }
                        .hi {
                            .ch: 'h'
                            .eq {
                                .ch: 'w'
                                .eq {
                                    .val: "cdhw"
                                }
                            }
                        }
                    }
                }
            }
        }
        .eq {
            .val: "ce"
        }
    }
}
$ print pot potato pottery tattoo tempo|trie
{
    .ch: 'p'
    .eq {
        .ch: 'o'
        .eq {
            .ch: 't'
            .eq {
                .val: "pot"
                .hi {
                    .ch: 'a'
                    .eq {
                        .ch: 't'
                        .eq {
                            .ch: 'o'
                            .eq {
                                .val: "potato"
                            }
                        }
                    }
                    .hi {
                        .ch: 't'
                        .eq {
                            .ch: 'e'
                            .eq {
                                .ch: 'r'
                                .eq {
                                    .ch: 'y'
                                    .eq {
                                        .val: "pottery"
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    .hi {
        .ch: 't'
        .eq {
            .ch: 'a'
            .eq {
                .ch: 't'
                .eq {
                    .ch: 't'
                    .eq {
                        .ch: 'o'
                        .eq {
                            .ch: 'o'
                            .eq {
                                .val: "tattoo"
                            }
                        }
                    }
                }
            }
            .hi {
                .ch: 'e'
                .eq {
                    .ch: 'm'
                    .eq {
                        .ch: 'p'
                        .eq {
                            .ch: 'o'
                            .eq {
                                .val: "tempo"
                            }
                        }
                    }
                }
            }
        }
    }
}
$

--[ print-obj-base ]------------------------------------------------------------

$ printc() { LANG=C awk '{ printf("%c\n", strtonum("0x" $1)) }' <<< "$1"; }
$ trie() { ../src/trie --trie=array --node=str "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a b|trie
{
    'a': "a"
    'b': "b"
}
$ print a aa b|trie
{
    'a': "a" {
        'a': "aa"
    }
    'b': "b"
}
$ print a b bb|trie
{
    'a': "a"
    'b': "b" {
        'b': "bb"
    }
}
$ print aa bb|trie
{
    'a' {
        'a': "aa"
    }
    'b' {
        'b': "bb"
    }
}
$ print a b bb cc ccc ddd dddd|trie 
{
    'a': "a"
    'b': "b" {
        'b': "bb"
    }
    'c' {
        'c': "cc" {
            'c': "ccc"
        }
    }
    'd' {
        'd' {
            'd': "ddd" {
                'd': "dddd"
            }
        }
    }
}
$ print a ab abc|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc"
        }
    }
}
$ print a ab abc abcd|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc" {
                'd': "abcd"
            }
        }
    }
}
$ print a ab abc abcd abc$'\xfa'|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc" {
                'd': "abcd"
                '\xfa': "abc\xfa"
            }
        }
    }
}
$ printc 1|trie
{
    '\x1': "\x01"
}
$ printc ff|trie
{
    '\xff': "\xff"
}
$ printc 22|trie
{
    '"': "\""
}
$ printc 27|trie
{
    '\'': "'"
}
$ trie() { ../src/trie --trie=ternary --node=str "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a b|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .val: "b"
        }
    }
}
$ print a aa b|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
        .hi {
            .ch: 'a'
            .eq {
                .val: "aa"
            }
        }
    }
    .hi {
        .ch: 'b'
        .eq {
            .val: "b"
        }
    }
}
$ print a b bb|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .val: "b"
            .hi {
                .ch: 'b'
                .eq {
                    .val: "bb"
                }
            }
        }
    }
}
$ print aa bb|trie
{
    .ch: 'a'
    .eq {
        .ch: 'a'
        .eq {
            .val: "aa"
        }
    }
    .hi {
        .ch: 'b'
        .eq {
            .ch: 'b'
            .eq {
                .val: "bb"
            }
        }
    }
}
$ print a b bb cc ccc ddd dddd|trie 
{
    .ch: 'a'
    .eq {
        .val: "a"
    }
    .hi {
        .ch: 'b'
        .eq {
            .val: "b"
            .hi {
                .ch: 'b'
                .eq {
                    .val: "bb"
                }
            }
        }
        .hi {
            .ch: 'c'
            .eq {
                .ch: 'c'
                .eq {
                    .val: "cc"
                    .hi {
                        .ch: 'c'
                        .eq {
                            .val: "ccc"
                        }
                    }
                }
            }
            .hi {
                .ch: 'd'
                .eq {
                    .ch: 'd'
                    .eq {
                        .ch: 'd'
                        .eq {
                            .val: "ddd"
                            .hi {
                                .ch: 'd'
                                .eq {
                                    .val: "dddd"
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
$ print a ab abc|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
        .hi {
            .ch: 'b'
            .eq {
                .val: "ab"
                .hi {
                    .ch: 'c'
                    .eq {
                        .val: "abc"
                    }
                }
            }
        }
    }
}
$ print a ab abc abcd|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
        .hi {
            .ch: 'b'
            .eq {
                .val: "ab"
                .hi {
                    .ch: 'c'
                    .eq {
                        .val: "abc"
                        .hi {
                            .ch: 'd'
                            .eq {
                                .val: "abcd"
                            }
                        }
                    }
                }
            }
        }
    }
}
$ print a ab abc abcd abc$'\xfa'|trie
{
    .ch: 'a'
    .eq {
        .val: "a"
        .hi {
            .ch: 'b'
            .eq {
                .val: "ab"
                .hi {
                    .ch: 'c'
                    .eq {
                        .val: "abc"
                        .hi {
                            .ch: 'd'
                            .eq {
                                .val: "abcd"
                            }
                            .hi {
                                .ch: '\xfa'
                                .eq {
                                    .val: "abc\xfa"
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
$ printc 1|trie
{
    .ch: '\x1'
    .eq {
        .val: "\x01"
    }
}
$ printc ff|trie
{
    .ch: '\xff'
    .eq {
        .val: "\xff"
    }
}
$ printc 22|trie
{
    .ch: '"'
    .eq {
        .val: "\""
    }
}
$ printc 27|trie
{
    .ch: '\''
    .eq {
        .val: "'"
    }
}
$ trie() { ../src/trie --node=str --output=trie --gen=compact --attrs "$@"; }
$ printc 22|trie --trie=array
[1,'"'] {
    "\"" [0,"",'"',[0]]: "\""
}
$ printc 22|trie --trie=ternary
[1,'"'] {
    "\"" [0,"",'"',[0]]: "\""
}
$ printc 27|trie --trie=array
[1,'\''] {
    "'" [0,"",'\'',[0]]: "'"
}
$ printc 27|trie --trie=ternary
[1,'\''] {
    "'" [0,"",'\'',[0]]: "'"
}
$

--[ print-obj-base-array ]------------------------------------------------------

$ trie() { ../src/trie --output=object --attrs --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
[1,'a'] {
.   'a': "a"
}
$ print a b|trie
[2,'b'] {
.   'a': "a"
.   'b': "b"
}
$ print a b c|trie
[3,'c'] {
.   'a': "a"
.   'b': "b"
.   'c': "c"
}
$ print a ab abc|trie
[1,'a'] {
.   'a': "a" [1,'b'] {
.   .   'b': "ab" [1,'c'] {
.   .   .   'c': "abc"
.   .   }
.   }
}
$ print a ab ac|trie
[1,'a'] {
.   'a': "a" [2,'c'] {
.   .   'b': "ab"
.   .   'c': "ac"
.   }
}
$ print a ab ac ad|trie
[1,'a'] {
.   'a': "a" [3,'d'] {
.   .   'b': "ab"
.   .   'c': "ac"
.   .   'd': "ad"
.   }
}
$ print a abd ac|trie
[1,'a'] {
.   'a': "a" [2,'c'] {
.   .   'b' [1,'d'] {
.   .   .   'd': "abd"
.   .   }
.   .   'c': "ac"
.   }
}
$ print a ab ac acd|trie
[1,'a'] {
.   'a': "a" [2,'c'] {
.   .   'b': "ab"
.   .   'c': "ac" [1,'d'] {
.   .   .   'd': "acd"
.   .   }
.   }
}
$ print a bb ba ccc|trie
[3,'c'] {
.   'a': "a"
.   'b' [2,'b'] {
.   .   'a': "ba"
.   .   'b': "bb"
.   }
.   'c' [1,'c'] {
.   .   'c' [1,'c'] {
.   .   .   'c': "ccc"
.   .   }
.   }
}
$ print a bb ccc|trie
[3,'c'] {
.   'a': "a"
.   'b' [1,'b'] {
.   .   'b': "bb"
.   }
.   'c' [1,'c'] {
.   .   'c' [1,'c'] {
.   .   .   'c': "ccc"
.   .   }
.   }
}
$ print a bb ba ccc|trie
[3,'c'] {
.   'a': "a"
.   'b' [2,'b'] {
.   .   'a': "ba"
.   .   'b': "bb"
.   }
.   'c' [1,'c'] {
.   .   'c' [1,'c'] {
.   .   .   'c': "ccc"
.   .   }
.   }
}
$ print abc abd acde|trie
[1,'a'] {
.   'a' [2,'c'] {
.   .   'b' [2,'d'] {
.   .   .   'c': "abc"
.   .   .   'd': "abd"
.   .   }
.   .   'c' [1,'d'] {
.   .   .   'd' [1,'e'] {
.   .   .   .   'e': "acde"
.   .   .   }
.   .   }
.   }
}
$ print abc abd acde ac|trie
[1,'a'] {
.   'a' [2,'c'] {
.   .   'b' [2,'d'] {
.   .   .   'c': "abc"
.   .   .   'd': "abd"
.   .   }
.   .   'c': "ac" [1,'d'] {
.   .   .   'd' [1,'e'] {
.   .   .   .   'e': "acde"
.   .   .   }
.   .   }
.   }
}
$ print abc abd acde acfg|trie
[1,'a'] {
.   'a' [2,'c'] {
.   .   'b' [2,'d'] {
.   .   .   'c': "abc"
.   .   .   'd': "abd"
.   .   }
.   .   'c' [2,'f'] {
.   .   .   'd' [1,'e'] {
.   .   .   .   'e': "acde"
.   .   .   }
.   .   .   'f' [1,'g'] {
.   .   .   .   'g': "acfg"
.   .   .   }
.   .   }
.   }
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c'] {
.   'c' [2,'f'] {
.   .   'd' [1,'e'] {
.   .   .   'e': "cde"
.   .   }
.   .   'f' [1,'g'] {
.   .   .   'g': "cfg" [1,'x'] {
.   .   .   .   'x': "cfgx" [2,'z'] {
.   .   .   .   .   'y': "cfgxy" [1,'z'] {
.   .   .   .   .   .   'z': "cfgxyz"
.   .   .   .   .   }
.   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   .   'z': "cfgxzzz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c'] {
.   'c' [2,'g'] {
.   .   'f' [1,'g'] {
.   .   .   'g': "cfg" [1,'x'] {
.   .   .   .   'x': "cfgx" [2,'z'] {
.   .   .   .   .   'y': "cfgxy" [1,'z'] {
.   .   .   .   .   .   'z': "cfgxyz"
.   .   .   .   .   }
.   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   .   'z': "cfgxzzz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'g' [1,'e'] {
.   .   .   'e': "cge"
.   .   }
.   }
}
$ print a abcd abcdefg h hijk|trie
[2,'h'] {
.   'a': "a" [1,'b'] {
.   .   'b' [1,'c'] {
.   .   .   'c' [1,'d'] {
.   .   .   .   'd': "abcd" [1,'e'] {
.   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   'f' [1,'g'] {
.   .   .   .   .   .   .   'g': "abcdefg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'h': "h" [1,'i'] {
.   .   'i' [1,'j'] {
.   .   .   'j' [1,'k'] {
.   .   .   .   'k': "hijk"
.   .   .   }
.   .   }
.   }
}
$ print a abcd abcdefg abcdxyz h hijk|trie
[2,'h'] {
.   'a': "a" [1,'b'] {
.   .   'b' [1,'c'] {
.   .   .   'c' [1,'d'] {
.   .   .   .   'd': "abcd" [2,'x'] {
.   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   'f' [1,'g'] {
.   .   .   .   .   .   .   'g': "abcdefg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   'x' [1,'y'] {
.   .   .   .   .   .   'y' [1,'z'] {
.   .   .   .   .   .   .   'z': "abcdxyz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'h': "h" [1,'i'] {
.   .   'i' [1,'j'] {
.   .   .   'j' [1,'k'] {
.   .   .   .   'k': "hijk"
.   .   .   }
.   .   }
.   }
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
[2,'h'] {
.   'a': "a" [1,'b'] {
.   .   'b' [1,'c'] {
.   .   .   'c' [1,'d'] {
.   .   .   .   'd': "abcd" [2,'x'] {
.   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   'f' [1,'g'] {
.   .   .   .   .   .   .   'g': "abcdefg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   'x' [1,'y'] {
.   .   .   .   .   .   'y' [1,'z'] {
.   .   .   .   .   .   .   'z': "abcdxyz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'h': "h" [2,'l'] {
.   .   'i' [1,'j'] {
.   .   .   'j' [1,'k'] {
.   .   .   .   'k': "hijk"
.   .   .   }
.   .   }
.   .   'l' [1,'m'] {
.   .   .   'm': "hlm"
.   .   }
.   }
}
$

--[ print-obj-base-ternary ]----------------------------------------------------

$ trie() { ../src/trie --output=object --attrs --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
[1,'a']
[0] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   }
}
$ print a b|trie
[2,'b']
[0] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   }
.   .hi [0] {
.   .   .ch: 'b'
.   .   .eq [0] {
.   .   .   .val: "b"
.   .   }
.   }
}
$ print a b c|trie
[3,'c']
[0] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   }
.   .hi [0] {
.   .   .ch: 'b'
.   .   .eq [0] {
.   .   .   .val: "b"
.   .   }
.   .   .hi [0] {
.   .   .   .ch: 'c'
.   .   .   .eq [0] {
.   .   .   .   .val: "c"
.   .   .   }
.   .   }
.   }
}
$ print a ab abc|trie
[1,'a']
[1,'b'] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   .   .hi [1,'c'] {
.   .   .   .ch: 'b'
.   .   .   .eq [0] {
.   .   .   .   .val: "ab"
.   .   .   .   .hi [0] {
.   .   .   .   .   .ch: 'c'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "abc"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print a ab ac|trie
[1,'a']
[2,'c'] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   .   .hi [0] {
.   .   .   .ch: 'b'
.   .   .   .eq [0] {
.   .   .   .   .val: "ab"
.   .   .   }
.   .   .   .hi [0] {
.   .   .   .   .ch: 'c'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "ac"
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print a ab ac ad|trie
[1,'a']
[3,'d'] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   .   .hi [0] {
.   .   .   .ch: 'b'
.   .   .   .eq [0] {
.   .   .   .   .val: "ab"
.   .   .   }
.   .   .   .hi [0] {
.   .   .   .   .ch: 'c'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "ac"
.   .   .   .   }
.   .   .   .   .hi [0] {
.   .   .   .   .   .ch: 'd'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "ad"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print a abd ac|trie
[1,'a']
[2,'c'] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   .   .hi [1,'d'] {
.   .   .   .ch: 'b'
.   .   .   .eq [0] {
.   .   .   .   .ch: 'd'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "abd"
.   .   .   .   }
.   .   .   }
.   .   .   .hi [0] {
.   .   .   .   .ch: 'c'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "ac"
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print a ab ac acd|trie
[1,'a']
[2,'c'] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   .   .hi [0] {
.   .   .   .ch: 'b'
.   .   .   .eq [0] {
.   .   .   .   .val: "ab"
.   .   .   }
.   .   .   .hi [1,'d'] {
.   .   .   .   .ch: 'c'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "ac"
.   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "acd"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print a bb ba ccc|trie
[3,'c']
[0] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   }
.   .hi [2,'b'] {
.   .   .ch: 'b'
.   .   .eq [0] {
.   .   .   .ch: 'b'
.   .   .   .lo [0] {
.   .   .   .   .ch: 'a'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "ba"
.   .   .   .   }
.   .   .   }
.   .   .   .eq [0] {
.   .   .   .   .val: "bb"
.   .   .   }
.   .   }
.   .   .hi [1,'c'] {
.   .   .   .ch: 'c'
.   .   .   .eq [1,'c'] {
.   .   .   .   .ch: 'c'
.   .   .   .   .eq [0] {
.   .   .   .   .   .ch: 'c'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "ccc"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print a bb ccc|trie
[3,'c']
[0] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   }
.   .hi [1,'b'] {
.   .   .ch: 'b'
.   .   .eq [0] {
.   .   .   .ch: 'b'
.   .   .   .eq [0] {
.   .   .   .   .val: "bb"
.   .   .   }
.   .   }
.   .   .hi [1,'c'] {
.   .   .   .ch: 'c'
.   .   .   .eq [1,'c'] {
.   .   .   .   .ch: 'c'
.   .   .   .   .eq [0] {
.   .   .   .   .   .ch: 'c'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "ccc"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print a bb ba ccc|trie
[3,'c']
[0] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   }
.   .hi [2,'b'] {
.   .   .ch: 'b'
.   .   .eq [0] {
.   .   .   .ch: 'b'
.   .   .   .lo [0] {
.   .   .   .   .ch: 'a'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "ba"
.   .   .   .   }
.   .   .   }
.   .   .   .eq [0] {
.   .   .   .   .val: "bb"
.   .   .   }
.   .   }
.   .   .hi [1,'c'] {
.   .   .   .ch: 'c'
.   .   .   .eq [1,'c'] {
.   .   .   .   .ch: 'c'
.   .   .   .   .eq [0] {
.   .   .   .   .   .ch: 'c'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "ccc"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print abc abd acde|trie
[1,'a']
[2,'c'] {
.   .ch: 'a'
.   .eq [2,'d'] {
.   .   .ch: 'b'
.   .   .eq [0] {
.   .   .   .ch: 'c'
.   .   .   .eq [0] {
.   .   .   .   .val: "abc"
.   .   .   }
.   .   .   .hi [0] {
.   .   .   .   .ch: 'd'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "abd"
.   .   .   .   }
.   .   .   }
.   .   }
.   .   .hi [1,'d'] {
.   .   .   .ch: 'c'
.   .   .   .eq [1,'e'] {
.   .   .   .   .ch: 'd'
.   .   .   .   .eq [0] {
.   .   .   .   .   .ch: 'e'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "acde"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print abc abd acde ac|trie
[1,'a']
[2,'c'] {
.   .ch: 'a'
.   .eq [2,'d'] {
.   .   .ch: 'b'
.   .   .eq [0] {
.   .   .   .ch: 'c'
.   .   .   .eq [0] {
.   .   .   .   .val: "abc"
.   .   .   }
.   .   .   .hi [0] {
.   .   .   .   .ch: 'd'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "abd"
.   .   .   .   }
.   .   .   }
.   .   }
.   .   .hi [1,'d'] {
.   .   .   .ch: 'c'
.   .   .   .eq [1,'e'] {
.   .   .   .   .ch: 'd'
.   .   .   .   .lo [0] {
.   .   .   .   .   .val: "ac"
.   .   .   .   }
.   .   .   .   .eq [0] {
.   .   .   .   .   .ch: 'e'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "acde"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print abc abd acde acfg|trie
[1,'a']
[2,'c'] {
.   .ch: 'a'
.   .eq [2,'d'] {
.   .   .ch: 'b'
.   .   .eq [0] {
.   .   .   .ch: 'c'
.   .   .   .eq [0] {
.   .   .   .   .val: "abc"
.   .   .   }
.   .   .   .hi [0] {
.   .   .   .   .ch: 'd'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "abd"
.   .   .   .   }
.   .   .   }
.   .   }
.   .   .hi [2,'f'] {
.   .   .   .ch: 'c'
.   .   .   .eq [1,'e'] {
.   .   .   .   .ch: 'd'
.   .   .   .   .eq [0] {
.   .   .   .   .   .ch: 'e'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "acde"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   .hi [1,'g'] {
.   .   .   .   .   .ch: 'f'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "acfg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c']
[2,'f'] {
.   .ch: 'c'
.   .eq [1,'e'] {
.   .   .ch: 'd'
.   .   .eq [0] {
.   .   .   .ch: 'e'
.   .   .   .eq [0] {
.   .   .   .   .val: "cde"
.   .   .   }
.   .   }
.   .   .hi [1,'g'] {
.   .   .   .ch: 'f'
.   .   .   .eq [1,'x'] {
.   .   .   .   .ch: 'g'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "cfg"
.   .   .   .   .   .hi [2,'z'] {
.   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "cfgx"
.   .   .   .   .   .   .   .hi [1,'z'] {
.   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .val: "cfgxy"
.   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "cfgxyz"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .hi [1,'z'] {
.   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .eq [1,'z'] {
.   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "cfgxzzz"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c']
[2,'g'] {
.   .ch: 'c'
.   .eq [1,'e'] {
.   .   .ch: 'g'
.   .   .lo [1,'g'] {
.   .   .   .ch: 'f'
.   .   .   .eq [1,'x'] {
.   .   .   .   .ch: 'g'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "cfg"
.   .   .   .   .   .hi [2,'z'] {
.   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "cfgx"
.   .   .   .   .   .   .   .hi [1,'z'] {
.   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .val: "cfgxy"
.   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "cfgxyz"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .hi [1,'z'] {
.   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .eq [1,'z'] {
.   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "cfgxzzz"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   .eq [0] {
.   .   .   .ch: 'e'
.   .   .   .eq [0] {
.   .   .   .   .val: "cge"
.   .   .   }
.   .   }
.   }
}
$ print a abcd abcdefg h hijk|trie
[2,'h']
[1,'b'] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   .   .hi [1,'c'] {
.   .   .   .ch: 'b'
.   .   .   .eq [1,'d'] {
.   .   .   .   .ch: 'c'
.   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .ch: 'd'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "abcd"
.   .   .   .   .   .   .hi [1,'f'] {
.   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .eq [1,'g'] {
.   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .val: "abcdefg"
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   .hi [1,'i'] {
.   .   .ch: 'h'
.   .   .eq [0] {
.   .   .   .val: "h"
.   .   .   .hi [1,'j'] {
.   .   .   .   .ch: 'i'
.   .   .   .   .eq [1,'k'] {
.   .   .   .   .   .ch: 'j'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "hijk"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print a abcd abcdefg abcdxyz h hijk|trie
[2,'h']
[1,'b'] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   .   .hi [1,'c'] {
.   .   .   .ch: 'b'
.   .   .   .eq [1,'d'] {
.   .   .   .   .ch: 'c'
.   .   .   .   .eq [2,'x'] {
.   .   .   .   .   .ch: 'd'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "abcd"
.   .   .   .   .   .   .hi [1,'f'] {
.   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .eq [1,'g'] {
.   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .val: "abcdefg"
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .hi [1,'y'] {
.   .   .   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .   .   .eq [1,'z'] {
.   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "abcdxyz"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   .hi [1,'i'] {
.   .   .ch: 'h'
.   .   .eq [0] {
.   .   .   .val: "h"
.   .   .   .hi [1,'j'] {
.   .   .   .   .ch: 'i'
.   .   .   .   .eq [1,'k'] {
.   .   .   .   .   .ch: 'j'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "hijk"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
[2,'h']
[1,'b'] {
.   .ch: 'a'
.   .eq [0] {
.   .   .val: "a"
.   .   .hi [1,'c'] {
.   .   .   .ch: 'b'
.   .   .   .eq [1,'d'] {
.   .   .   .   .ch: 'c'
.   .   .   .   .eq [2,'x'] {
.   .   .   .   .   .ch: 'd'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "abcd"
.   .   .   .   .   .   .hi [1,'f'] {
.   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .eq [1,'g'] {
.   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .val: "abcdefg"
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .hi [1,'y'] {
.   .   .   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .   .   .eq [1,'z'] {
.   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "abcdxyz"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   .hi [2,'l'] {
.   .   .ch: 'h'
.   .   .eq [0] {
.   .   .   .val: "h"
.   .   .   .hi [1,'j'] {
.   .   .   .   .ch: 'i'
.   .   .   .   .eq [1,'k'] {
.   .   .   .   .   .ch: 'j'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "hijk"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   .hi [1,'m'] {
.   .   .   .   .   .ch: 'l'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "hlm"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$

--[ print-obj-alphabets-array ]-------------------------------------------------

$ ../src/trie --attrs --dots --output=object --trie=array < alphabets.txt
[25,'z'] {
.   'a' [8,'z'] {
.   .   'a': "aa"
.   .   'f': "af"
.   .   'g' [1,'q'] {
.   .   .   'q': "agq"
.   .   }
.   .   'k': "ak"
.   .   'm': "am"
.   .   'r': "ar"
.   .   's': "as" [2,'t'] {
.   .   .   'a': "asa"
.   .   .   't': "ast"
.   .   }
.   .   'z': "az" [1,'_'] {
.   .   .   '_' [1,'C'] {
.   .   .   .   'C' [1,'y'] {
.   .   .   .   .   'y' [1,'r'] {
.   .   .   .   .   .   'r' [1,'l'] {
.   .   .   .   .   .   .   'l': "az_Cyrl"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'b' [9,'y'] {
.   .   'a' [1,'s'] {
.   .   .   's': "bas"
.   .   }
.   .   'e': "be" [2,'z'] {
.   .   .   'm': "bem"
.   .   .   'z': "bez"
.   .   }
.   .   'g': "bg"
.   .   'm': "bm"
.   .   'n': "bn"
.   .   'o': "bo"
.   .   'r': "br" [1,'x'] {
.   .   .   'x': "brx"
.   .   }
.   .   's': "bs" [1,'_'] {
.   .   .   '_' [1,'C'] {
.   .   .   .   'C' [1,'y'] {
.   .   .   .   .   'y' [1,'r'] {
.   .   .   .   .   .   'r' [1,'l'] {
.   .   .   .   .   .   .   'l': "bs_Cyrl"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'y' [1,'n'] {
.   .   .   'n': "byn"
.   .   }
.   }
.   'c' [5,'y'] {
.   .   'a': "ca"
.   .   'g' [1,'g'] {
.   .   .   'g': "cgg"
.   .   }
.   .   'h' [1,'r'] {
.   .   .   'r': "chr"
.   .   }
.   .   's': "cs"
.   .   'y': "cy"
.   }
.   'd' [6,'z'] {
.   .   'a': "da" [1,'v'] {
.   .   .   'v': "dav"
.   .   }
.   .   'e': "de"
.   .   'j' [1,'e'] {
.   .   .   'e': "dje"
.   .   }
.   .   'u' [1,'a'] {
.   .   .   'a': "dua"
.   .   }
.   .   'y' [1,'o'] {
.   .   .   'o': "dyo"
.   .   }
.   .   'z': "dz"
.   }
.   'e' [9,'w'] {
.   .   'b' [1,'u'] {
.   .   .   'u': "ebu"
.   .   }
.   .   'e': "ee"
.   .   'l': "el"
.   .   'n': "en"
.   .   'o': "eo"
.   .   's': "es"
.   .   't': "et"
.   .   'u': "eu"
.   .   'w' [1,'o'] {
.   .   .   'o': "ewo"
.   .   }
.   }
.   'f' [7,'y'] {
.   .   'a': "fa"
.   .   'f': "ff"
.   .   'i': "fi" [1,'l'] {
.   .   .   'l': "fil"
.   .   }
.   .   'o': "fo"
.   .   'r': "fr"
.   .   'u' [1,'r'] {
.   .   .   'r': "fur"
.   .   }
.   .   'y': "fy"
.   }
.   'g' [6,'v'] {
.   .   'a': "ga"
.   .   'd': "gd"
.   .   'l': "gl"
.   .   's' [1,'w'] {
.   .   .   'w': "gsw"
.   .   }
.   .   'u': "gu" [1,'z'] {
.   .   .   'z': "guz"
.   .   }
.   .   'v': "gv"
.   }
.   'h' [6,'y'] {
.   .   'a': "ha" [1,'w'] {
.   .   .   'w': "haw"
.   .   }
.   .   'e': "he"
.   .   'i': "hi"
.   .   'r': "hr"
.   .   'u': "hu"
.   .   'y': "hy"
.   }
.   'i' [6,'t'] {
.   .   'a': "ia"
.   .   'd': "id"
.   .   'g': "ig"
.   .   'i': "ii"
.   .   's': "is"
.   .   't': "it"
.   }
.   'j' [3,'m'] {
.   .   'a': "ja"
.   .   'g' [1,'o'] {
.   .   .   'o': "jgo"
.   .   }
.   .   'm' [1,'c'] {
.   .   .   'c': "jmc"
.   .   }
.   }
.   'k' [13,'y'] {
.   .   'a': "ka" [2,'m'] {
.   .   .   'b': "kab"
.   .   .   'm': "kam"
.   .   }
.   .   'd' [1,'e'] {
.   .   .   'e': "kde"
.   .   }
.   .   'e' [1,'a'] {
.   .   .   'a': "kea"
.   .   }
.   .   'h' [1,'q'] {
.   .   .   'q': "khq"
.   .   }
.   .   'i': "ki"
.   .   'k': "kk" [1,'j'] {
.   .   .   'j': "kkj"
.   .   }
.   .   'l': "kl" [1,'n'] {
.   .   .   'n': "kln"
.   .   }
.   .   'm': "km"
.   .   'n': "kn"
.   .   'o': "ko" [1,'k'] {
.   .   .   'k': "kok"
.   .   }
.   .   's' [3,'h'] {
.   .   .   'b': "ksb"
.   .   .   'f': "ksf"
.   .   .   'h': "ksh"
.   .   }
.   .   'w': "kw"
.   .   'y': "ky"
.   }
.   'l' [8,'v'] {
.   .   'a' [1,'g'] {
.   .   .   'g': "lag"
.   .   }
.   .   'g': "lg"
.   .   'k' [1,'t'] {
.   .   .   't': "lkt"
.   .   }
.   .   'n': "ln"
.   .   'o': "lo"
.   .   't': "lt"
.   .   'u': "lu" [2,'y'] {
.   .   .   'o': "luo"
.   .   .   'y': "luy"
.   .   }
.   .   'v': "lv"
.   }
.   'm' [12,'y'] {
.   .   'a' [1,'s'] {
.   .   .   's': "mas"
.   .   }
.   .   'e' [1,'r'] {
.   .   .   'r': "mer"
.   .   }
.   .   'f' [1,'e'] {
.   .   .   'e': "mfe"
.   .   }
.   .   'g': "mg" [2,'o'] {
.   .   .   'h': "mgh"
.   .   .   'o': "mgo"
.   .   }
.   .   'k': "mk"
.   .   'l': "ml"
.   .   'n': "mn"
.   .   'r': "mr"
.   .   's': "ms"
.   .   't': "mt"
.   .   'u' [1,'a'] {
.   .   .   'a': "mua"
.   .   }
.   .   'y': "my"
.   }
.   'n' [11,'y'] {
.   .   'a' [1,'q'] {
.   .   .   'q': "naq"
.   .   }
.   .   'b': "nb"
.   .   'd': "nd"
.   .   'e': "ne"
.   .   'l': "nl"
.   .   'm' [1,'g'] {
.   .   .   'g': "nmg"
.   .   }
.   .   'n': "nn" [1,'h'] {
.   .   .   'h': "nnh"
.   .   }
.   .   'r': "nr"
.   .   's' [1,'o'] {
.   .   .   'o': "nso"
.   .   }
.   .   'u' [1,'s'] {
.   .   .   's': "nus"
.   .   }
.   .   'y' [1,'n'] {
.   .   .   'n': "nyn"
.   .   }
.   }
.   'o' [3,'s'] {
.   .   'm': "om"
.   .   'r': "or"
.   .   's': "os"
.   }
.   'p' [4,'t'] {
.   .   'a': "pa" [1,'_'] {
.   .   .   '_' [1,'A'] {
.   .   .   .   'A' [1,'r'] {
.   .   .   .   .   'r' [1,'a'] {
.   .   .   .   .   .   'a' [1,'b'] {
.   .   .   .   .   .   .   'b': "pa_Arab"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'l': "pl"
.   .   's': "ps"
.   .   't': "pt"
.   }
.   'r' [5,'w'] {
.   .   'm': "rm"
.   .   'n': "rn"
.   .   'o': "ro" [1,'f'] {
.   .   .   'f': "rof"
.   .   }
.   .   'u': "ru"
.   .   'w': "rw" [1,'k'] {
.   .   .   'k': "rwk"
.   .   }
.   }
.   's' [16,'w'] {
.   .   'a' [2,'q'] {
.   .   .   'h': "sah"
.   .   .   'q': "saq"
.   .   }
.   .   'b' [1,'p'] {
.   .   .   'p': "sbp"
.   .   }
.   .   'e': "se" [2,'s'] {
.   .   .   'h': "seh"
.   .   .   's': "ses"
.   .   }
.   .   'g': "sg"
.   .   'h' [1,'i'] {
.   .   .   'i': "shi" [1,'_'] {
.   .   .   .   '_' [1,'L'] {
.   .   .   .   .   'L' [1,'a'] {
.   .   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   .   't' [1,'n'] {
.   .   .   .   .   .   .   .   'n': "shi_Latn"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'i': "si"
.   .   'k': "sk"
.   .   'l': "sl"
.   .   'n': "sn"
.   .   'o': "so"
.   .   'q': "sq"
.   .   'r': "sr" [1,'_'] {
.   .   .   '_' [1,'L'] {
.   .   .   .   'L' [1,'a'] {
.   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   't' [1,'n'] {
.   .   .   .   .   .   .   'n': "sr_Latn"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   's': "ss" [1,'y'] {
.   .   .   'y': "ssy"
.   .   }
.   .   't': "st"
.   .   'v': "sv"
.   .   'w': "sw" [1,'c'] {
.   .   .   'c': "swc"
.   .   }
.   }
.   't' [11,'z'] {
.   .   'a': "ta"
.   .   'e': "te" [1,'o'] {
.   .   .   'o': "teo"
.   .   }
.   .   'g': "tg"
.   .   'h': "th"
.   .   'i': "ti" [2,'g'] {
.   .   .   '_' [1,'E'] {
.   .   .   .   'E' [1,'R'] {
.   .   .   .   .   'R': "ti_ER"
.   .   .   .   }
.   .   .   }
.   .   .   'g': "tig"
.   .   }
.   .   'n': "tn"
.   .   'o': "to"
.   .   'r': "tr"
.   .   's': "ts"
.   .   'w' [1,'q'] {
.   .   .   'q': "twq"
.   .   }
.   .   'z' [1,'m'] {
.   .   .   'm': "tzm"
.   .   }
.   }
.   'u' [4,'z'] {
.   .   'g': "ug"
.   .   'k': "uk"
.   .   'r': "ur"
.   .   'z': "uz" [1,'_'] {
.   .   .   '_' [2,'C'] {
.   .   .   .   'A' [1,'r'] {
.   .   .   .   .   'r' [1,'a'] {
.   .   .   .   .   .   'a' [1,'b'] {
.   .   .   .   .   .   .   'b': "uz_Arab"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   'C' [1,'y'] {
.   .   .   .   .   'y' [1,'r'] {
.   .   .   .   .   .   'r' [1,'l'] {
.   .   .   .   .   .   .   'l': "uz_Cyrl"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'v' [5,'u'] {
.   .   'a' [1,'i'] {
.   .   .   'i' [1,'_'] {
.   .   .   .   '_' [1,'L'] {
.   .   .   .   .   'L' [1,'a'] {
.   .   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   .   't' [1,'n'] {
.   .   .   .   .   .   .   .   'n': "vai_Latn"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'e': "ve"
.   .   'i': "vi"
.   .   'o': "vo"
.   .   'u' [1,'n'] {
.   .   .   'n': "vun"
.   .   }
.   }
.   'w' [1,'a'] {
.   .   'a' [2,'l'] {
.   .   .   'e': "wae"
.   .   .   'l': "wal"
.   .   }
.   }
.   'x' [2,'o'] {
.   .   'h': "xh"
.   .   'o' [1,'g'] {
.   .   .   'g': "xog"
.   .   }
.   }
.   'y' [2,'o'] {
.   .   'a' [1,'v'] {
.   .   .   'v': "yav"
.   .   }
.   .   'o': "yo" [1,'_'] {
.   .   .   '_' [1,'B'] {
.   .   .   .   'B' [1,'J'] {
.   .   .   .   .   'J': "yo_BJ"
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'z' [3,'u'] {
.   .   'g' [1,'h'] {
.   .   .   'h': "zgh"
.   .   }
.   .   'h': "zh" [1,'_'] {
.   .   .   '_' [1,'H'] {
.   .   .   .   'H' [1,'a'] {
.   .   .   .   .   'a' [1,'n'] {
.   .   .   .   .   .   'n' [1,'t'] {
.   .   .   .   .   .   .   't': "zh_Hant"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'u': "zu"
.   }
}
$

--[ print-obj-alphabets-ternary ]-----------------------------------------------

$ ../src/trie --attrs --dots --output=object --trie=ternary < alphabets.txt
[25,'z']
[8,'z'] {
.   .ch: 'a'
.   .eq [0] {
.   .   .ch: 'a'
.   .   .eq [0] {
.   .   .   .val: "aa"
.   .   }
.   .   .hi [0] {
.   .   .   .ch: 'f'
.   .   .   .eq [0] {
.   .   .   .   .val: "af"
.   .   .   }
.   .   .   .hi [1,'q'] {
.   .   .   .   .ch: 'g'
.   .   .   .   .eq [0] {
.   .   .   .   .   .ch: 'q'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "agq"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   .hi [0] {
.   .   .   .   .   .ch: 'k'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "ak"
.   .   .   .   .   }
.   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "am"
.   .   .   .   .   .   }
.   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .val: "ar"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .hi [2,'t'] {
.   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .val: "as"
.   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "asa"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "ast"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .hi [1,'_'] {
.   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .val: "az"
.   .   .   .   .   .   .   .   .   .   .hi [1,'C'] {
.   .   .   .   .   .   .   .   .   .   .   .ch: '_'
.   .   .   .   .   .   .   .   .   .   .   .eq [1,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'C'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "az_Cyrl"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   .hi [9,'y'] {
.   .   .ch: 'b'
.   .   .eq [1,'s'] {
.   .   .   .ch: 'a'
.   .   .   .eq [0] {
.   .   .   .   .ch: 's'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "bas"
.   .   .   .   }
.   .   .   }
.   .   .   .hi [2,'z'] {
.   .   .   .   .ch: 'e'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "be"
.   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "bem"
.   .   .   .   .   .   }
.   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .val: "bez"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   .hi [0] {
.   .   .   .   .   .ch: 'g'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "bg"
.   .   .   .   .   }
.   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "bm"
.   .   .   .   .   .   }
.   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .val: "bn"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .val: "bo"
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .hi [1,'x'] {
.   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .val: "br"
.   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "brx"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .hi [1,'_'] {
.   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "bs"
.   .   .   .   .   .   .   .   .   .   .   .hi [1,'C'] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: '_'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'C'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "bs_Cyrl"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .hi [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: "byn"
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   .hi [5,'y'] {
.   .   .   .ch: 'c'
.   .   .   .eq [0] {
.   .   .   .   .ch: 'a'
.   .   .   .   .eq [0] {
.   .   .   .   .   .val: "ca"
.   .   .   .   }
.   .   .   .   .hi [1,'g'] {
.   .   .   .   .   .ch: 'g'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "cgg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   .hi [1,'r'] {
.   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .val: "chr"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .val: "cs"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .val: "cy"
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   .hi [6,'z'] {
.   .   .   .   .ch: 'd'
.   .   .   .   .eq [1,'v'] {
.   .   .   .   .   .ch: 'a'
.   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .val: "da"
.   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .ch: 'v'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .val: "dav"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .val: "de"
.   .   .   .   .   .   }
.   .   .   .   .   .   .hi [1,'e'] {
.   .   .   .   .   .   .   .ch: 'j'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .val: "dje"
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .hi [1,'a'] {
.   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .val: "dua"
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .hi [1,'o'] {
.   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "dyo"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "dz"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   .hi [9,'w'] {
.   .   .   .   .   .ch: 'e'
.   .   .   .   .   .eq [1,'u'] {
.   .   .   .   .   .   .ch: 'b'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .val: "ebu"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .val: "ee"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .val: "el"
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .val: "en"
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "eo"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "es"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: "et"
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "eu"
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'w'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ewo"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   .hi [7,'y'] {
.   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .val: "fa"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .val: "ff"
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .hi [1,'l'] {
.   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .val: "fi"
.   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "fil"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "fo"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "fr"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .hi [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "fur"
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "fy"
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   .hi [6,'v'] {
.   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .val: "ga"
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .val: "gd"
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "gl"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .hi [1,'w'] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'w'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: "gsw"
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .hi [1,'z'] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: "gu"
.   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "guz"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'v'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "gv"
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .hi [6,'y'] {
.   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .eq [1,'w'] {
.   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .val: "ha"
.   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'w'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "haw"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "he"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "hi"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: "hr"
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "hu"
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "hy"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .hi [6,'t'] {
.   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .val: "ia"
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "id"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ig"
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ii"
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "is"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "it"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .hi [3,'m'] {
.   .   .   .   .   .   .   .   .   .   .ch: 'j'
.   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .val: "ja"
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .hi [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "jgo"
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'c'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "jmc"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .hi [13,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .   .   .   .   .   .eq [2,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ka"
.   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'b'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kab"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kam"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kde"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kea"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'q'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'q'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "khq"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ki"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'j'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kk"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'j'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kkj"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kl"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kln"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "km"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kn"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'k'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ko"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kok"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [3,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'b'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ksb"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ksf"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ksh"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'w'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "kw"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ky"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .hi [8,'v'] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'g'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "lag"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "lg"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "lkt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ln"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "lo"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "lt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [2,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "lu"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "luo"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "luy"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'v'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "lv"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .hi [12,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mas"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mer"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mfe"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [2,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mg"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mgh"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mgo"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mk"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ml"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mn"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mr"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ms"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "mua"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "my"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .hi [11,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'q'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'q'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "naq"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'b'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "nb"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "nd"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ne"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "nl"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'g'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "nmg"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "nn"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "nnh"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "nr"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "nso"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "nus"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "nyn"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [3,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "om"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "or"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "os"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [4,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'p'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'_'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "pa"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'A'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '_'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'A'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'b'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'b'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "pa_Arab"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "pl"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ps"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "pt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [5,'w'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "rm"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "rn"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ro"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "rof"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ru"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'k'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'w'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "rw"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "rwk"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [16,'w'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [2,'q'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sah"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'q'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "saq"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'p'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'b'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'p'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sbp"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [2,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "se"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "seh"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ses"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sg"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'_'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "shi"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'L'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '_'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'L'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "shi_Latn"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "si"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sk"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sl"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sn"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "so"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'q'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sq"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'_'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sr"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'L'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '_'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'L'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sr_Latn"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ss"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ssy"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "st"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'v'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sv"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'w'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "sw"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'c'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "swc"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [11,'z'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ta"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "te"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "teo"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "tg"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "th"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [2,'g'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ti"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'E'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '_'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'R'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'E'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'R'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ti_ER"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "tig"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "tn"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "to"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "tr"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ts"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'q'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'w'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'q'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "twq"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "tzm"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [4,'z'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ug"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "uk"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ur"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'_'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "uz"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [2,'C'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '_'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'A'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'b'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'b'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "uz_Arab"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'C'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "uz_Cyrl"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [5,'u'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'v'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'_'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'L'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '_'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'L'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "vai_Latn"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "ve"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "vi"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "vo"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "vun"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'w'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [2,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "wae"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "wal"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [2,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "xh"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'g'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "xog"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [2,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'v'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'v'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "yav"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'_'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "yo"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'B'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '_'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'J'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'B'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'J'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "yo_BJ"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [3,'u'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'z'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'g'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "zgh"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'_'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "zh"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'H'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '_'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'H'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "zh_Hant"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "zu"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$

--[ print-obj-filenames-array ]-------------------------------------------------

$ ../src/trie --attrs --dots --output=object --trie=array < filenames.txt
[1,'c'] {
.   'c' [1,'+'] {
.   .   '+' [1,'+'] {
.   .   .   '+' [1,'p'] {
.   .   .   .   'p' [1,'y'] {
.   .   .   .   .   'y' [1,'-'] {
.   .   .   .   .   .   '-' [1,'t'] {
.   .   .   .   .   .   .   't' [1,'r'] {
.   .   .   .   .   .   .   .   'r' [1,'e'] {
.   .   .   .   .   .   .   .   .   'e' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   'e' [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   '-' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   'm' [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'o' [1,'/'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '/' [3,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [2,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/.src-dirs"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'l' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/.src-files"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'b' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'n' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'p'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'h': "c++py-tree-demo/bin.patch"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'+'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '+' [1,'+'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '+' [1,'p'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'y' [2,'/'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [2,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [3,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'u'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'u' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'h' [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'o' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree-author.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'm' [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'o' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree-demo.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'm' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [2,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f': "c++py-tree-demo/c++py-tree-readme.pdf"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [2,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x': "c++py-tree-demo/c++py-tree-readme.tex"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree-readme.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [2,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f': "c++py-tree-demo/c++py-tree.pdf"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [2,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x': "c++py-tree-demo/c++py-tree.tex"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '/' [4,'R'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [2,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/c++py/.src-dirs"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'l' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/c++py/.src-files"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'A' [1,'U'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'U' [1,'T'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'T' [1,'H'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'H' [1,'O'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'O' [1,'R'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'R': "c++py-tree-demo/c++py/AUTHOR"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'M' [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'k'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'k' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'l' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e': "c++py-tree-demo/c++py/Makefile"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'R' [1,'E'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'E' [1,'A'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'A' [1,'D'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'D' [1,'M'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'M' [1,'E'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'E': "c++py-tree-demo/c++py/README"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$

--[ print-obj-filenames-ternary ]-----------------------------------------------

$ ../src/trie --attrs --dots --output=object --trie=ternary < filenames.txt
[1,'c']
[1,'+'] {
.   .ch: 'c'
.   .eq [1,'+'] {
.   .   .ch: '+'
.   .   .eq [1,'p'] {
.   .   .   .ch: '+'
.   .   .   .eq [1,'y'] {
.   .   .   .   .ch: 'p'
.   .   .   .   .eq [1,'-'] {
.   .   .   .   .   .ch: 'y'
.   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .ch: '-'
.   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .eq [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .eq [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .ch: '-'
.   .   .   .   .   .   .   .   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'/'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [3,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '/'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '.'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'c'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [2,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '-'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/.src-dirs"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/.src-files"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'b'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'n'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'p'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '.'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'p'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'c'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/bin.patch"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'+'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'c'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'+'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '+'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'p'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '+'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'p'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [2,'/'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'y'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '-'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [2,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [3,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '-'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'u'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'u'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'h'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '.'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py-tree-author.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'o'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '.'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py-tree-demo.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'm'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [2,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '.'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'p'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py-tree-readme.pdf"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [2,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py-tree-readme.tex"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py-tree-readme.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [2,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '.'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'p'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py-tree.pdf"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [2,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py-tree.tex"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'x'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 't'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py-tree.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [4,'R'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '/'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '.'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'c'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [2,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: '-'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'd'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'r'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py/.src-dirs"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 's'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py/.src-files"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'U'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'A'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'T'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'U'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'H'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'T'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'O'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'H'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'R'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'O'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'R'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py/AUTHOR"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'M'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'k'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'a'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'k'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'f'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'i'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'l'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'e'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py/Makefile"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .hi [1,'E'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'R'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'A'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'E'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'D'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'A'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'M'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'D'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [1,'E'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'M'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .ch: 'E'
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .eq [0] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .val: "c++py-tree-demo/c++py/README"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$

--[ gen-wide-c-code-base0-array ]-----------------------------------------------

$ trie() { ../src/trie --gen=wide --output=c-code --trie=array "$@"; }
$ print a|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
    }
    return error;
$ print a ab|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
    }
    return error;
$ print a ab abc|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "abc";
            }
        }
    }
    return error;
$ print a b|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        if (*p == 0)
            return "b";
    }
    return error;
$ print a b abc bac abd|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
            }
        }
        return error;
    case 'b':
        if (*p == 0)
            return "b";
        if (*p ++ == 'a') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "bac";
            }
        }
    }
    return error;
$ print a bb ba c|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print a bb ba cc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p == 0)
                return "cc";
        }
    }
    return error;
$ print a bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print a bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
            }
        }
    }
    return error;
$ print a bb ba cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                }
            }
        }
    }
    return error;
$ print a bb ba cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p == 0)
                            return "cdefg";
                    }
                }
            }
        }
    }
    return error;
$ print a bb bac cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "bac";
            }
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                }
            }
        }
    }
    return error;
$ print a bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x') {
                if (*p == 0)
                    return "bbx";
            }
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print a bbx bay ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'y') {
                if (*p == 0)
                    return "bay";
            }
            return error;
        case 'b':
            if (*p ++ == 'x') {
                if (*p == 0)
                    return "bbx";
            }
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print a cde cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                }
            }
        }
    }
    return error;
$ print a cde cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p == 0)
                            return "cdefg";
                    }
                }
            }
        }
    }
    return error;
$ print a cde cdef cdefgh|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p ++ == 'h') {
                            if (*p == 0)
                                return "cdefgh";
                        }
                    }
                }
            }
        }
    }
    return error;
$ print a cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p == 0)
                            return "cdefg";
                    }
                }
            }
        }
    }
    return error;
$ print ab|trie
    if (*p ++ == 'a') {
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
    }
    return error;
$ print ab bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print ab bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
            }
        }
    }
    return error;
$ print ab bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x') {
                if (*p == 0)
                    return "bbx";
            }
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print ab c|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print abc bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "abc";
            }
        }
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print abcd abde abef|trie
    if (*p ++ == 'a') {
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p ++ == 'd') {
                    if (*p == 0)
                        return "abcd";
                }
                return error;
            case 'd':
                if (*p ++ == 'e') {
                    if (*p == 0)
                        return "abde";
                }
                return error;
            case 'e':
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "abef";
                }
            }
        }
    }
    return error;
$ print abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
        }
    }
    return error;
$ print ac ab|trie
    if (*p ++ == 'a') {
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            return error;
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print aef ae abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ae";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "aef";
            }
        }
    }
    return error;
$ print cde cdef cdefgh|trie
    if (*p ++ == 'c') {
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p ++ == 'h') {
                            if (*p == 0)
                                return "cdefgh";
                        }
                    }
                }
            }
        }
    }
    return error;
$ print cdef cdefg|trie
    if (*p ++ == 'c') {
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p == 0)
                            return "cdefg";
                    }
                }
            }
        }
    }
    return error;
$ print cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        if (*p ++ == 'd') {
            switch (*p ++) {
            case 'e':
                if (*p ++ == 'x') {
                    if (*p == 0)
                        return "cdex";
                }
                return error;
            case 'f':
                if (*p ++ == 'y') {
                    if (*p == 0)
                        return "cdfy";
                }
                return error;
            case 'g':
                if (*p ++ == 'z') {
                    if (*p == 0)
                        return "cdgz";
                }
                return error;
            case 'h':
                if (*p ++ == 'w') {
                    if (*p == 0)
                        return "cdhw";
                }
            }
        }
    }
    return error;
$ print ce cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        switch (*p ++) {
        case 'd':
            switch (*p ++) {
            case 'e':
                if (*p ++ == 'x') {
                    if (*p == 0)
                        return "cdex";
                }
                return error;
            case 'f':
                if (*p ++ == 'y') {
                    if (*p == 0)
                        return "cdfy";
                }
                return error;
            case 'g':
                if (*p ++ == 'z') {
                    if (*p == 0)
                        return "cdgz";
                }
                return error;
            case 'h':
                if (*p ++ == 'w') {
                    if (*p == 0)
                        return "cdhw";
                }
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ce";
        }
    }
    return error;
$ print pot potato pottery tattoo tempo|trie
    switch (*p ++) {
    case 'p':
        if (*p ++ == 'o') {
            if (*p ++ == 't') {
                if (*p == 0)
                    return "pot";
                switch (*p ++) {
                case 'a':
                    if (*p ++ == 't') {
                        if (*p ++ == 'o') {
                            if (*p == 0)
                                return "potato";
                        }
                    }
                    return error;
                case 't':
                    if (*p ++ == 'e') {
                        if (*p ++ == 'r') {
                            if (*p ++ == 'y') {
                                if (*p == 0)
                                    return "pottery";
                            }
                        }
                    }
                }
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 't') {
                if (*p ++ == 't') {
                    if (*p ++ == 'o') {
                        if (*p ++ == 'o') {
                            if (*p == 0)
                                return "tattoo";
                        }
                    }
                }
            }
            return error;
        case 'e':
            if (*p ++ == 'm') {
                if (*p ++ == 'p') {
                    if (*p ++ == 'o') {
                        if (*p == 0)
                            return "tempo";
                    }
                }
            }
        }
    }
    return error;
$

--[ gen-wide-c-code-base0-ternary ]---------------------------------------------

$ trie() { ../src/trie --gen=wide --output=c-code --trie=ternary "$@"; }
$ print a|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
    }
    return error;
$ print a ab|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
    }
    return error;
$ print a ab abc|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "abc";
            }
        }
    }
    return error;
$ print a b|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        if (*p == 0)
            return "b";
    }
    return error;
$ print a b abc bac abd|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
            }
        }
        return error;
    case 'b':
        if (*p == 0)
            return "b";
        if (*p ++ == 'a') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "bac";
            }
        }
    }
    return error;
$ print a bb ba c|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print a bb ba cc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p == 0)
                return "cc";
        }
    }
    return error;
$ print a bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print a bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
            }
        }
    }
    return error;
$ print a bb ba cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                }
            }
        }
    }
    return error;
$ print a bb ba cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p == 0)
                            return "cdefg";
                    }
                }
            }
        }
    }
    return error;
$ print a bb bac cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "bac";
            }
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                }
            }
        }
    }
    return error;
$ print a bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x') {
                if (*p == 0)
                    return "bbx";
            }
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print a bbx bay ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'y') {
                if (*p == 0)
                    return "bay";
            }
            return error;
        case 'b':
            if (*p ++ == 'x') {
                if (*p == 0)
                    return "bbx";
            }
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print a cde cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                }
            }
        }
    }
    return error;
$ print a cde cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p == 0)
                            return "cdefg";
                    }
                }
            }
        }
    }
    return error;
$ print a cde cdef cdefgh|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p ++ == 'h') {
                            if (*p == 0)
                                return "cdefgh";
                        }
                    }
                }
            }
        }
    }
    return error;
$ print a cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p == 0)
                            return "cdefg";
                    }
                }
            }
        }
    }
    return error;
$ print ab|trie
    if (*p ++ == 'a') {
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
    }
    return error;
$ print ab bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print ab bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
            }
        }
    }
    return error;
$ print ab bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x') {
                if (*p == 0)
                    return "bbx";
            }
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print ab c|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print abc bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "abc";
            }
        }
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c') {
            if (*p ++ == 'c') {
                if (*p == 0)
                    return "ccc";
            }
        }
    }
    return error;
$ print abcd abde abef|trie
    if (*p ++ == 'a') {
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p ++ == 'd') {
                    if (*p == 0)
                        return "abcd";
                }
                return error;
            case 'd':
                if (*p ++ == 'e') {
                    if (*p == 0)
                        return "abde";
                }
                return error;
            case 'e':
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "abef";
                }
            }
        }
    }
    return error;
$ print abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
        }
    }
    return error;
$ print ac ab|trie
    if (*p ++ == 'a') {
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            return error;
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print aef ae abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ae";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "aef";
            }
        }
    }
    return error;
$ print cde cdef cdefgh|trie
    if (*p ++ == 'c') {
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p == 0)
                    return "cde";
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p ++ == 'h') {
                            if (*p == 0)
                                return "cdefgh";
                        }
                    }
                }
            }
        }
    }
    return error;
$ print cdef cdefg|trie
    if (*p ++ == 'c') {
        if (*p ++ == 'd') {
            if (*p ++ == 'e') {
                if (*p ++ == 'f') {
                    if (*p == 0)
                        return "cdef";
                    if (*p ++ == 'g') {
                        if (*p == 0)
                            return "cdefg";
                    }
                }
            }
        }
    }
    return error;
$ print cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        if (*p ++ == 'd') {
            switch (*p ++) {
            case 'e':
                if (*p ++ == 'x') {
                    if (*p == 0)
                        return "cdex";
                }
                return error;
            case 'f':
                if (*p ++ == 'y') {
                    if (*p == 0)
                        return "cdfy";
                }
                return error;
            case 'g':
                if (*p ++ == 'z') {
                    if (*p == 0)
                        return "cdgz";
                }
                return error;
            case 'h':
                if (*p ++ == 'w') {
                    if (*p == 0)
                        return "cdhw";
                }
            }
        }
    }
    return error;
$ print ce cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        switch (*p ++) {
        case 'd':
            switch (*p ++) {
            case 'e':
                if (*p ++ == 'x') {
                    if (*p == 0)
                        return "cdex";
                }
                return error;
            case 'f':
                if (*p ++ == 'y') {
                    if (*p == 0)
                        return "cdfy";
                }
                return error;
            case 'g':
                if (*p ++ == 'z') {
                    if (*p == 0)
                        return "cdgz";
                }
                return error;
            case 'h':
                if (*p ++ == 'w') {
                    if (*p == 0)
                        return "cdhw";
                }
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ce";
        }
    }
    return error;
$ print pot potato pottery tattoo tempo|trie
    switch (*p ++) {
    case 'p':
        if (*p ++ == 'o') {
            if (*p ++ == 't') {
                if (*p == 0)
                    return "pot";
                switch (*p ++) {
                case 'a':
                    if (*p ++ == 't') {
                        if (*p ++ == 'o') {
                            if (*p == 0)
                                return "potato";
                        }
                    }
                    return error;
                case 't':
                    if (*p ++ == 'e') {
                        if (*p ++ == 'r') {
                            if (*p ++ == 'y') {
                                if (*p == 0)
                                    return "pottery";
                            }
                        }
                    }
                }
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 't') {
                if (*p ++ == 't') {
                    if (*p ++ == 'o') {
                        if (*p ++ == 'o') {
                            if (*p == 0)
                                return "tattoo";
                        }
                    }
                }
            }
            return error;
        case 'e':
            if (*p ++ == 'm') {
                if (*p ++ == 'p') {
                    if (*p ++ == 'o') {
                        if (*p == 0)
                            return "tempo";
                    }
                }
            }
        }
    }
    return error;
$

--[ gen-wide-c-code-base ]------------------------------------------------------

$ trie() { ../src/trie --gen=wide --output=c-code --attrs --no-dots "$@"; }
$ print a ab abc abd ac|trie
    // [1,'a']
    // 'a' [2,'c']
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        // 'b' [2,'d']
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            // 'c' [0]
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            // 'd' [0]
            case 'd':
                if (*p == 0)
                    return "abd";
            }
            return error;
        // 'c' [0]
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print a ab abc abd ac|trie -t int
    // [1,'a']
    // 'a' [2,'c']
    if (*p ++ == 'a') {
        if (*p == 0)
            return 1;
        switch (*p ++) {
        // 'b' [2,'d']
        case 'b':
            if (*p == 0)
                return 2;
            switch (*p ++) {
            // 'c' [0]
            case 'c':
                if (*p == 0)
                    return 3;
                return error;
            // 'd' [0]
            case 'd':
                if (*p == 0)
                    return 4;
            }
            return error;
        // 'c' [0]
        case 'c':
            if (*p == 0)
                return 5;
        }
    }
    return error;
$ print a ab abc abd ac|trie -t float
    // [1,'a']
    // 'a' [2,'c']
    if (*p ++ == 'a') {
        if (*p == 0)
            return 1.0;
        switch (*p ++) {
        // 'b' [2,'d']
        case 'b':
            if (*p == 0)
                return 2.0;
            switch (*p ++) {
            // 'c' [0]
            case 'c':
                if (*p == 0)
                    return 3.0;
                return error;
            // 'd' [0]
            case 'd':
                if (*p == 0)
                    return 4.0;
            }
            return error;
        // 'c' [0]
        case 'c':
            if (*p == 0)
                return 5.0;
        }
    }
    return error;
$

--[ gen-wide-c-code-base-array ]------------------------------------------------

$ trie() { ../src/trie --gen=wide --output=c-code --attrs --dots --trie=array "$@"; }
$ print|trie 
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
.   // [1,'a']
.   // 'a' [0]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   }
.   return error;
$ print a b|trie
.   // [2,'b']
.   switch (*p ++) {
.   // 'a' [0]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // 'b' [0]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   }
.   return error;
$ print a b c|trie
.   // [3,'c']
.   switch (*p ++) {
.   // 'a' [0]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // 'b' [0]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   .   return error;
.   // 'c' [0]
.   case 'c':
.   .   if (*p == 0)
.   .   .   return "c";
.   }
.   return error;
$ print a ab abc|trie
.   // [1,'a']
.   // 'a' [1,'b']
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // 'b' [1,'c']
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   }
.   .   }
.   }
.   return error;
$ print a ab ac|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // 'c' [0]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac ad|trie
.   // [1,'a']
.   // 'a' [3,'d']
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // 'c' [0]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   return error;
.   .   // 'd' [0]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "ad";
.   .   }
.   }
.   return error;
$ print a abd ac|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // 'b' [1,'d']
.   .   case 'b':
.   .   .   // 'd' [0]
.   .   .   if (*p ++ == 'd') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // 'c' [0]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac acd|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // 'c' [1,'d']
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // 'd' [0]
.   .   .   if (*p ++ == 'd') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "acd";
.   .   .   }
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // 'a' [0]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // 'b' [2,'b']
.   case 'b':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // 'c' [1,'c']
.   case 'c':
.   .   // 'c' [1,'c']
.   .   if (*p ++ == 'c') {
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ccc";
.   .   .   }
.   .   }
.   }
.   return error;
$ print a bb ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // 'a' [0]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // 'b' [1,'b']
.   case 'b':
.   .   // 'b' [0]
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // 'c' [1,'c']
.   case 'c':
.   .   // 'c' [1,'c']
.   .   if (*p ++ == 'c') {
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ccc";
.   .   .   }
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // 'a' [0]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // 'b' [2,'b']
.   case 'b':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // 'c' [1,'c']
.   case 'c':
.   .   // 'c' [1,'c']
.   .   if (*p ++ == 'c') {
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ccc";
.   .   .   }
.   .   }
.   }
.   return error;
$ print abc abd acde|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // 'b' [2,'d']
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // 'c' [0]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // 'd' [0]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // 'c' [1,'d']
.   .   case 'c':
.   .   .   // 'd' [1,'e']
.   .   .   if (*p ++ == 'd') {
.   .   .   .   // 'e' [0]
.   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "acde";
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print abc abd acde ac|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // 'b' [2,'d']
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // 'c' [0]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // 'd' [0]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // 'c' [1,'d']
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // 'd' [1,'e']
.   .   .   if (*p ++ == 'd') {
.   .   .   .   // 'e' [0]
.   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "acde";
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print abc abd acde acfg|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // 'b' [2,'d']
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // 'c' [0]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // 'd' [0]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // 'c' [2,'f']
.   .   case 'c':
.   .   .   switch (*p ++) {
.   .   .   // 'd' [1,'e']
.   .   .   case 'd':
.   .   .   .   // 'e' [0]
.   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "acde";
.   .   .   .   }
.   .   .   .   return error;
.   .   .   // 'f' [1,'g']
.   .   .   case 'f':
.   .   .   .   // 'g' [0]
.   .   .   .   if (*p ++ == 'g') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "acfg";
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // 'c' [2,'f']
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // 'd' [1,'e']
.   .   case 'd':
.   .   .   // 'e' [0]
.   .   .   if (*p ++ == 'e') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cde";
.   .   .   }
.   .   .   return error;
.   .   // 'f' [1,'g']
.   .   case 'f':
.   .   .   // 'g' [1,'x']
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // 'x' [2,'z']
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // 'y' [1,'z']
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // 'z' [1,'z']
.   .   .   .   .   case 'z':
.   .   .   .   .   .   // 'z' [1,'z']
.   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // 'c' [2,'g']
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // 'f' [1,'g']
.   .   case 'f':
.   .   .   // 'g' [1,'x']
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // 'x' [2,'z']
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // 'y' [1,'z']
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // 'z' [1,'z']
.   .   .   .   .   case 'z':
.   .   .   .   .   .   // 'z' [1,'z']
.   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'g' [1,'e']
.   .   case 'g':
.   .   .   // 'e' [0]
.   .   .   if (*p ++ == 'e') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cge";
.   .   .   }
.   .   }
.   }
.   return error;
$ print a abcd abcdefg h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // 'a' [1,'b']
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // 'b' [1,'c']
.   .   if (*p ++ == 'b') {
.   .   .   // 'c' [1,'d']
.   .   .   if (*p ++ == 'c') {
.   .   .   .   // 'd' [1,'e']
.   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "abcd";
.   .   .   .   .   // 'e' [1,'f']
.   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   // 'f' [1,'g']
.   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   // 'g' [0]
.   .   .   .   .   .   .   if (*p ++ == 'g') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "abcdefg";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'h' [1,'i']
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // 'i' [1,'j']
.   .   if (*p ++ == 'i') {
.   .   .   // 'j' [1,'k']
.   .   .   if (*p ++ == 'j') {
.   .   .   .   // 'k' [0]
.   .   .   .   if (*p ++ == 'k') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "hijk";
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // 'a' [1,'b']
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // 'b' [1,'c']
.   .   if (*p ++ == 'b') {
.   .   .   // 'c' [1,'d']
.   .   .   if (*p ++ == 'c') {
.   .   .   .   // 'd' [2,'x']
.   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "abcd";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // 'e' [1,'f']
.   .   .   .   .   case 'e':
.   .   .   .   .   .   // 'f' [1,'g']
.   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   // 'g' [0]
.   .   .   .   .   .   .   if (*p ++ == 'g') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "abcdefg";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // 'x' [1,'y']
.   .   .   .   .   case 'x':
.   .   .   .   .   .   // 'y' [1,'z']
.   .   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "abcdxyz";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'h' [1,'i']
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // 'i' [1,'j']
.   .   if (*p ++ == 'i') {
.   .   .   // 'j' [1,'k']
.   .   .   if (*p ++ == 'j') {
.   .   .   .   // 'k' [0]
.   .   .   .   if (*p ++ == 'k') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "hijk";
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
.   // [2,'h']
.   switch (*p ++) {
.   // 'a' [1,'b']
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // 'b' [1,'c']
.   .   if (*p ++ == 'b') {
.   .   .   // 'c' [1,'d']
.   .   .   if (*p ++ == 'c') {
.   .   .   .   // 'd' [2,'x']
.   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "abcd";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // 'e' [1,'f']
.   .   .   .   .   case 'e':
.   .   .   .   .   .   // 'f' [1,'g']
.   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   // 'g' [0]
.   .   .   .   .   .   .   if (*p ++ == 'g') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "abcdefg";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // 'x' [1,'y']
.   .   .   .   .   case 'x':
.   .   .   .   .   .   // 'y' [1,'z']
.   .   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "abcdxyz";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'h' [2,'l']
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   switch (*p ++) {
.   .   // 'i' [1,'j']
.   .   case 'i':
.   .   .   // 'j' [1,'k']
.   .   .   if (*p ++ == 'j') {
.   .   .   .   // 'k' [0]
.   .   .   .   if (*p ++ == 'k') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "hijk";
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'l' [1,'m']
.   .   case 'l':
.   .   .   // 'm' [0]
.   .   .   if (*p ++ == 'm') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "hlm";
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-wide-c-code-base-ternary ]----------------------------------------------

$ trie() { ../src/trie --gen=wide --output=c-code --attrs --dots --trie=ternary "$@"; }
$ print|trie 
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
.   // [1,'a']
.   // 'a' [0]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   }
.   return error;
$ print a b|trie
.   // [2,'b']
.   switch (*p ++) {
.   // 'a' [0]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // 'b' [0]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   }
.   return error;
$ print a b c|trie
.   // [3,'c']
.   switch (*p ++) {
.   // 'a' [0]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // 'b' [0]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   .   return error;
.   // 'c' [0]
.   case 'c':
.   .   if (*p == 0)
.   .   .   return "c";
.   }
.   return error;
$ print a ab abc|trie
.   // [1,'a']
.   // 'a' [1,'b']
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // 'b' [1,'c']
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   }
.   .   }
.   }
.   return error;
$ print a ab ac|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // 'c' [0]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac ad|trie
.   // [1,'a']
.   // 'a' [3,'d']
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // 'c' [0]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   return error;
.   .   // 'd' [0]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "ad";
.   .   }
.   }
.   return error;
$ print a abd ac|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // 'b' [1,'d']
.   .   case 'b':
.   .   .   // 'd' [0]
.   .   .   if (*p ++ == 'd') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // 'c' [0]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac acd|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // 'c' [1,'d']
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // 'd' [0]
.   .   .   if (*p ++ == 'd') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "acd";
.   .   .   }
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // 'a' [0]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // 'b' [2,'b']
.   case 'b':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // 'c' [1,'c']
.   case 'c':
.   .   // 'c' [1,'c']
.   .   if (*p ++ == 'c') {
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ccc";
.   .   .   }
.   .   }
.   }
.   return error;
$ print a bb ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // 'a' [0]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // 'b' [1,'b']
.   case 'b':
.   .   // 'b' [0]
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // 'c' [1,'c']
.   case 'c':
.   .   // 'c' [1,'c']
.   .   if (*p ++ == 'c') {
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ccc";
.   .   .   }
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // 'a' [0]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // 'b' [2,'b']
.   case 'b':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // 'c' [1,'c']
.   case 'c':
.   .   // 'c' [1,'c']
.   .   if (*p ++ == 'c') {
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ccc";
.   .   .   }
.   .   }
.   }
.   return error;
$ print abc abd acde|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // 'b' [2,'d']
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // 'c' [0]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // 'd' [0]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // 'c' [1,'d']
.   .   case 'c':
.   .   .   // 'd' [1,'e']
.   .   .   if (*p ++ == 'd') {
.   .   .   .   // 'e' [0]
.   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "acde";
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print abc abd acde ac|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // 'b' [2,'d']
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // 'c' [0]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // 'd' [0]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // 'c' [1,'d']
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // 'd' [1,'e']
.   .   .   if (*p ++ == 'd') {
.   .   .   .   // 'e' [0]
.   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "acde";
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print abc abd acde acfg|trie
.   // [1,'a']
.   // 'a' [2,'c']
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // 'b' [2,'d']
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // 'c' [0]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // 'd' [0]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // 'c' [2,'f']
.   .   case 'c':
.   .   .   switch (*p ++) {
.   .   .   // 'd' [1,'e']
.   .   .   case 'd':
.   .   .   .   // 'e' [0]
.   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "acde";
.   .   .   .   }
.   .   .   .   return error;
.   .   .   // 'f' [1,'g']
.   .   .   case 'f':
.   .   .   .   // 'g' [0]
.   .   .   .   if (*p ++ == 'g') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "acfg";
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // 'c' [2,'f']
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // 'd' [1,'e']
.   .   case 'd':
.   .   .   // 'e' [0]
.   .   .   if (*p ++ == 'e') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cde";
.   .   .   }
.   .   .   return error;
.   .   // 'f' [1,'g']
.   .   case 'f':
.   .   .   // 'g' [1,'x']
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // 'x' [2,'z']
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // 'y' [1,'z']
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // 'z' [1,'z']
.   .   .   .   .   case 'z':
.   .   .   .   .   .   // 'z' [1,'z']
.   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // 'c' [2,'g']
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // 'f' [1,'g']
.   .   case 'f':
.   .   .   // 'g' [1,'x']
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // 'x' [2,'z']
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // 'y' [1,'z']
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // 'z' [1,'z']
.   .   .   .   .   case 'z':
.   .   .   .   .   .   // 'z' [1,'z']
.   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'g' [1,'e']
.   .   case 'g':
.   .   .   // 'e' [0]
.   .   .   if (*p ++ == 'e') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cge";
.   .   .   }
.   .   }
.   }
.   return error;
$ print a abcd abcdefg h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // 'a' [1,'b']
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // 'b' [1,'c']
.   .   if (*p ++ == 'b') {
.   .   .   // 'c' [1,'d']
.   .   .   if (*p ++ == 'c') {
.   .   .   .   // 'd' [1,'e']
.   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "abcd";
.   .   .   .   .   // 'e' [1,'f']
.   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   // 'f' [1,'g']
.   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   // 'g' [0]
.   .   .   .   .   .   .   if (*p ++ == 'g') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "abcdefg";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'h' [1,'i']
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // 'i' [1,'j']
.   .   if (*p ++ == 'i') {
.   .   .   // 'j' [1,'k']
.   .   .   if (*p ++ == 'j') {
.   .   .   .   // 'k' [0]
.   .   .   .   if (*p ++ == 'k') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "hijk";
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // 'a' [1,'b']
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // 'b' [1,'c']
.   .   if (*p ++ == 'b') {
.   .   .   // 'c' [1,'d']
.   .   .   if (*p ++ == 'c') {
.   .   .   .   // 'd' [2,'x']
.   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "abcd";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // 'e' [1,'f']
.   .   .   .   .   case 'e':
.   .   .   .   .   .   // 'f' [1,'g']
.   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   // 'g' [0]
.   .   .   .   .   .   .   if (*p ++ == 'g') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "abcdefg";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // 'x' [1,'y']
.   .   .   .   .   case 'x':
.   .   .   .   .   .   // 'y' [1,'z']
.   .   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "abcdxyz";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'h' [1,'i']
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // 'i' [1,'j']
.   .   if (*p ++ == 'i') {
.   .   .   // 'j' [1,'k']
.   .   .   if (*p ++ == 'j') {
.   .   .   .   // 'k' [0]
.   .   .   .   if (*p ++ == 'k') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "hijk";
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
.   // [2,'h']
.   switch (*p ++) {
.   // 'a' [1,'b']
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // 'b' [1,'c']
.   .   if (*p ++ == 'b') {
.   .   .   // 'c' [1,'d']
.   .   .   if (*p ++ == 'c') {
.   .   .   .   // 'd' [2,'x']
.   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "abcd";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // 'e' [1,'f']
.   .   .   .   .   case 'e':
.   .   .   .   .   .   // 'f' [1,'g']
.   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   // 'g' [0]
.   .   .   .   .   .   .   if (*p ++ == 'g') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "abcdefg";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // 'x' [1,'y']
.   .   .   .   .   case 'x':
.   .   .   .   .   .   // 'y' [1,'z']
.   .   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   .   // 'z' [0]
.   .   .   .   .   .   .   if (*p ++ == 'z') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "abcdxyz";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'h' [2,'l']
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   switch (*p ++) {
.   .   // 'i' [1,'j']
.   .   case 'i':
.   .   .   // 'j' [1,'k']
.   .   .   if (*p ++ == 'j') {
.   .   .   .   // 'k' [0]
.   .   .   .   if (*p ++ == 'k') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "hijk";
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'l' [1,'m']
.   .   case 'l':
.   .   .   // 'm' [0]
.   .   .   if (*p ++ == 'm') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "hlm";
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-wide-c-code-alphabets-array ]-------------------------------------------

$ ../src/trie --attrs --dots --gen=wide --output=c-code --trie=array < alphabets.txt
.   // [25,'z']
.   switch (*p ++) {
.   // 'a' [8,'z']
.   case 'a':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "aa";
.   .   .   return error;
.   .   // 'f' [0]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "af";
.   .   .   return error;
.   .   // 'g' [1,'q']
.   .   case 'g':
.   .   .   // 'q' [0]
.   .   .   if (*p ++ == 'q') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "agq";
.   .   .   }
.   .   .   return error;
.   .   // 'k' [0]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "ak";
.   .   .   return error;
.   .   // 'm' [0]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "am";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ar";
.   .   .   return error;
.   .   // 's' [2,'t']
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "as";
.   .   .   switch (*p ++) {
.   .   .   // 'a' [0]
.   .   .   case 'a':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "asa";
.   .   .   .   return error;
.   .   .   // 't' [0]
.   .   .   case 't':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ast";
.   .   .   }
.   .   .   return error;
.   .   // 'z' [1,'_']
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "az";
.   .   .   // '_' [1,'C']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'C' [1,'y']
.   .   .   .   if (*p ++ == 'C') {
.   .   .   .   .   // 'y' [1,'r']
.   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   // 'r' [1,'l']
.   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   // 'l' [0]
.   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "az_Cyrl";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'b' [9,'y']
.   case 'b':
.   .   switch (*p ++) {
.   .   // 'a' [1,'s']
.   .   case 'a':
.   .   .   // 's' [0]
.   .   .   if (*p ++ == 's') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bas";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [2,'z']
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "be";
.   .   .   switch (*p ++) {
.   .   .   // 'm' [0]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bem";
.   .   .   .   return error;
.   .   .   // 'z' [0]
.   .   .   case 'z':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bez";
.   .   .   }
.   .   .   return error;
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "bg";
.   .   .   return error;
.   .   // 'm' [0]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "bm";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "bn";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "bo";
.   .   .   return error;
.   .   // 'r' [1,'x']
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "br";
.   .   .   // 'x' [0]
.   .   .   if (*p ++ == 'x') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "brx";
.   .   .   }
.   .   .   return error;
.   .   // 's' [1,'_']
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "bs";
.   .   .   // '_' [1,'C']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'C' [1,'y']
.   .   .   .   if (*p ++ == 'C') {
.   .   .   .   .   // 'y' [1,'r']
.   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   // 'r' [1,'l']
.   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   // 'l' [0]
.   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "bs_Cyrl";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'y' [1,'n']
.   .   case 'y':
.   .   .   // 'n' [0]
.   .   .   if (*p ++ == 'n') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "byn";
.   .   .   }
.   .   }
.   .   return error;
.   // 'c' [5,'y']
.   case 'c':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ca";
.   .   .   return error;
.   .   // 'g' [1,'g']
.   .   case 'g':
.   .   .   // 'g' [0]
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cgg";
.   .   .   }
.   .   .   return error;
.   .   // 'h' [1,'r']
.   .   case 'h':
.   .   .   // 'r' [0]
.   .   .   if (*p ++ == 'r') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "chr";
.   .   .   }
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "cs";
.   .   .   return error;
.   .   // 'y' [0]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "cy";
.   .   }
.   .   return error;
.   // 'd' [6,'z']
.   case 'd':
.   .   switch (*p ++) {
.   .   // 'a' [1,'v']
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "da";
.   .   .   // 'v' [0]
.   .   .   if (*p ++ == 'v') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "dav";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [0]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "de";
.   .   .   return error;
.   .   // 'j' [1,'e']
.   .   case 'j':
.   .   .   // 'e' [0]
.   .   .   if (*p ++ == 'e') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "dje";
.   .   .   }
.   .   .   return error;
.   .   // 'u' [1,'a']
.   .   case 'u':
.   .   .   // 'a' [0]
.   .   .   if (*p ++ == 'a') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "dua";
.   .   .   }
.   .   .   return error;
.   .   // 'y' [1,'o']
.   .   case 'y':
.   .   .   // 'o' [0]
.   .   .   if (*p ++ == 'o') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "dyo";
.   .   .   }
.   .   .   return error;
.   .   // 'z' [0]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "dz";
.   .   }
.   .   return error;
.   // 'e' [9,'w']
.   case 'e':
.   .   switch (*p ++) {
.   .   // 'b' [1,'u']
.   .   case 'b':
.   .   .   // 'u' [0]
.   .   .   if (*p ++ == 'u') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ebu";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [0]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ee";
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "el";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "en";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "eo";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "es";
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "et";
.   .   .   return error;
.   .   // 'u' [0]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "eu";
.   .   .   return error;
.   .   // 'w' [1,'o']
.   .   case 'w':
.   .   .   // 'o' [0]
.   .   .   if (*p ++ == 'o') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ewo";
.   .   .   }
.   .   }
.   .   return error;
.   // 'f' [7,'y']
.   case 'f':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "fa";
.   .   .   return error;
.   .   // 'f' [0]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "ff";
.   .   .   return error;
.   .   // 'i' [1,'l']
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "fi";
.   .   .   // 'l' [0]
.   .   .   if (*p ++ == 'l') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "fil";
.   .   .   }
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "fo";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "fr";
.   .   .   return error;
.   .   // 'u' [1,'r']
.   .   case 'u':
.   .   .   // 'r' [0]
.   .   .   if (*p ++ == 'r') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "fur";
.   .   .   }
.   .   .   return error;
.   .   // 'y' [0]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "fy";
.   .   }
.   .   return error;
.   // 'g' [6,'v']
.   case 'g':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ga";
.   .   .   return error;
.   .   // 'd' [0]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "gd";
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "gl";
.   .   .   return error;
.   .   // 's' [1,'w']
.   .   case 's':
.   .   .   // 'w' [0]
.   .   .   if (*p ++ == 'w') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "gsw";
.   .   .   }
.   .   .   return error;
.   .   // 'u' [1,'z']
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "gu";
.   .   .   // 'z' [0]
.   .   .   if (*p ++ == 'z') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "guz";
.   .   .   }
.   .   .   return error;
.   .   // 'v' [0]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "gv";
.   .   }
.   .   return error;
.   // 'h' [6,'y']
.   case 'h':
.   .   switch (*p ++) {
.   .   // 'a' [1,'w']
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ha";
.   .   .   // 'w' [0]
.   .   .   if (*p ++ == 'w') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "haw";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [0]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "he";
.   .   .   return error;
.   .   // 'i' [0]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "hi";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "hr";
.   .   .   return error;
.   .   // 'u' [0]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "hu";
.   .   .   return error;
.   .   // 'y' [0]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "hy";
.   .   }
.   .   return error;
.   // 'i' [6,'t']
.   case 'i':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ia";
.   .   .   return error;
.   .   // 'd' [0]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "id";
.   .   .   return error;
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ig";
.   .   .   return error;
.   .   // 'i' [0]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ii";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "is";
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "it";
.   .   }
.   .   return error;
.   // 'j' [3,'m']
.   case 'j':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ja";
.   .   .   return error;
.   .   // 'g' [1,'o']
.   .   case 'g':
.   .   .   // 'o' [0]
.   .   .   if (*p ++ == 'o') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "jgo";
.   .   .   }
.   .   .   return error;
.   .   // 'm' [1,'c']
.   .   case 'm':
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "jmc";
.   .   .   }
.   .   }
.   .   return error;
.   // 'k' [13,'y']
.   case 'k':
.   .   switch (*p ++) {
.   .   // 'a' [2,'m']
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ka";
.   .   .   switch (*p ++) {
.   .   .   // 'b' [0]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kab";
.   .   .   .   return error;
.   .   .   // 'm' [0]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kam";
.   .   .   }
.   .   .   return error;
.   .   // 'd' [1,'e']
.   .   case 'd':
.   .   .   // 'e' [0]
.   .   .   if (*p ++ == 'e') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kde";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [1,'a']
.   .   case 'e':
.   .   .   // 'a' [0]
.   .   .   if (*p ++ == 'a') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kea";
.   .   .   }
.   .   .   return error;
.   .   // 'h' [1,'q']
.   .   case 'h':
.   .   .   // 'q' [0]
.   .   .   if (*p ++ == 'q') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "khq";
.   .   .   }
.   .   .   return error;
.   .   // 'i' [0]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ki";
.   .   .   return error;
.   .   // 'k' [1,'j']
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "kk";
.   .   .   // 'j' [0]
.   .   .   if (*p ++ == 'j') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kkj";
.   .   .   }
.   .   .   return error;
.   .   // 'l' [1,'n']
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "kl";
.   .   .   // 'n' [0]
.   .   .   if (*p ++ == 'n') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kln";
.   .   .   }
.   .   .   return error;
.   .   // 'm' [0]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "km";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "kn";
.   .   .   return error;
.   .   // 'o' [1,'k']
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ko";
.   .   .   // 'k' [0]
.   .   .   if (*p ++ == 'k') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kok";
.   .   .   }
.   .   .   return error;
.   .   // 's' [3,'h']
.   .   case 's':
.   .   .   switch (*p ++) {
.   .   .   // 'b' [0]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksb";
.   .   .   .   return error;
.   .   .   // 'f' [0]
.   .   .   case 'f':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksf";
.   .   .   .   return error;
.   .   .   // 'h' [0]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksh";
.   .   .   }
.   .   .   return error;
.   .   // 'w' [0]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "kw";
.   .   .   return error;
.   .   // 'y' [0]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "ky";
.   .   }
.   .   return error;
.   // 'l' [8,'v']
.   case 'l':
.   .   switch (*p ++) {
.   .   // 'a' [1,'g']
.   .   case 'a':
.   .   .   // 'g' [0]
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "lag";
.   .   .   }
.   .   .   return error;
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "lg";
.   .   .   return error;
.   .   // 'k' [1,'t']
.   .   case 'k':
.   .   .   // 't' [0]
.   .   .   if (*p ++ == 't') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "lkt";
.   .   .   }
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "ln";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "lo";
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "lt";
.   .   .   return error;
.   .   // 'u' [2,'y']
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "lu";
.   .   .   switch (*p ++) {
.   .   .   // 'o' [0]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luo";
.   .   .   .   return error;
.   .   .   // 'y' [0]
.   .   .   case 'y':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luy";
.   .   .   }
.   .   .   return error;
.   .   // 'v' [0]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "lv";
.   .   }
.   .   return error;
.   // 'm' [12,'y']
.   case 'm':
.   .   switch (*p ++) {
.   .   // 'a' [1,'s']
.   .   case 'a':
.   .   .   // 's' [0]
.   .   .   if (*p ++ == 's') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mas";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [1,'r']
.   .   case 'e':
.   .   .   // 'r' [0]
.   .   .   if (*p ++ == 'r') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mer";
.   .   .   }
.   .   .   return error;
.   .   // 'f' [1,'e']
.   .   case 'f':
.   .   .   // 'e' [0]
.   .   .   if (*p ++ == 'e') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mfe";
.   .   .   }
.   .   .   return error;
.   .   // 'g' [2,'o']
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "mg";
.   .   .   switch (*p ++) {
.   .   .   // 'h' [0]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgh";
.   .   .   .   return error;
.   .   .   // 'o' [0]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgo";
.   .   .   }
.   .   .   return error;
.   .   // 'k' [0]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "mk";
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "ml";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "mn";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "mr";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ms";
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "mt";
.   .   .   return error;
.   .   // 'u' [1,'a']
.   .   case 'u':
.   .   .   // 'a' [0]
.   .   .   if (*p ++ == 'a') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mua";
.   .   .   }
.   .   .   return error;
.   .   // 'y' [0]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "my";
.   .   }
.   .   return error;
.   // 'n' [11,'y']
.   case 'n':
.   .   switch (*p ++) {
.   .   // 'a' [1,'q']
.   .   case 'a':
.   .   .   // 'q' [0]
.   .   .   if (*p ++ == 'q') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "naq";
.   .   .   }
.   .   .   return error;
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "nb";
.   .   .   return error;
.   .   // 'd' [0]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "nd";
.   .   .   return error;
.   .   // 'e' [0]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ne";
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "nl";
.   .   .   return error;
.   .   // 'm' [1,'g']
.   .   case 'm':
.   .   .   // 'g' [0]
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "nmg";
.   .   .   }
.   .   .   return error;
.   .   // 'n' [1,'h']
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "nn";
.   .   .   // 'h' [0]
.   .   .   if (*p ++ == 'h') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "nnh";
.   .   .   }
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "nr";
.   .   .   return error;
.   .   // 's' [1,'o']
.   .   case 's':
.   .   .   // 'o' [0]
.   .   .   if (*p ++ == 'o') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "nso";
.   .   .   }
.   .   .   return error;
.   .   // 'u' [1,'s']
.   .   case 'u':
.   .   .   // 's' [0]
.   .   .   if (*p ++ == 's') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "nus";
.   .   .   }
.   .   .   return error;
.   .   // 'y' [1,'n']
.   .   case 'y':
.   .   .   // 'n' [0]
.   .   .   if (*p ++ == 'n') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "nyn";
.   .   .   }
.   .   }
.   .   return error;
.   // 'o' [3,'s']
.   case 'o':
.   .   switch (*p ++) {
.   .   // 'm' [0]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "om";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "or";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "os";
.   .   }
.   .   return error;
.   // 'p' [4,'t']
.   case 'p':
.   .   switch (*p ++) {
.   .   // 'a' [1,'_']
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "pa";
.   .   .   // '_' [1,'A']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'A' [1,'r']
.   .   .   .   if (*p ++ == 'A') {
.   .   .   .   .   // 'r' [1,'a']
.   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   // 'a' [1,'b']
.   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   // 'b' [0]
.   .   .   .   .   .   .   if (*p ++ == 'b') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "pa_Arab";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "pl";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ps";
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "pt";
.   .   }
.   .   return error;
.   // 'r' [5,'w']
.   case 'r':
.   .   switch (*p ++) {
.   .   // 'm' [0]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "rm";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "rn";
.   .   .   return error;
.   .   // 'o' [1,'f']
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ro";
.   .   .   // 'f' [0]
.   .   .   if (*p ++ == 'f') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "rof";
.   .   .   }
.   .   .   return error;
.   .   // 'u' [0]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "ru";
.   .   .   return error;
.   .   // 'w' [1,'k']
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "rw";
.   .   .   // 'k' [0]
.   .   .   if (*p ++ == 'k') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "rwk";
.   .   .   }
.   .   }
.   .   return error;
.   // 's' [16,'w']
.   case 's':
.   .   switch (*p ++) {
.   .   // 'a' [2,'q']
.   .   case 'a':
.   .   .   switch (*p ++) {
.   .   .   // 'h' [0]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sah";
.   .   .   .   return error;
.   .   .   // 'q' [0]
.   .   .   case 'q':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "saq";
.   .   .   }
.   .   .   return error;
.   .   // 'b' [1,'p']
.   .   case 'b':
.   .   .   // 'p' [0]
.   .   .   if (*p ++ == 'p') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sbp";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [2,'s']
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "se";
.   .   .   switch (*p ++) {
.   .   .   // 'h' [0]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "seh";
.   .   .   .   return error;
.   .   .   // 's' [0]
.   .   .   case 's':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ses";
.   .   .   }
.   .   .   return error;
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "sg";
.   .   .   return error;
.   .   // 'h' [1,'i']
.   .   case 'h':
.   .   .   // 'i' [1,'_']
.   .   .   if (*p ++ == 'i') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "shi";
.   .   .   .   // '_' [1,'L']
.   .   .   .   if (*p ++ == '_') {
.   .   .   .   .   // 'L' [1,'a']
.   .   .   .   .   if (*p ++ == 'L') {
.   .   .   .   .   .   // 'a' [1,'t']
.   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   // 't' [1,'n']
.   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   // 'n' [0]
.   .   .   .   .   .   .   .   if (*p ++ == 'n') {
.   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   return "shi_Latn";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'i' [0]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "si";
.   .   .   return error;
.   .   // 'k' [0]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "sk";
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "sl";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "sn";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "so";
.   .   .   return error;
.   .   // 'q' [0]
.   .   case 'q':
.   .   .   if (*p == 0)
.   .   .   .   return "sq";
.   .   .   return error;
.   .   // 'r' [1,'_']
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "sr";
.   .   .   // '_' [1,'L']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'L' [1,'a']
.   .   .   .   if (*p ++ == 'L') {
.   .   .   .   .   // 'a' [1,'t']
.   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   // 't' [1,'n']
.   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   // 'n' [0]
.   .   .   .   .   .   .   if (*p ++ == 'n') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "sr_Latn";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 's' [1,'y']
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ss";
.   .   .   // 'y' [0]
.   .   .   if (*p ++ == 'y') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ssy";
.   .   .   }
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "st";
.   .   .   return error;
.   .   // 'v' [0]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "sv";
.   .   .   return error;
.   .   // 'w' [1,'c']
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "sw";
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "swc";
.   .   .   }
.   .   }
.   .   return error;
.   // 't' [11,'z']
.   case 't':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ta";
.   .   .   return error;
.   .   // 'e' [1,'o']
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "te";
.   .   .   // 'o' [0]
.   .   .   if (*p ++ == 'o') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "teo";
.   .   .   }
.   .   .   return error;
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "tg";
.   .   .   return error;
.   .   // 'h' [0]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "th";
.   .   .   return error;
.   .   // 'i' [2,'g']
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ti";
.   .   .   switch (*p ++) {
.   .   .   // '_' [1,'E']
.   .   .   case '_':
.   .   .   .   // 'E' [1,'R']
.   .   .   .   if (*p ++ == 'E') {
.   .   .   .   .   // 'R' [0]
.   .   .   .   .   if (*p ++ == 'R') {
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "ti_ER";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   return error;
.   .   .   // 'g' [0]
.   .   .   case 'g':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tig";
.   .   .   }
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "tn";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "to";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "tr";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ts";
.   .   .   return error;
.   .   // 'w' [1,'q']
.   .   case 'w':
.   .   .   // 'q' [0]
.   .   .   if (*p ++ == 'q') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "twq";
.   .   .   }
.   .   .   return error;
.   .   // 'z' [1,'m']
.   .   case 'z':
.   .   .   // 'm' [0]
.   .   .   if (*p ++ == 'm') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tzm";
.   .   .   }
.   .   }
.   .   return error;
.   // 'u' [4,'z']
.   case 'u':
.   .   switch (*p ++) {
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ug";
.   .   .   return error;
.   .   // 'k' [0]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "uk";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ur";
.   .   .   return error;
.   .   // 'z' [1,'_']
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "uz";
.   .   .   // '_' [2,'C']
.   .   .   if (*p ++ == '_') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // 'A' [1,'r']
.   .   .   .   case 'A':
.   .   .   .   .   // 'r' [1,'a']
.   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   // 'a' [1,'b']
.   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   // 'b' [0]
.   .   .   .   .   .   .   if (*p ++ == 'b') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "uz_Arab";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   return error;
.   .   .   .   // 'C' [1,'y']
.   .   .   .   case 'C':
.   .   .   .   .   // 'y' [1,'r']
.   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   // 'r' [1,'l']
.   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   // 'l' [0]
.   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "uz_Cyrl";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'v' [5,'u']
.   case 'v':
.   .   switch (*p ++) {
.   .   // 'a' [1,'i']
.   .   case 'a':
.   .   .   // 'i' [1,'_']
.   .   .   if (*p ++ == 'i') {
.   .   .   .   // '_' [1,'L']
.   .   .   .   if (*p ++ == '_') {
.   .   .   .   .   // 'L' [1,'a']
.   .   .   .   .   if (*p ++ == 'L') {
.   .   .   .   .   .   // 'a' [1,'t']
.   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   // 't' [1,'n']
.   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   // 'n' [0]
.   .   .   .   .   .   .   .   if (*p ++ == 'n') {
.   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   return "vai_Latn";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'e' [0]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ve";
.   .   .   return error;
.   .   // 'i' [0]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "vi";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "vo";
.   .   .   return error;
.   .   // 'u' [1,'n']
.   .   case 'u':
.   .   .   // 'n' [0]
.   .   .   if (*p ++ == 'n') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "vun";
.   .   .   }
.   .   }
.   .   return error;
.   // 'w' [1,'a']
.   case 'w':
.   .   // 'a' [2,'l']
.   .   if (*p ++ == 'a') {
.   .   .   switch (*p ++) {
.   .   .   // 'e' [0]
.   .   .   case 'e':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wae";
.   .   .   .   return error;
.   .   .   // 'l' [0]
.   .   .   case 'l':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wal";
.   .   .   }
.   .   }
.   .   return error;
.   // 'x' [2,'o']
.   case 'x':
.   .   switch (*p ++) {
.   .   // 'h' [0]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "xh";
.   .   .   return error;
.   .   // 'o' [1,'g']
.   .   case 'o':
.   .   .   // 'g' [0]
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "xog";
.   .   .   }
.   .   }
.   .   return error;
.   // 'y' [2,'o']
.   case 'y':
.   .   switch (*p ++) {
.   .   // 'a' [1,'v']
.   .   case 'a':
.   .   .   // 'v' [0]
.   .   .   if (*p ++ == 'v') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "yav";
.   .   .   }
.   .   .   return error;
.   .   // 'o' [1,'_']
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "yo";
.   .   .   // '_' [1,'B']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'B' [1,'J']
.   .   .   .   if (*p ++ == 'B') {
.   .   .   .   .   // 'J' [0]
.   .   .   .   .   if (*p ++ == 'J') {
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "yo_BJ";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'z' [3,'u']
.   case 'z':
.   .   switch (*p ++) {
.   .   // 'g' [1,'h']
.   .   case 'g':
.   .   .   // 'h' [0]
.   .   .   if (*p ++ == 'h') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "zgh";
.   .   .   }
.   .   .   return error;
.   .   // 'h' [1,'_']
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "zh";
.   .   .   // '_' [1,'H']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'H' [1,'a']
.   .   .   .   if (*p ++ == 'H') {
.   .   .   .   .   // 'a' [1,'n']
.   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   // 'n' [1,'t']
.   .   .   .   .   .   if (*p ++ == 'n') {
.   .   .   .   .   .   .   // 't' [0]
.   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "zh_Hant";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'u' [0]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "zu";
.   .   }
.   }
.   return error;
$

--[ gen-wide-c-code-alphabets-ternary ]-----------------------------------------

$ ../src/trie --attrs --dots --gen=wide --output=c-code --trie=ternary < alphabets.txt
.   // [25,'z']
.   switch (*p ++) {
.   // 'a' [8,'z']
.   case 'a':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "aa";
.   .   .   return error;
.   .   // 'f' [0]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "af";
.   .   .   return error;
.   .   // 'g' [1,'q']
.   .   case 'g':
.   .   .   // 'q' [0]
.   .   .   if (*p ++ == 'q') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "agq";
.   .   .   }
.   .   .   return error;
.   .   // 'k' [0]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "ak";
.   .   .   return error;
.   .   // 'm' [0]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "am";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ar";
.   .   .   return error;
.   .   // 's' [2,'t']
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "as";
.   .   .   switch (*p ++) {
.   .   .   // 'a' [0]
.   .   .   case 'a':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "asa";
.   .   .   .   return error;
.   .   .   // 't' [0]
.   .   .   case 't':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ast";
.   .   .   }
.   .   .   return error;
.   .   // 'z' [1,'_']
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "az";
.   .   .   // '_' [1,'C']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'C' [1,'y']
.   .   .   .   if (*p ++ == 'C') {
.   .   .   .   .   // 'y' [1,'r']
.   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   // 'r' [1,'l']
.   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   // 'l' [0]
.   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "az_Cyrl";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'b' [9,'y']
.   case 'b':
.   .   switch (*p ++) {
.   .   // 'a' [1,'s']
.   .   case 'a':
.   .   .   // 's' [0]
.   .   .   if (*p ++ == 's') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bas";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [2,'z']
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "be";
.   .   .   switch (*p ++) {
.   .   .   // 'm' [0]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bem";
.   .   .   .   return error;
.   .   .   // 'z' [0]
.   .   .   case 'z':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bez";
.   .   .   }
.   .   .   return error;
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "bg";
.   .   .   return error;
.   .   // 'm' [0]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "bm";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "bn";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "bo";
.   .   .   return error;
.   .   // 'r' [1,'x']
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "br";
.   .   .   // 'x' [0]
.   .   .   if (*p ++ == 'x') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "brx";
.   .   .   }
.   .   .   return error;
.   .   // 's' [1,'_']
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "bs";
.   .   .   // '_' [1,'C']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'C' [1,'y']
.   .   .   .   if (*p ++ == 'C') {
.   .   .   .   .   // 'y' [1,'r']
.   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   // 'r' [1,'l']
.   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   // 'l' [0]
.   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "bs_Cyrl";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'y' [1,'n']
.   .   case 'y':
.   .   .   // 'n' [0]
.   .   .   if (*p ++ == 'n') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "byn";
.   .   .   }
.   .   }
.   .   return error;
.   // 'c' [5,'y']
.   case 'c':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ca";
.   .   .   return error;
.   .   // 'g' [1,'g']
.   .   case 'g':
.   .   .   // 'g' [0]
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cgg";
.   .   .   }
.   .   .   return error;
.   .   // 'h' [1,'r']
.   .   case 'h':
.   .   .   // 'r' [0]
.   .   .   if (*p ++ == 'r') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "chr";
.   .   .   }
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "cs";
.   .   .   return error;
.   .   // 'y' [0]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "cy";
.   .   }
.   .   return error;
.   // 'd' [6,'z']
.   case 'd':
.   .   switch (*p ++) {
.   .   // 'a' [1,'v']
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "da";
.   .   .   // 'v' [0]
.   .   .   if (*p ++ == 'v') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "dav";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [0]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "de";
.   .   .   return error;
.   .   // 'j' [1,'e']
.   .   case 'j':
.   .   .   // 'e' [0]
.   .   .   if (*p ++ == 'e') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "dje";
.   .   .   }
.   .   .   return error;
.   .   // 'u' [1,'a']
.   .   case 'u':
.   .   .   // 'a' [0]
.   .   .   if (*p ++ == 'a') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "dua";
.   .   .   }
.   .   .   return error;
.   .   // 'y' [1,'o']
.   .   case 'y':
.   .   .   // 'o' [0]
.   .   .   if (*p ++ == 'o') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "dyo";
.   .   .   }
.   .   .   return error;
.   .   // 'z' [0]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "dz";
.   .   }
.   .   return error;
.   // 'e' [9,'w']
.   case 'e':
.   .   switch (*p ++) {
.   .   // 'b' [1,'u']
.   .   case 'b':
.   .   .   // 'u' [0]
.   .   .   if (*p ++ == 'u') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ebu";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [0]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ee";
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "el";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "en";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "eo";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "es";
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "et";
.   .   .   return error;
.   .   // 'u' [0]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "eu";
.   .   .   return error;
.   .   // 'w' [1,'o']
.   .   case 'w':
.   .   .   // 'o' [0]
.   .   .   if (*p ++ == 'o') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ewo";
.   .   .   }
.   .   }
.   .   return error;
.   // 'f' [7,'y']
.   case 'f':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "fa";
.   .   .   return error;
.   .   // 'f' [0]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "ff";
.   .   .   return error;
.   .   // 'i' [1,'l']
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "fi";
.   .   .   // 'l' [0]
.   .   .   if (*p ++ == 'l') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "fil";
.   .   .   }
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "fo";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "fr";
.   .   .   return error;
.   .   // 'u' [1,'r']
.   .   case 'u':
.   .   .   // 'r' [0]
.   .   .   if (*p ++ == 'r') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "fur";
.   .   .   }
.   .   .   return error;
.   .   // 'y' [0]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "fy";
.   .   }
.   .   return error;
.   // 'g' [6,'v']
.   case 'g':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ga";
.   .   .   return error;
.   .   // 'd' [0]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "gd";
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "gl";
.   .   .   return error;
.   .   // 's' [1,'w']
.   .   case 's':
.   .   .   // 'w' [0]
.   .   .   if (*p ++ == 'w') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "gsw";
.   .   .   }
.   .   .   return error;
.   .   // 'u' [1,'z']
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "gu";
.   .   .   // 'z' [0]
.   .   .   if (*p ++ == 'z') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "guz";
.   .   .   }
.   .   .   return error;
.   .   // 'v' [0]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "gv";
.   .   }
.   .   return error;
.   // 'h' [6,'y']
.   case 'h':
.   .   switch (*p ++) {
.   .   // 'a' [1,'w']
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ha";
.   .   .   // 'w' [0]
.   .   .   if (*p ++ == 'w') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "haw";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [0]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "he";
.   .   .   return error;
.   .   // 'i' [0]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "hi";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "hr";
.   .   .   return error;
.   .   // 'u' [0]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "hu";
.   .   .   return error;
.   .   // 'y' [0]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "hy";
.   .   }
.   .   return error;
.   // 'i' [6,'t']
.   case 'i':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ia";
.   .   .   return error;
.   .   // 'd' [0]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "id";
.   .   .   return error;
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ig";
.   .   .   return error;
.   .   // 'i' [0]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ii";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "is";
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "it";
.   .   }
.   .   return error;
.   // 'j' [3,'m']
.   case 'j':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ja";
.   .   .   return error;
.   .   // 'g' [1,'o']
.   .   case 'g':
.   .   .   // 'o' [0]
.   .   .   if (*p ++ == 'o') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "jgo";
.   .   .   }
.   .   .   return error;
.   .   // 'm' [1,'c']
.   .   case 'm':
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "jmc";
.   .   .   }
.   .   }
.   .   return error;
.   // 'k' [13,'y']
.   case 'k':
.   .   switch (*p ++) {
.   .   // 'a' [2,'m']
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ka";
.   .   .   switch (*p ++) {
.   .   .   // 'b' [0]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kab";
.   .   .   .   return error;
.   .   .   // 'm' [0]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kam";
.   .   .   }
.   .   .   return error;
.   .   // 'd' [1,'e']
.   .   case 'd':
.   .   .   // 'e' [0]
.   .   .   if (*p ++ == 'e') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kde";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [1,'a']
.   .   case 'e':
.   .   .   // 'a' [0]
.   .   .   if (*p ++ == 'a') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kea";
.   .   .   }
.   .   .   return error;
.   .   // 'h' [1,'q']
.   .   case 'h':
.   .   .   // 'q' [0]
.   .   .   if (*p ++ == 'q') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "khq";
.   .   .   }
.   .   .   return error;
.   .   // 'i' [0]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ki";
.   .   .   return error;
.   .   // 'k' [1,'j']
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "kk";
.   .   .   // 'j' [0]
.   .   .   if (*p ++ == 'j') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kkj";
.   .   .   }
.   .   .   return error;
.   .   // 'l' [1,'n']
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "kl";
.   .   .   // 'n' [0]
.   .   .   if (*p ++ == 'n') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kln";
.   .   .   }
.   .   .   return error;
.   .   // 'm' [0]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "km";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "kn";
.   .   .   return error;
.   .   // 'o' [1,'k']
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ko";
.   .   .   // 'k' [0]
.   .   .   if (*p ++ == 'k') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kok";
.   .   .   }
.   .   .   return error;
.   .   // 's' [3,'h']
.   .   case 's':
.   .   .   switch (*p ++) {
.   .   .   // 'b' [0]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksb";
.   .   .   .   return error;
.   .   .   // 'f' [0]
.   .   .   case 'f':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksf";
.   .   .   .   return error;
.   .   .   // 'h' [0]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksh";
.   .   .   }
.   .   .   return error;
.   .   // 'w' [0]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "kw";
.   .   .   return error;
.   .   // 'y' [0]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "ky";
.   .   }
.   .   return error;
.   // 'l' [8,'v']
.   case 'l':
.   .   switch (*p ++) {
.   .   // 'a' [1,'g']
.   .   case 'a':
.   .   .   // 'g' [0]
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "lag";
.   .   .   }
.   .   .   return error;
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "lg";
.   .   .   return error;
.   .   // 'k' [1,'t']
.   .   case 'k':
.   .   .   // 't' [0]
.   .   .   if (*p ++ == 't') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "lkt";
.   .   .   }
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "ln";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "lo";
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "lt";
.   .   .   return error;
.   .   // 'u' [2,'y']
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "lu";
.   .   .   switch (*p ++) {
.   .   .   // 'o' [0]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luo";
.   .   .   .   return error;
.   .   .   // 'y' [0]
.   .   .   case 'y':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luy";
.   .   .   }
.   .   .   return error;
.   .   // 'v' [0]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "lv";
.   .   }
.   .   return error;
.   // 'm' [12,'y']
.   case 'm':
.   .   switch (*p ++) {
.   .   // 'a' [1,'s']
.   .   case 'a':
.   .   .   // 's' [0]
.   .   .   if (*p ++ == 's') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mas";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [1,'r']
.   .   case 'e':
.   .   .   // 'r' [0]
.   .   .   if (*p ++ == 'r') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mer";
.   .   .   }
.   .   .   return error;
.   .   // 'f' [1,'e']
.   .   case 'f':
.   .   .   // 'e' [0]
.   .   .   if (*p ++ == 'e') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mfe";
.   .   .   }
.   .   .   return error;
.   .   // 'g' [2,'o']
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "mg";
.   .   .   switch (*p ++) {
.   .   .   // 'h' [0]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgh";
.   .   .   .   return error;
.   .   .   // 'o' [0]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgo";
.   .   .   }
.   .   .   return error;
.   .   // 'k' [0]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "mk";
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "ml";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "mn";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "mr";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ms";
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "mt";
.   .   .   return error;
.   .   // 'u' [1,'a']
.   .   case 'u':
.   .   .   // 'a' [0]
.   .   .   if (*p ++ == 'a') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mua";
.   .   .   }
.   .   .   return error;
.   .   // 'y' [0]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "my";
.   .   }
.   .   return error;
.   // 'n' [11,'y']
.   case 'n':
.   .   switch (*p ++) {
.   .   // 'a' [1,'q']
.   .   case 'a':
.   .   .   // 'q' [0]
.   .   .   if (*p ++ == 'q') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "naq";
.   .   .   }
.   .   .   return error;
.   .   // 'b' [0]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "nb";
.   .   .   return error;
.   .   // 'd' [0]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "nd";
.   .   .   return error;
.   .   // 'e' [0]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ne";
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "nl";
.   .   .   return error;
.   .   // 'm' [1,'g']
.   .   case 'm':
.   .   .   // 'g' [0]
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "nmg";
.   .   .   }
.   .   .   return error;
.   .   // 'n' [1,'h']
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "nn";
.   .   .   // 'h' [0]
.   .   .   if (*p ++ == 'h') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "nnh";
.   .   .   }
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "nr";
.   .   .   return error;
.   .   // 's' [1,'o']
.   .   case 's':
.   .   .   // 'o' [0]
.   .   .   if (*p ++ == 'o') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "nso";
.   .   .   }
.   .   .   return error;
.   .   // 'u' [1,'s']
.   .   case 'u':
.   .   .   // 's' [0]
.   .   .   if (*p ++ == 's') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "nus";
.   .   .   }
.   .   .   return error;
.   .   // 'y' [1,'n']
.   .   case 'y':
.   .   .   // 'n' [0]
.   .   .   if (*p ++ == 'n') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "nyn";
.   .   .   }
.   .   }
.   .   return error;
.   // 'o' [3,'s']
.   case 'o':
.   .   switch (*p ++) {
.   .   // 'm' [0]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "om";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "or";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "os";
.   .   }
.   .   return error;
.   // 'p' [4,'t']
.   case 'p':
.   .   switch (*p ++) {
.   .   // 'a' [1,'_']
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "pa";
.   .   .   // '_' [1,'A']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'A' [1,'r']
.   .   .   .   if (*p ++ == 'A') {
.   .   .   .   .   // 'r' [1,'a']
.   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   // 'a' [1,'b']
.   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   // 'b' [0]
.   .   .   .   .   .   .   if (*p ++ == 'b') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "pa_Arab";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "pl";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ps";
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "pt";
.   .   }
.   .   return error;
.   // 'r' [5,'w']
.   case 'r':
.   .   switch (*p ++) {
.   .   // 'm' [0]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "rm";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "rn";
.   .   .   return error;
.   .   // 'o' [1,'f']
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ro";
.   .   .   // 'f' [0]
.   .   .   if (*p ++ == 'f') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "rof";
.   .   .   }
.   .   .   return error;
.   .   // 'u' [0]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "ru";
.   .   .   return error;
.   .   // 'w' [1,'k']
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "rw";
.   .   .   // 'k' [0]
.   .   .   if (*p ++ == 'k') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "rwk";
.   .   .   }
.   .   }
.   .   return error;
.   // 's' [16,'w']
.   case 's':
.   .   switch (*p ++) {
.   .   // 'a' [2,'q']
.   .   case 'a':
.   .   .   switch (*p ++) {
.   .   .   // 'h' [0]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sah";
.   .   .   .   return error;
.   .   .   // 'q' [0]
.   .   .   case 'q':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "saq";
.   .   .   }
.   .   .   return error;
.   .   // 'b' [1,'p']
.   .   case 'b':
.   .   .   // 'p' [0]
.   .   .   if (*p ++ == 'p') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sbp";
.   .   .   }
.   .   .   return error;
.   .   // 'e' [2,'s']
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "se";
.   .   .   switch (*p ++) {
.   .   .   // 'h' [0]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "seh";
.   .   .   .   return error;
.   .   .   // 's' [0]
.   .   .   case 's':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ses";
.   .   .   }
.   .   .   return error;
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "sg";
.   .   .   return error;
.   .   // 'h' [1,'i']
.   .   case 'h':
.   .   .   // 'i' [1,'_']
.   .   .   if (*p ++ == 'i') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "shi";
.   .   .   .   // '_' [1,'L']
.   .   .   .   if (*p ++ == '_') {
.   .   .   .   .   // 'L' [1,'a']
.   .   .   .   .   if (*p ++ == 'L') {
.   .   .   .   .   .   // 'a' [1,'t']
.   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   // 't' [1,'n']
.   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   // 'n' [0]
.   .   .   .   .   .   .   .   if (*p ++ == 'n') {
.   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   return "shi_Latn";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'i' [0]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "si";
.   .   .   return error;
.   .   // 'k' [0]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "sk";
.   .   .   return error;
.   .   // 'l' [0]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "sl";
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "sn";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "so";
.   .   .   return error;
.   .   // 'q' [0]
.   .   case 'q':
.   .   .   if (*p == 0)
.   .   .   .   return "sq";
.   .   .   return error;
.   .   // 'r' [1,'_']
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "sr";
.   .   .   // '_' [1,'L']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'L' [1,'a']
.   .   .   .   if (*p ++ == 'L') {
.   .   .   .   .   // 'a' [1,'t']
.   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   // 't' [1,'n']
.   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   // 'n' [0]
.   .   .   .   .   .   .   if (*p ++ == 'n') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "sr_Latn";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 's' [1,'y']
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ss";
.   .   .   // 'y' [0]
.   .   .   if (*p ++ == 'y') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ssy";
.   .   .   }
.   .   .   return error;
.   .   // 't' [0]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "st";
.   .   .   return error;
.   .   // 'v' [0]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "sv";
.   .   .   return error;
.   .   // 'w' [1,'c']
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "sw";
.   .   .   // 'c' [0]
.   .   .   if (*p ++ == 'c') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "swc";
.   .   .   }
.   .   }
.   .   return error;
.   // 't' [11,'z']
.   case 't':
.   .   switch (*p ++) {
.   .   // 'a' [0]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ta";
.   .   .   return error;
.   .   // 'e' [1,'o']
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "te";
.   .   .   // 'o' [0]
.   .   .   if (*p ++ == 'o') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "teo";
.   .   .   }
.   .   .   return error;
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "tg";
.   .   .   return error;
.   .   // 'h' [0]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "th";
.   .   .   return error;
.   .   // 'i' [2,'g']
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ti";
.   .   .   switch (*p ++) {
.   .   .   // '_' [1,'E']
.   .   .   case '_':
.   .   .   .   // 'E' [1,'R']
.   .   .   .   if (*p ++ == 'E') {
.   .   .   .   .   // 'R' [0]
.   .   .   .   .   if (*p ++ == 'R') {
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "ti_ER";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   return error;
.   .   .   // 'g' [0]
.   .   .   case 'g':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tig";
.   .   .   }
.   .   .   return error;
.   .   // 'n' [0]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "tn";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "to";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "tr";
.   .   .   return error;
.   .   // 's' [0]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ts";
.   .   .   return error;
.   .   // 'w' [1,'q']
.   .   case 'w':
.   .   .   // 'q' [0]
.   .   .   if (*p ++ == 'q') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "twq";
.   .   .   }
.   .   .   return error;
.   .   // 'z' [1,'m']
.   .   case 'z':
.   .   .   // 'm' [0]
.   .   .   if (*p ++ == 'm') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tzm";
.   .   .   }
.   .   }
.   .   return error;
.   // 'u' [4,'z']
.   case 'u':
.   .   switch (*p ++) {
.   .   // 'g' [0]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ug";
.   .   .   return error;
.   .   // 'k' [0]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "uk";
.   .   .   return error;
.   .   // 'r' [0]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ur";
.   .   .   return error;
.   .   // 'z' [1,'_']
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "uz";
.   .   .   // '_' [2,'C']
.   .   .   if (*p ++ == '_') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // 'A' [1,'r']
.   .   .   .   case 'A':
.   .   .   .   .   // 'r' [1,'a']
.   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   // 'a' [1,'b']
.   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   // 'b' [0]
.   .   .   .   .   .   .   if (*p ++ == 'b') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "uz_Arab";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   return error;
.   .   .   .   // 'C' [1,'y']
.   .   .   .   case 'C':
.   .   .   .   .   // 'y' [1,'r']
.   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   // 'r' [1,'l']
.   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   // 'l' [0]
.   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "uz_Cyrl";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'v' [5,'u']
.   case 'v':
.   .   switch (*p ++) {
.   .   // 'a' [1,'i']
.   .   case 'a':
.   .   .   // 'i' [1,'_']
.   .   .   if (*p ++ == 'i') {
.   .   .   .   // '_' [1,'L']
.   .   .   .   if (*p ++ == '_') {
.   .   .   .   .   // 'L' [1,'a']
.   .   .   .   .   if (*p ++ == 'L') {
.   .   .   .   .   .   // 'a' [1,'t']
.   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   // 't' [1,'n']
.   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   // 'n' [0]
.   .   .   .   .   .   .   .   if (*p ++ == 'n') {
.   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   return "vai_Latn";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'e' [0]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ve";
.   .   .   return error;
.   .   // 'i' [0]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "vi";
.   .   .   return error;
.   .   // 'o' [0]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "vo";
.   .   .   return error;
.   .   // 'u' [1,'n']
.   .   case 'u':
.   .   .   // 'n' [0]
.   .   .   if (*p ++ == 'n') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "vun";
.   .   .   }
.   .   }
.   .   return error;
.   // 'w' [1,'a']
.   case 'w':
.   .   // 'a' [2,'l']
.   .   if (*p ++ == 'a') {
.   .   .   switch (*p ++) {
.   .   .   // 'e' [0]
.   .   .   case 'e':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wae";
.   .   .   .   return error;
.   .   .   // 'l' [0]
.   .   .   case 'l':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wal";
.   .   .   }
.   .   }
.   .   return error;
.   // 'x' [2,'o']
.   case 'x':
.   .   switch (*p ++) {
.   .   // 'h' [0]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "xh";
.   .   .   return error;
.   .   // 'o' [1,'g']
.   .   case 'o':
.   .   .   // 'g' [0]
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "xog";
.   .   .   }
.   .   }
.   .   return error;
.   // 'y' [2,'o']
.   case 'y':
.   .   switch (*p ++) {
.   .   // 'a' [1,'v']
.   .   case 'a':
.   .   .   // 'v' [0]
.   .   .   if (*p ++ == 'v') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "yav";
.   .   .   }
.   .   .   return error;
.   .   // 'o' [1,'_']
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "yo";
.   .   .   // '_' [1,'B']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'B' [1,'J']
.   .   .   .   if (*p ++ == 'B') {
.   .   .   .   .   // 'J' [0]
.   .   .   .   .   if (*p ++ == 'J') {
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "yo_BJ";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // 'z' [3,'u']
.   case 'z':
.   .   switch (*p ++) {
.   .   // 'g' [1,'h']
.   .   case 'g':
.   .   .   // 'h' [0]
.   .   .   if (*p ++ == 'h') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "zgh";
.   .   .   }
.   .   .   return error;
.   .   // 'h' [1,'_']
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "zh";
.   .   .   // '_' [1,'H']
.   .   .   if (*p ++ == '_') {
.   .   .   .   // 'H' [1,'a']
.   .   .   .   if (*p ++ == 'H') {
.   .   .   .   .   // 'a' [1,'n']
.   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   // 'n' [1,'t']
.   .   .   .   .   .   if (*p ++ == 'n') {
.   .   .   .   .   .   .   // 't' [0]
.   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   return "zh_Hant";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // 'u' [0]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "zu";
.   .   }
.   }
.   return error;
$

--[ gen-wide-c-code-filenames-array ]-------------------------------------------

$ ../src/trie --attrs --dots --gen=wide --output=c-code --trie=array < filenames.txt
.   // [1,'c']
.   // 'c' [1,'+']
.   if (*p ++ == 'c') {
.   .   // '+' [1,'+']
.   .   if (*p ++ == '+') {
.   .   .   // '+' [1,'p']
.   .   .   if (*p ++ == '+') {
.   .   .   .   // 'p' [1,'y']
.   .   .   .   if (*p ++ == 'p') {
.   .   .   .   .   // 'y' [1,'-']
.   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   // '-' [1,'t']
.   .   .   .   .   .   if (*p ++ == '-') {
.   .   .   .   .   .   .   // 't' [1,'r']
.   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   // 'r' [1,'e']
.   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   // 'e' [1,'e']
.   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   // 'e' [1,'-']
.   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   // '-' [1,'d']
.   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '-') {
.   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'m']
.   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'm' [1,'o']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'm') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'o' [1,'/']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'o') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '/' [3,'c']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '/') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'c']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'c' [1,'-']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'c') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '-' [2,'f']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '-') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/.src-dirs";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'f' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'l']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'l' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/.src-files";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'b' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'b':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'n']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'n' [1,'.']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'n') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [1,'p']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '.') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'p' [1,'a']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'p') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'a' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [1,'c']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'c' [1,'h']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'c') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'h' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'h') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/bin.patch";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'c' [1,'+']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'c':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '+' [1,'+']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '+') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '+' [1,'p']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '+') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'p' [1,'y']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'p') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'y' [2,'/']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '-' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [2,'.']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '-' [3,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'a' [1,'u']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'a':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'u' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'u') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [1,'h']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'h' [1,'o']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'h') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'o' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'o') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'.']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '.') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [1,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-author.txt";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'m']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'm' [1,'o']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'm') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'o' [1,'.']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'o') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '.') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [1,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-demo.txt";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'r':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'a']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'a' [1,'d']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'m']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'm' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'm') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'.']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [2,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '.') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'p' [1,'d']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'f']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'f' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.pdf";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [2,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.tex";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.txt";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [2,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'p' [1,'d']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'f']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'f' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.pdf";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [2,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.tex";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.txt";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '/' [4,'R']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '/':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'c']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'c' [1,'-']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'c') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '-' [2,'f']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '-') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-dirs";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'f' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'l']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'l' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-files";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'A' [1,'U']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'A':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'U' [1,'T']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'U') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'T' [1,'H']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'T') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'H' [1,'O']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'H') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'O' [1,'R']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'O') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'R' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'R') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/AUTHOR";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'M' [1,'a']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'M':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'a' [1,'k']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'k' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'k') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'f']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'f' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'l']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'l' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/Makefile";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'R' [1,'E']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'R':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'E' [1,'A']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'E') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'A' [1,'D']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'A') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'D' [1,'M']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'D') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'M' [1,'E']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'M') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'E' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'E') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/README";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-wide-c-code-filenames-ternary ]-----------------------------------------

$ ../src/trie --attrs --dots --gen=wide --output=c-code --trie=ternary < filenames.txt
.   // [1,'c']
.   // 'c' [1,'+']
.   if (*p ++ == 'c') {
.   .   // '+' [1,'+']
.   .   if (*p ++ == '+') {
.   .   .   // '+' [1,'p']
.   .   .   if (*p ++ == '+') {
.   .   .   .   // 'p' [1,'y']
.   .   .   .   if (*p ++ == 'p') {
.   .   .   .   .   // 'y' [1,'-']
.   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   // '-' [1,'t']
.   .   .   .   .   .   if (*p ++ == '-') {
.   .   .   .   .   .   .   // 't' [1,'r']
.   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   // 'r' [1,'e']
.   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   // 'e' [1,'e']
.   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   // 'e' [1,'-']
.   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   // '-' [1,'d']
.   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '-') {
.   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'m']
.   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'm' [1,'o']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'm') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'o' [1,'/']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'o') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '/' [3,'c']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '/') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'c']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'c' [1,'-']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'c') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '-' [2,'f']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '-') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/.src-dirs";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'f' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'l']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'l' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/.src-files";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'b' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'b':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'n']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'n' [1,'.']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'n') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [1,'p']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '.') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'p' [1,'a']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'p') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'a' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [1,'c']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'c' [1,'h']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'c') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'h' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'h') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/bin.patch";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'c' [1,'+']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'c':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '+' [1,'+']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '+') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '+' [1,'p']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '+') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'p' [1,'y']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'p') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'y' [2,'/']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'y') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '-' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [2,'.']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '-' [3,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'a' [1,'u']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'a':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'u' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'u') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [1,'h']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'h' [1,'o']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'h') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'o' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'o') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'.']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '.') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [1,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-author.txt";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'m']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'm' [1,'o']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'm') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'o' [1,'.']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'o') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '.') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [1,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-demo.txt";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'r':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'a']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'a' [1,'d']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'m']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'm' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'm') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'.']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [2,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '.') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'p' [1,'d']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'f']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'f' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.pdf";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [2,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.tex";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.txt";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [2,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'p' [1,'d']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'f']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'd') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'f' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.pdf";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [2,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'x']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.tex";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'x' [1,'t']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 't' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.txt";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '/' [4,'R']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '/':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '.' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'c']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'c' [1,'-']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'c') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // '-' [2,'f']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == '-') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'd' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'r']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'r' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'r') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-dirs";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'f' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'l']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'l' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'s']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 's' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 's') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-files";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'A' [1,'U']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'A':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'U' [1,'T']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'U') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'T' [1,'H']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'T') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'H' [1,'O']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'H') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'O' [1,'R']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'O') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'R' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'R') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/AUTHOR";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'M' [1,'a']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'M':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'a' [1,'k']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'a') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'k' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'k') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [1,'f']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'f' [1,'i']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'f') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'i' [1,'l']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'i') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'l' [1,'e']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'l') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'e' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'e') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/Makefile";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'R' [1,'E']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   case 'R':
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'E' [1,'A']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'E') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'A' [1,'D']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'A') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'D' [1,'M']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'D') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'M' [1,'E']
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'M') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   // 'E' [0]
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'E') {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/README";
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-base0-array ]--------------------------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --trie=array "$@"; }
$ print a|trie
    if (*p ++ == 'a' &&
        *p == 0)
        return "a";
    return error;
$ print a ab|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
    }
    return error;
$ print a ab abc|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            if (*p ++ == 'c' &&
                *p == 0)
                return "abc";
        }
    }
    return error;
$ print a b|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        if (*p == 0)
            return "b";
    }
    return error;
$ print a b abc bac abd|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
            }
        }
        return error;
    case 'b':
        if (*p == 0)
            return "b";
        if (*p ++ == 'a' &&
            *p ++ == 'c' &&
            *p == 0)
            return "bac";
    }
    return error;
$ print a bb ba c|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print a bb ba cc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p == 0)
            return "cc";
    }
    return error;
$ print a bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print a bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p == 0)
            return "cde";
    }
    return error;
$ print a bb ba cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f' &&
            *p == 0)
            return "cdef";
    }
    return error;
$ print a bb ba cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if (*p ++ == 'g' &&
                *p == 0)
                return "cdefg";
        }
    }
    return error;
$ print a bb bac cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'c' &&
                *p == 0)
                return "bac";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f' &&
            *p == 0)
            return "cdef";
    }
    return error;
$ print a bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print a bbx bay ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'y' &&
                *p == 0)
                return "bay";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print a cde cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f' &&
                *p == 0)
                return "cdef";
        }
    }
    return error;
$ print a cde cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if (*p ++ == 'g' &&
                    *p == 0)
                    return "cdefg";
            }
        }
    }
    return error;
$ print a cde cdef cdefgh|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if (*p ++ == 'g' &&
                    *p ++ == 'h' &&
                    *p == 0)
                    return "cdefgh";
            }
        }
    }
    return error;
$ print a cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if (*p ++ == 'g' &&
                *p == 0)
                return "cdefg";
        }
    }
    return error;
$ print ab|trie
    if (*p ++ == 'a' &&
        *p ++ == 'b' &&
        *p == 0)
        return "ab";
    return error;
$ print ab bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print ab bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p == 0)
            return "cde";
    }
    return error;
$ print ab bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print ab c|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print abc bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p ++ == 'c' &&
            *p == 0)
            return "abc";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print abcd abde abef|trie
    if (*p ++ == 'a' &&
        *p ++ == 'b') {
        switch (*p ++) {
        case 'c':
            if (*p ++ == 'd' &&
                *p == 0)
                return "abcd";
            return error;
        case 'd':
            if (*p ++ == 'e' &&
                *p == 0)
                return "abde";
            return error;
        case 'e':
            if (*p ++ == 'f' &&
                *p == 0)
                return "abef";
        }
    }
    return error;
$ print abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
        }
    }
    return error;
$ print ac ab|trie
    if (*p ++ == 'a') {
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            return error;
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print aef ae abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ae";
            if (*p ++ == 'f' &&
                *p == 0)
                return "aef";
        }
    }
    return error;
$ print cde cdef cdefgh|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd' &&
        *p ++ == 'e') {
        if (*p == 0)
            return "cde";
        if (*p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if (*p ++ == 'g' &&
                *p ++ == 'h' &&
                *p == 0)
                return "cdefgh";
        }
    }
    return error;
$ print cdef cdefg|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd' &&
        *p ++ == 'e' &&
        *p ++ == 'f') {
        if (*p == 0)
            return "cdef";
        if (*p ++ == 'g' &&
            *p == 0)
            return "cdefg";
    }
    return error;
$ print cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd') {
        switch (*p ++) {
        case 'e':
            if (*p ++ == 'x' &&
                *p == 0)
                return "cdex";
            return error;
        case 'f':
            if (*p ++ == 'y' &&
                *p == 0)
                return "cdfy";
            return error;
        case 'g':
            if (*p ++ == 'z' &&
                *p == 0)
                return "cdgz";
            return error;
        case 'h':
            if (*p ++ == 'w' &&
                *p == 0)
                return "cdhw";
        }
    }
    return error;
$ print ce cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        switch (*p ++) {
        case 'd':
            switch (*p ++) {
            case 'e':
                if (*p ++ == 'x' &&
                    *p == 0)
                    return "cdex";
                return error;
            case 'f':
                if (*p ++ == 'y' &&
                    *p == 0)
                    return "cdfy";
                return error;
            case 'g':
                if (*p ++ == 'z' &&
                    *p == 0)
                    return "cdgz";
                return error;
            case 'h':
                if (*p ++ == 'w' &&
                    *p == 0)
                    return "cdhw";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ce";
        }
    }
    return error;
$ print pot potato pottery tattoo tempo|trie
    switch (*p ++) {
    case 'p':
        if (*p ++ == 'o' &&
            *p ++ == 't') {
            if (*p == 0)
                return "pot";
            switch (*p ++) {
            case 'a':
                if (*p ++ == 't' &&
                    *p ++ == 'o' &&
                    *p == 0)
                    return "potato";
                return error;
            case 't':
                if (*p ++ == 'e' &&
                    *p ++ == 'r' &&
                    *p ++ == 'y' &&
                    *p == 0)
                    return "pottery";
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 't' &&
                *p ++ == 't' &&
                *p ++ == 'o' &&
                *p ++ == 'o' &&
                *p == 0)
                return "tattoo";
            return error;
        case 'e':
            if (*p ++ == 'm' &&
                *p ++ == 'p' &&
                *p ++ == 'o' &&
                *p == 0)
                return "tempo";
        }
    }
    return error;
$

--[ gen-compact-c-code-base0-ternary ]------------------------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --trie=ternary "$@"; }
$ print a|trie
    if (*p ++ == 'a' &&
        *p == 0)
        return "a";
    return error;
$ print a ab|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
    }
    return error;
$ print a ab abc|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            if (*p ++ == 'c' &&
                *p == 0)
                return "abc";
        }
    }
    return error;
$ print a b|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        if (*p == 0)
            return "b";
    }
    return error;
$ print a b abc bac abd|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
            }
        }
        return error;
    case 'b':
        if (*p == 0)
            return "b";
        if (*p ++ == 'a' &&
            *p ++ == 'c' &&
            *p == 0)
            return "bac";
    }
    return error;
$ print a bb ba c|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print a bb ba cc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p == 0)
            return "cc";
    }
    return error;
$ print a bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print a bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p == 0)
            return "cde";
    }
    return error;
$ print a bb ba cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f' &&
            *p == 0)
            return "cdef";
    }
    return error;
$ print a bb ba cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if (*p ++ == 'g' &&
                *p == 0)
                return "cdefg";
        }
    }
    return error;
$ print a bb bac cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'c' &&
                *p == 0)
                return "bac";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f' &&
            *p == 0)
            return "cdef";
    }
    return error;
$ print a bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print a bbx bay ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'y' &&
                *p == 0)
                return "bay";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print a cde cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f' &&
                *p == 0)
                return "cdef";
        }
    }
    return error;
$ print a cde cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if (*p ++ == 'g' &&
                    *p == 0)
                    return "cdefg";
            }
        }
    }
    return error;
$ print a cde cdef cdefgh|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if (*p ++ == 'g' &&
                    *p ++ == 'h' &&
                    *p == 0)
                    return "cdefgh";
            }
        }
    }
    return error;
$ print a cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if (*p ++ == 'g' &&
                *p == 0)
                return "cdefg";
        }
    }
    return error;
$ print ab|trie
    if (*p ++ == 'a' &&
        *p ++ == 'b' &&
        *p == 0)
        return "ab";
    return error;
$ print ab bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print ab bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p == 0)
            return "cde";
    }
    return error;
$ print ab bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print ab c|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print abc bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p ++ == 'c' &&
            *p == 0)
            return "abc";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p ++ == 'c' &&
            *p == 0)
            return "ccc";
    }
    return error;
$ print abcd abde abef|trie
    if (*p ++ == 'a' &&
        *p ++ == 'b') {
        switch (*p ++) {
        case 'c':
            if (*p ++ == 'd' &&
                *p == 0)
                return "abcd";
            return error;
        case 'd':
            if (*p ++ == 'e' &&
                *p == 0)
                return "abde";
            return error;
        case 'e':
            if (*p ++ == 'f' &&
                *p == 0)
                return "abef";
        }
    }
    return error;
$ print abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
        }
    }
    return error;
$ print ac ab|trie
    if (*p ++ == 'a') {
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            return error;
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print aef ae abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ae";
            if (*p ++ == 'f' &&
                *p == 0)
                return "aef";
        }
    }
    return error;
$ print cde cdef cdefgh|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd' &&
        *p ++ == 'e') {
        if (*p == 0)
            return "cde";
        if (*p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if (*p ++ == 'g' &&
                *p ++ == 'h' &&
                *p == 0)
                return "cdefgh";
        }
    }
    return error;
$ print cdef cdefg|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd' &&
        *p ++ == 'e' &&
        *p ++ == 'f') {
        if (*p == 0)
            return "cdef";
        if (*p ++ == 'g' &&
            *p == 0)
            return "cdefg";
    }
    return error;
$ print cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd') {
        switch (*p ++) {
        case 'e':
            if (*p ++ == 'x' &&
                *p == 0)
                return "cdex";
            return error;
        case 'f':
            if (*p ++ == 'y' &&
                *p == 0)
                return "cdfy";
            return error;
        case 'g':
            if (*p ++ == 'z' &&
                *p == 0)
                return "cdgz";
            return error;
        case 'h':
            if (*p ++ == 'w' &&
                *p == 0)
                return "cdhw";
        }
    }
    return error;
$ print ce cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        switch (*p ++) {
        case 'd':
            switch (*p ++) {
            case 'e':
                if (*p ++ == 'x' &&
                    *p == 0)
                    return "cdex";
                return error;
            case 'f':
                if (*p ++ == 'y' &&
                    *p == 0)
                    return "cdfy";
                return error;
            case 'g':
                if (*p ++ == 'z' &&
                    *p == 0)
                    return "cdgz";
                return error;
            case 'h':
                if (*p ++ == 'w' &&
                    *p == 0)
                    return "cdhw";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ce";
        }
    }
    return error;
$ print pot potato pottery tattoo tempo|trie
    switch (*p ++) {
    case 'p':
        if (*p ++ == 'o' &&
            *p ++ == 't') {
            if (*p == 0)
                return "pot";
            switch (*p ++) {
            case 'a':
                if (*p ++ == 't' &&
                    *p ++ == 'o' &&
                    *p == 0)
                    return "potato";
                return error;
            case 't':
                if (*p ++ == 'e' &&
                    *p ++ == 'r' &&
                    *p ++ == 'y' &&
                    *p == 0)
                    return "pottery";
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 't' &&
                *p ++ == 't' &&
                *p ++ == 'o' &&
                *p ++ == 'o' &&
                *p == 0)
                return "tattoo";
            return error;
        case 'e':
            if (*p ++ == 'm' &&
                *p ++ == 'p' &&
                *p ++ == 'o' &&
                *p == 0)
                return "tempo";
        }
    }
    return error;
$

--[ gen-compact-c-code-base ]---------------------------------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --attrs --no-dots "$@"; }
$ print a ab abc abd ac|trie
    // [1,'a']
    // [0,"",'a',[2,'c']]
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        // [0,"",'b',[2,'d']]
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            // [0,"",'c',[0]]
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            // [0,"",'d',[0]]
            case 'd':
                if (*p == 0)
                    return "abd";
            }
            return error;
        // [0,"",'c',[0]]
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print a ab abc abd ac|trie -t int
    // [1,'a']
    // [0,"",'a',[2,'c']]
    if (*p ++ == 'a') {
        if (*p == 0)
            return 1;
        switch (*p ++) {
        // [0,"",'b',[2,'d']]
        case 'b':
            if (*p == 0)
                return 2;
            switch (*p ++) {
            // [0,"",'c',[0]]
            case 'c':
                if (*p == 0)
                    return 3;
                return error;
            // [0,"",'d',[0]]
            case 'd':
                if (*p == 0)
                    return 4;
            }
            return error;
        // [0,"",'c',[0]]
        case 'c':
            if (*p == 0)
                return 5;
        }
    }
    return error;
$ print a ab abc abd ac|trie -t float
    // [1,'a']
    // [0,"",'a',[2,'c']]
    if (*p ++ == 'a') {
        if (*p == 0)
            return 1.0;
        switch (*p ++) {
        // [0,"",'b',[2,'d']]
        case 'b':
            if (*p == 0)
                return 2.0;
            switch (*p ++) {
            // [0,"",'c',[0]]
            case 'c':
                if (*p == 0)
                    return 3.0;
                return error;
            // [0,"",'d',[0]]
            case 'd':
                if (*p == 0)
                    return 4.0;
            }
            return error;
        // [0,"",'c',[0]]
        case 'c':
            if (*p == 0)
                return 5.0;
        }
    }
    return error;
$

--[ gen-compact-c-code-base-array ]---------------------------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --attrs --dots --trie=array "$@"; }
$ print|trie 
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
.   // [1,'a']
.   // [0,"",'a',[0]]
.   if (*p ++ == 'a' &&
.   .   *p == 0)
.   .   return "a";
.   return error;
$ print a b|trie
.   // [2,'b']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   }
.   return error;
$ print a b c|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   .   return error;
.   // [0,"",'c',[0]]
.   case 'c':
.   .   if (*p == 0)
.   .   .   return "c";
.   }
.   return error;
$ print a ab abc|trie
.   // [1,'a']
.   // [0,"",'a',[1,'b']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"",'b',[1,'c']]
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   // [0,"",'c',[0]]
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "abc";
.   .   }
.   }
.   return error;
$ print a ab ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac ad|trie
.   // [1,'a']
.   // [0,"",'a',[3,'d']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "ad";
.   .   }
.   }
.   return error;
$ print a abd ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"b",'d',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p == 0)
.   .   .   .   return "abd";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac acd|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"",'d',[0]]
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p == 0)
.   .   .   .   return "acd";
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (*p ++ == 'c' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p == 0)
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"b",'b',[0]]
.   case 'b':
.   .   if (*p ++ == 'b' &&
.   .   .   *p == 0)
.   .   .   return "bb";
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (*p ++ == 'c' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p == 0)
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (*p ++ == 'c' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p == 0)
.   .   .   return "ccc";
.   }
.   return error;
$ print abc abd acde|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"cd",'e',[0]]
.   .   case 'c':
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"d",'e',[0]]
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde acfg|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[2,'f']]
.   .   case 'c':
.   .   .   switch (*p ++) {
.   .   .   // [0,"d",'e',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p ++ == 'e' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "acde";
.   .   .   .   return error;
.   .   .   // [0,"f",'g',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p ++ == 'g' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "acfg";
.   .   .   }
.   .   }
.   }
.   return error;
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'f']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cde";
.   .   .   return error;
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'g']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [0,"g",'e',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cge";
.   .   }
.   }
.   return error;
$ print a abcd abcdefg h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[1,'e']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p ++ == 'f' &&
.   .   .   .   *p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "abcdefg";
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (*p ++ == 'i' &&
.   .   .   *p ++ == 'j' &&
.   .   .   *p ++ == 'k' &&
.   .   .   *p == 0)
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p ++ == 'f' &&
.   .   .   .   .   *p ++ == 'g' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (*p ++ == 'y' &&
.   .   .   .   .   *p ++ == 'z' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (*p ++ == 'i' &&
.   .   .   *p ++ == 'j' &&
.   .   .   *p ++ == 'k' &&
.   .   .   *p == 0)
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p ++ == 'f' &&
.   .   .   .   .   *p ++ == 'g' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (*p ++ == 'y' &&
.   .   .   .   .   *p ++ == 'z' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[2,'l']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   switch (*p ++) {
.   .   // [0,"ij",'k',[0]]
.   .   case 'i':
.   .   .   if (*p ++ == 'j' &&
.   .   .   .   *p ++ == 'k' &&
.   .   .   .   *p == 0)
.   .   .   .   return "hijk";
.   .   .   return error;
.   .   // [0,"l",'m',[0]]
.   .   case 'l':
.   .   .   if (*p ++ == 'm' &&
.   .   .   .   *p == 0)
.   .   .   .   return "hlm";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-base-ternary ]-------------------------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --attrs --dots --trie=ternary "$@"; }
$ print|trie 
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
.   // [1,'a']
.   // [0,"",'a',[0]]
.   if (*p ++ == 'a' &&
.   .   *p == 0)
.   .   return "a";
.   return error;
$ print a b|trie
.   // [2,'b']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   }
.   return error;
$ print a b c|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   .   return error;
.   // [0,"",'c',[0]]
.   case 'c':
.   .   if (*p == 0)
.   .   .   return "c";
.   }
.   return error;
$ print a ab abc|trie
.   // [1,'a']
.   // [0,"",'a',[1,'b']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"",'b',[1,'c']]
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   // [0,"",'c',[0]]
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "abc";
.   .   }
.   }
.   return error;
$ print a ab ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac ad|trie
.   // [1,'a']
.   // [0,"",'a',[3,'d']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "ad";
.   .   }
.   }
.   return error;
$ print a abd ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"b",'d',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p == 0)
.   .   .   .   return "abd";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac acd|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"",'d',[0]]
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p == 0)
.   .   .   .   return "acd";
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (*p ++ == 'c' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p == 0)
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"b",'b',[0]]
.   case 'b':
.   .   if (*p ++ == 'b' &&
.   .   .   *p == 0)
.   .   .   return "bb";
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (*p ++ == 'c' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p == 0)
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (*p ++ == 'c' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p == 0)
.   .   .   return "ccc";
.   }
.   return error;
$ print abc abd acde|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"cd",'e',[0]]
.   .   case 'c':
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"d",'e',[0]]
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde acfg|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[2,'f']]
.   .   case 'c':
.   .   .   switch (*p ++) {
.   .   .   // [0,"d",'e',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p ++ == 'e' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "acde";
.   .   .   .   return error;
.   .   .   // [0,"f",'g',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p ++ == 'g' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "acfg";
.   .   .   }
.   .   }
.   }
.   return error;
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'f']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cde";
.   .   .   return error;
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'g']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [0,"g",'e',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cge";
.   .   }
.   }
.   return error;
$ print a abcd abcdefg h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[1,'e']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p ++ == 'f' &&
.   .   .   .   *p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "abcdefg";
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (*p ++ == 'i' &&
.   .   .   *p ++ == 'j' &&
.   .   .   *p ++ == 'k' &&
.   .   .   *p == 0)
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p ++ == 'f' &&
.   .   .   .   .   *p ++ == 'g' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (*p ++ == 'y' &&
.   .   .   .   .   *p ++ == 'z' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (*p ++ == 'i' &&
.   .   .   *p ++ == 'j' &&
.   .   .   *p ++ == 'k' &&
.   .   .   *p == 0)
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p ++ == 'f' &&
.   .   .   .   .   *p ++ == 'g' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (*p ++ == 'y' &&
.   .   .   .   .   *p ++ == 'z' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[2,'l']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   switch (*p ++) {
.   .   // [0,"ij",'k',[0]]
.   .   case 'i':
.   .   .   if (*p ++ == 'j' &&
.   .   .   .   *p ++ == 'k' &&
.   .   .   .   *p == 0)
.   .   .   .   return "hijk";
.   .   .   return error;
.   .   // [0,"l",'m',[0]]
.   .   case 'l':
.   .   .   if (*p ++ == 'm' &&
.   .   .   .   *p == 0)
.   .   .   .   return "hlm";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-alphabets-array ]----------------------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --trie=array < alphabets.txt
.   // [25,'z']
.   switch (*p ++) {
.   // [0,"",'a',[8,'z']]
.   case 'a':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "aa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "af";
.   .   .   return error;
.   .   // [0,"g",'q',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "agq";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "ak";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "am";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ar";
.   .   .   return error;
.   .   // [0,"",'s',[2,'t']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "as";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'a',[0]]
.   .   .   case 'a':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "asa";
.   .   .   .   return error;
.   .   .   // [0,"",'t',[0]]
.   .   .   case 't':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ast";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "az";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'C' &&
.   .   .   .   *p ++ == 'y' &&
.   .   .   .   *p ++ == 'r' &&
.   .   .   .   *p ++ == 'l' &&
.   .   .   .   *p == 0)
.   .   .   .   return "az_Cyrl";
.   .   }
.   .   return error;
.   // [0,"",'b',[9,'y']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "bas";
.   .   .   return error;
.   .   // [0,"",'e',[2,'z']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "be";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bem";
.   .   .   .   return error;
.   .   .   // [0,"",'z',[0]]
.   .   .   case 'z':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bez";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "bg";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "bm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "bn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "bo";
.   .   .   return error;
.   .   // [0,"",'r',[1,'x']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "br";
.   .   .   // [0,"",'x',[0]]
.   .   .   if (*p ++ == 'x' &&
.   .   .   .   *p == 0)
.   .   .   .   return "brx";
.   .   .   return error;
.   .   // [0,"",'s',[1,'_']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "bs";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'C' &&
.   .   .   .   *p ++ == 'y' &&
.   .   .   .   *p ++ == 'r' &&
.   .   .   .   *p ++ == 'l' &&
.   .   .   .   *p == 0)
.   .   .   .   return "bs_Cyrl";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "byn";
.   .   }
.   .   return error;
.   // [0,"",'c',[5,'y']]
.   case 'c':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ca";
.   .   .   return error;
.   .   // [0,"g",'g',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cgg";
.   .   .   return error;
.   .   // [0,"h",'r',[0]]
.   .   case 'h':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "chr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "cs";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "cy";
.   .   }
.   .   return error;
.   // [0,"",'d',[6,'z']]
.   case 'd':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'v']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "da";
.   .   .   // [0,"",'v',[0]]
.   .   .   if (*p ++ == 'v' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dav";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "de";
.   .   .   return error;
.   .   // [0,"j",'e',[0]]
.   .   case 'j':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dje";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dua";
.   .   .   return error;
.   .   // [0,"y",'o',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dyo";
.   .   .   return error;
.   .   // [0,"",'z',[0]]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "dz";
.   .   }
.   .   return error;
.   // [0,"",'e',[9,'w']]
.   case 'e':
.   .   switch (*p ++) {
.   .   // [0,"b",'u',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'u' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ebu";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ee";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "el";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "en";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "eo";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "es";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "et";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "eu";
.   .   .   return error;
.   .   // [0,"w",'o',[0]]
.   .   case 'w':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ewo";
.   .   }
.   .   return error;
.   // [0,"",'f',[7,'y']]
.   case 'f':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "fa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "ff";
.   .   .   return error;
.   .   // [0,"",'i',[1,'l']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "fi";
.   .   .   // [0,"",'l',[0]]
.   .   .   if (*p ++ == 'l' &&
.   .   .   .   *p == 0)
.   .   .   .   return "fil";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "fo";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "fr";
.   .   .   return error;
.   .   // [0,"u",'r',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "fur";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "fy";
.   .   }
.   .   return error;
.   // [0,"",'g',[6,'v']]
.   case 'g':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ga";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "gd";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "gl";
.   .   .   return error;
.   .   // [0,"s",'w',[0]]
.   .   case 's':
.   .   .   if (*p ++ == 'w' &&
.   .   .   .   *p == 0)
.   .   .   .   return "gsw";
.   .   .   return error;
.   .   // [0,"",'u',[1,'z']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "gu";
.   .   .   // [0,"",'z',[0]]
.   .   .   if (*p ++ == 'z' &&
.   .   .   .   *p == 0)
.   .   .   .   return "guz";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "gv";
.   .   }
.   .   return error;
.   // [0,"",'h',[6,'y']]
.   case 'h':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'w']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ha";
.   .   .   // [0,"",'w',[0]]
.   .   .   if (*p ++ == 'w' &&
.   .   .   .   *p == 0)
.   .   .   .   return "haw";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "he";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "hi";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "hr";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "hu";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "hy";
.   .   }
.   .   return error;
.   // [0,"",'i',[6,'t']]
.   case 'i':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ia";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "id";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ig";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ii";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "is";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "it";
.   .   }
.   .   return error;
.   // [0,"",'j',[3,'m']]
.   case 'j':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ja";
.   .   .   return error;
.   .   // [0,"g",'o',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "jgo";
.   .   .   return error;
.   .   // [0,"m",'c',[0]]
.   .   case 'm':
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "jmc";
.   .   }
.   .   return error;
.   // [0,"",'k',[13,'y']]
.   case 'k':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'m']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ka";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kab";
.   .   .   .   return error;
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kam";
.   .   .   }
.   .   .   return error;
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kde";
.   .   .   return error;
.   .   // [0,"e",'a',[0]]
.   .   case 'e':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kea";
.   .   .   return error;
.   .   // [0,"h",'q',[0]]
.   .   case 'h':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "khq";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ki";
.   .   .   return error;
.   .   // [0,"",'k',[1,'j']]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "kk";
.   .   .   // [0,"",'j',[0]]
.   .   .   if (*p ++ == 'j' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kkj";
.   .   .   return error;
.   .   // [0,"",'l',[1,'n']]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "kl";
.   .   .   // [0,"",'n',[0]]
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kln";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "km";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "kn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'k']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ko";
.   .   .   // [0,"",'k',[0]]
.   .   .   if (*p ++ == 'k' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kok";
.   .   .   return error;
.   .   // [0,"",'s',[3,'h']]
.   .   case 's':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksb";
.   .   .   .   return error;
.   .   .   // [0,"",'f',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksf";
.   .   .   .   return error;
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksh";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'w',[0]]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "kw";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "ky";
.   .   }
.   .   return error;
.   // [0,"",'l',[8,'v']]
.   case 'l':
.   .   switch (*p ++) {
.   .   // [0,"a",'g',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "lag";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "lg";
.   .   .   return error;
.   .   // [0,"k",'t',[0]]
.   .   case 'k':
.   .   .   if (*p ++ == 't' &&
.   .   .   .   *p == 0)
.   .   .   .   return "lkt";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "ln";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "lo";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "lt";
.   .   .   return error;
.   .   // [0,"",'u',[2,'y']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "lu";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luo";
.   .   .   .   return error;
.   .   .   // [0,"",'y',[0]]
.   .   .   case 'y':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luy";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "lv";
.   .   }
.   .   return error;
.   // [0,"",'m',[12,'y']]
.   case 'm':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mas";
.   .   .   return error;
.   .   // [0,"e",'r',[0]]
.   .   case 'e':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mer";
.   .   .   return error;
.   .   // [0,"f",'e',[0]]
.   .   case 'f':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mfe";
.   .   .   return error;
.   .   // [0,"",'g',[2,'o']]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "mg";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgh";
.   .   .   .   return error;
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgo";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "mk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "ml";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "mn";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "mr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ms";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "mt";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mua";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "my";
.   .   }
.   .   return error;
.   // [0,"",'n',[11,'y']]
.   case 'n':
.   .   switch (*p ++) {
.   .   // [0,"a",'q',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "naq";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "nb";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "nd";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ne";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "nl";
.   .   .   return error;
.   .   // [0,"m",'g',[0]]
.   .   case 'm':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nmg";
.   .   .   return error;
.   .   // [0,"",'n',[1,'h']]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "nn";
.   .   .   // [0,"",'h',[0]]
.   .   .   if (*p ++ == 'h' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nnh";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "nr";
.   .   .   return error;
.   .   // [0,"s",'o',[0]]
.   .   case 's':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nso";
.   .   .   return error;
.   .   // [0,"u",'s',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nus";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nyn";
.   .   }
.   .   return error;
.   // [0,"",'o',[3,'s']]
.   case 'o':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "om";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "or";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "os";
.   .   }
.   .   return error;
.   // [0,"",'p',[4,'t']]
.   case 'p':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'_']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "pa";
.   .   .   // [0,"_Ara",'b',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'A' &&
.   .   .   .   *p ++ == 'r' &&
.   .   .   .   *p ++ == 'a' &&
.   .   .   .   *p ++ == 'b' &&
.   .   .   .   *p == 0)
.   .   .   .   return "pa_Arab";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "pl";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ps";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "pt";
.   .   }
.   .   return error;
.   // [0,"",'r',[5,'w']]
.   case 'r':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "rm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "rn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'f']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ro";
.   .   .   // [0,"",'f',[0]]
.   .   .   if (*p ++ == 'f' &&
.   .   .   .   *p == 0)
.   .   .   .   return "rof";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "ru";
.   .   .   return error;
.   .   // [0,"",'w',[1,'k']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "rw";
.   .   .   // [0,"",'k',[0]]
.   .   .   if (*p ++ == 'k' &&
.   .   .   .   *p == 0)
.   .   .   .   return "rwk";
.   .   }
.   .   return error;
.   // [0,"",'s',[16,'w']]
.   case 's':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'q']]
.   .   case 'a':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sah";
.   .   .   .   return error;
.   .   .   // [0,"",'q',[0]]
.   .   .   case 'q':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "saq";
.   .   .   }
.   .   .   return error;
.   .   // [0,"b",'p',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'p' &&
.   .   .   .   *p == 0)
.   .   .   .   return "sbp";
.   .   .   return error;
.   .   // [0,"",'e',[2,'s']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "se";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "seh";
.   .   .   .   return error;
.   .   .   // [0,"",'s',[0]]
.   .   .   case 's':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ses";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "sg";
.   .   .   return error;
.   .   // [0,"h",'i',[1,'_']]
.   .   case 'h':
.   .   .   if (*p ++ == 'i') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "shi";
.   .   .   .   // [1,"h_Lat",'n',[0]]
.   .   .   .   if (*p ++ == '_' &&
.   .   .   .   .   *p ++ == 'L' &&
.   .   .   .   .   *p ++ == 'a' &&
.   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   *p ++ == 'n' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "shi_Latn";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "si";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "sk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "sl";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "sn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "so";
.   .   .   return error;
.   .   // [0,"",'q',[0]]
.   .   case 'q':
.   .   .   if (*p == 0)
.   .   .   .   return "sq";
.   .   .   return error;
.   .   // [0,"",'r',[1,'_']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "sr";
.   .   .   // [0,"_Lat",'n',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'L' &&
.   .   .   .   *p ++ == 'a' &&
.   .   .   .   *p ++ == 't' &&
.   .   .   .   *p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "sr_Latn";
.   .   .   return error;
.   .   // [0,"",'s',[1,'y']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ss";
.   .   .   // [0,"",'y',[0]]
.   .   .   if (*p ++ == 'y' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ssy";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "st";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "sv";
.   .   .   return error;
.   .   // [0,"",'w',[1,'c']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "sw";
.   .   .   // [0,"",'c',[0]]
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "swc";
.   .   }
.   .   return error;
.   // [0,"",'t',[11,'z']]
.   case 't':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ta";
.   .   .   return error;
.   .   // [0,"",'e',[1,'o']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "te";
.   .   .   // [0,"",'o',[0]]
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "teo";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "tg";
.   .   .   return error;
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "th";
.   .   .   return error;
.   .   // [0,"",'i',[2,'g']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ti";
.   .   .   switch (*p ++) {
.   .   .   // [0,"_E",'R',[0]]
.   .   .   case '_':
.   .   .   .   if (*p ++ == 'E' &&
.   .   .   .   .   *p ++ == 'R' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "ti_ER";
.   .   .   .   return error;
.   .   .   // [0,"",'g',[0]]
.   .   .   case 'g':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tig";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "tn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "to";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "tr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ts";
.   .   .   return error;
.   .   // [0,"w",'q',[0]]
.   .   case 'w':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "twq";
.   .   .   return error;
.   .   // [0,"z",'m',[0]]
.   .   case 'z':
.   .   .   if (*p ++ == 'm' &&
.   .   .   .   *p == 0)
.   .   .   .   return "tzm";
.   .   }
.   .   return error;
.   // [0,"",'u',[4,'z']]
.   case 'u':
.   .   switch (*p ++) {
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ug";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "uk";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ur";
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "uz";
.   .   .   // [0,"",'_',[2,'C']]
.   .   .   if (*p ++ == '_') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [0,"Ara",'b',[0]]
.   .   .   .   case 'A':
.   .   .   .   .   if (*p ++ == 'r' &&
.   .   .   .   .   .   *p ++ == 'a' &&
.   .   .   .   .   .   *p ++ == 'b' &&
.   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   return "uz_Arab";
.   .   .   .   .   return error;
.   .   .   .   // [0,"Cyr",'l',[0]]
.   .   .   .   case 'C':
.   .   .   .   .   if (*p ++ == 'y' &&
.   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   *p ++ == 'l' &&
.   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   return "uz_Cyrl";
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'v',[5,'u']]
.   case 'v':
.   .   switch (*p ++) {
.   .   // [0,"ai_Lat",'n',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'i' &&
.   .   .   .   *p ++ == '_' &&
.   .   .   .   *p ++ == 'L' &&
.   .   .   .   *p ++ == 'a' &&
.   .   .   .   *p ++ == 't' &&
.   .   .   .   *p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "vai_Latn";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ve";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "vi";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "vo";
.   .   .   return error;
.   .   // [0,"u",'n',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "vun";
.   .   }
.   .   return error;
.   // [0,"w",'a',[2,'l']]
.   case 'w':
.   .   if (*p ++ == 'a') {
.   .   .   switch (*p ++) {
.   .   .   // [1,"w",'e',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wae";
.   .   .   .   return error;
.   .   .   // [1,"w",'l',[0]]
.   .   .   case 'l':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wal";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'x',[2,'o']]
.   case 'x':
.   .   switch (*p ++) {
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "xh";
.   .   .   return error;
.   .   // [0,"o",'g',[0]]
.   .   case 'o':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "xog";
.   .   }
.   .   return error;
.   // [0,"",'y',[2,'o']]
.   case 'y':
.   .   switch (*p ++) {
.   .   // [0,"a",'v',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'v' &&
.   .   .   .   *p == 0)
.   .   .   .   return "yav";
.   .   .   return error;
.   .   // [0,"",'o',[1,'_']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "yo";
.   .   .   // [0,"_B",'J',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'B' &&
.   .   .   .   *p ++ == 'J' &&
.   .   .   .   *p == 0)
.   .   .   .   return "yo_BJ";
.   .   }
.   .   return error;
.   // [0,"",'z',[3,'u']]
.   case 'z':
.   .   switch (*p ++) {
.   .   // [0,"g",'h',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'h' &&
.   .   .   .   *p == 0)
.   .   .   .   return "zgh";
.   .   .   return error;
.   .   // [0,"",'h',[1,'_']]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "zh";
.   .   .   // [0,"_Han",'t',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'H' &&
.   .   .   .   *p ++ == 'a' &&
.   .   .   .   *p ++ == 'n' &&
.   .   .   .   *p ++ == 't' &&
.   .   .   .   *p == 0)
.   .   .   .   return "zh_Hant";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "zu";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-alphabets-ternary ]--------------------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --trie=ternary < alphabets.txt
.   // [25,'z']
.   switch (*p ++) {
.   // [0,"",'a',[8,'z']]
.   case 'a':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "aa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "af";
.   .   .   return error;
.   .   // [0,"g",'q',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "agq";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "ak";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "am";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ar";
.   .   .   return error;
.   .   // [0,"",'s',[2,'t']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "as";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'a',[0]]
.   .   .   case 'a':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "asa";
.   .   .   .   return error;
.   .   .   // [0,"",'t',[0]]
.   .   .   case 't':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ast";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "az";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'C' &&
.   .   .   .   *p ++ == 'y' &&
.   .   .   .   *p ++ == 'r' &&
.   .   .   .   *p ++ == 'l' &&
.   .   .   .   *p == 0)
.   .   .   .   return "az_Cyrl";
.   .   }
.   .   return error;
.   // [0,"",'b',[9,'y']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "bas";
.   .   .   return error;
.   .   // [0,"",'e',[2,'z']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "be";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bem";
.   .   .   .   return error;
.   .   .   // [0,"",'z',[0]]
.   .   .   case 'z':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bez";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "bg";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "bm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "bn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "bo";
.   .   .   return error;
.   .   // [0,"",'r',[1,'x']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "br";
.   .   .   // [0,"",'x',[0]]
.   .   .   if (*p ++ == 'x' &&
.   .   .   .   *p == 0)
.   .   .   .   return "brx";
.   .   .   return error;
.   .   // [0,"",'s',[1,'_']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "bs";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'C' &&
.   .   .   .   *p ++ == 'y' &&
.   .   .   .   *p ++ == 'r' &&
.   .   .   .   *p ++ == 'l' &&
.   .   .   .   *p == 0)
.   .   .   .   return "bs_Cyrl";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "byn";
.   .   }
.   .   return error;
.   // [0,"",'c',[5,'y']]
.   case 'c':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ca";
.   .   .   return error;
.   .   // [0,"g",'g',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cgg";
.   .   .   return error;
.   .   // [0,"h",'r',[0]]
.   .   case 'h':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "chr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "cs";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "cy";
.   .   }
.   .   return error;
.   // [0,"",'d',[6,'z']]
.   case 'd':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'v']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "da";
.   .   .   // [0,"",'v',[0]]
.   .   .   if (*p ++ == 'v' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dav";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "de";
.   .   .   return error;
.   .   // [0,"j",'e',[0]]
.   .   case 'j':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dje";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dua";
.   .   .   return error;
.   .   // [0,"y",'o',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dyo";
.   .   .   return error;
.   .   // [0,"",'z',[0]]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "dz";
.   .   }
.   .   return error;
.   // [0,"",'e',[9,'w']]
.   case 'e':
.   .   switch (*p ++) {
.   .   // [0,"b",'u',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'u' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ebu";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ee";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "el";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "en";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "eo";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "es";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "et";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "eu";
.   .   .   return error;
.   .   // [0,"w",'o',[0]]
.   .   case 'w':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ewo";
.   .   }
.   .   return error;
.   // [0,"",'f',[7,'y']]
.   case 'f':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "fa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "ff";
.   .   .   return error;
.   .   // [0,"",'i',[1,'l']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "fi";
.   .   .   // [0,"",'l',[0]]
.   .   .   if (*p ++ == 'l' &&
.   .   .   .   *p == 0)
.   .   .   .   return "fil";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "fo";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "fr";
.   .   .   return error;
.   .   // [0,"u",'r',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "fur";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "fy";
.   .   }
.   .   return error;
.   // [0,"",'g',[6,'v']]
.   case 'g':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ga";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "gd";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "gl";
.   .   .   return error;
.   .   // [0,"s",'w',[0]]
.   .   case 's':
.   .   .   if (*p ++ == 'w' &&
.   .   .   .   *p == 0)
.   .   .   .   return "gsw";
.   .   .   return error;
.   .   // [0,"",'u',[1,'z']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "gu";
.   .   .   // [0,"",'z',[0]]
.   .   .   if (*p ++ == 'z' &&
.   .   .   .   *p == 0)
.   .   .   .   return "guz";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "gv";
.   .   }
.   .   return error;
.   // [0,"",'h',[6,'y']]
.   case 'h':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'w']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ha";
.   .   .   // [0,"",'w',[0]]
.   .   .   if (*p ++ == 'w' &&
.   .   .   .   *p == 0)
.   .   .   .   return "haw";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "he";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "hi";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "hr";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "hu";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "hy";
.   .   }
.   .   return error;
.   // [0,"",'i',[6,'t']]
.   case 'i':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ia";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "id";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ig";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ii";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "is";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "it";
.   .   }
.   .   return error;
.   // [0,"",'j',[3,'m']]
.   case 'j':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ja";
.   .   .   return error;
.   .   // [0,"g",'o',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "jgo";
.   .   .   return error;
.   .   // [0,"m",'c',[0]]
.   .   case 'm':
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "jmc";
.   .   }
.   .   return error;
.   // [0,"",'k',[13,'y']]
.   case 'k':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'m']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ka";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kab";
.   .   .   .   return error;
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kam";
.   .   .   }
.   .   .   return error;
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kde";
.   .   .   return error;
.   .   // [0,"e",'a',[0]]
.   .   case 'e':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kea";
.   .   .   return error;
.   .   // [0,"h",'q',[0]]
.   .   case 'h':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "khq";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ki";
.   .   .   return error;
.   .   // [0,"",'k',[1,'j']]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "kk";
.   .   .   // [0,"",'j',[0]]
.   .   .   if (*p ++ == 'j' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kkj";
.   .   .   return error;
.   .   // [0,"",'l',[1,'n']]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "kl";
.   .   .   // [0,"",'n',[0]]
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kln";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "km";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "kn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'k']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ko";
.   .   .   // [0,"",'k',[0]]
.   .   .   if (*p ++ == 'k' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kok";
.   .   .   return error;
.   .   // [0,"",'s',[3,'h']]
.   .   case 's':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksb";
.   .   .   .   return error;
.   .   .   // [0,"",'f',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksf";
.   .   .   .   return error;
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksh";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'w',[0]]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "kw";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "ky";
.   .   }
.   .   return error;
.   // [0,"",'l',[8,'v']]
.   case 'l':
.   .   switch (*p ++) {
.   .   // [0,"a",'g',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "lag";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "lg";
.   .   .   return error;
.   .   // [0,"k",'t',[0]]
.   .   case 'k':
.   .   .   if (*p ++ == 't' &&
.   .   .   .   *p == 0)
.   .   .   .   return "lkt";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "ln";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "lo";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "lt";
.   .   .   return error;
.   .   // [0,"",'u',[2,'y']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "lu";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luo";
.   .   .   .   return error;
.   .   .   // [0,"",'y',[0]]
.   .   .   case 'y':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luy";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "lv";
.   .   }
.   .   return error;
.   // [0,"",'m',[12,'y']]
.   case 'm':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mas";
.   .   .   return error;
.   .   // [0,"e",'r',[0]]
.   .   case 'e':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mer";
.   .   .   return error;
.   .   // [0,"f",'e',[0]]
.   .   case 'f':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mfe";
.   .   .   return error;
.   .   // [0,"",'g',[2,'o']]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "mg";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgh";
.   .   .   .   return error;
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgo";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "mk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "ml";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "mn";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "mr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ms";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "mt";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mua";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "my";
.   .   }
.   .   return error;
.   // [0,"",'n',[11,'y']]
.   case 'n':
.   .   switch (*p ++) {
.   .   // [0,"a",'q',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "naq";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "nb";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "nd";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ne";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "nl";
.   .   .   return error;
.   .   // [0,"m",'g',[0]]
.   .   case 'm':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nmg";
.   .   .   return error;
.   .   // [0,"",'n',[1,'h']]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "nn";
.   .   .   // [0,"",'h',[0]]
.   .   .   if (*p ++ == 'h' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nnh";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "nr";
.   .   .   return error;
.   .   // [0,"s",'o',[0]]
.   .   case 's':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nso";
.   .   .   return error;
.   .   // [0,"u",'s',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nus";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nyn";
.   .   }
.   .   return error;
.   // [0,"",'o',[3,'s']]
.   case 'o':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "om";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "or";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "os";
.   .   }
.   .   return error;
.   // [0,"",'p',[4,'t']]
.   case 'p':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'_']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "pa";
.   .   .   // [0,"_Ara",'b',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'A' &&
.   .   .   .   *p ++ == 'r' &&
.   .   .   .   *p ++ == 'a' &&
.   .   .   .   *p ++ == 'b' &&
.   .   .   .   *p == 0)
.   .   .   .   return "pa_Arab";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "pl";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ps";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "pt";
.   .   }
.   .   return error;
.   // [0,"",'r',[5,'w']]
.   case 'r':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "rm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "rn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'f']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ro";
.   .   .   // [0,"",'f',[0]]
.   .   .   if (*p ++ == 'f' &&
.   .   .   .   *p == 0)
.   .   .   .   return "rof";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "ru";
.   .   .   return error;
.   .   // [0,"",'w',[1,'k']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "rw";
.   .   .   // [0,"",'k',[0]]
.   .   .   if (*p ++ == 'k' &&
.   .   .   .   *p == 0)
.   .   .   .   return "rwk";
.   .   }
.   .   return error;
.   // [0,"",'s',[16,'w']]
.   case 's':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'q']]
.   .   case 'a':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sah";
.   .   .   .   return error;
.   .   .   // [0,"",'q',[0]]
.   .   .   case 'q':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "saq";
.   .   .   }
.   .   .   return error;
.   .   // [0,"b",'p',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'p' &&
.   .   .   .   *p == 0)
.   .   .   .   return "sbp";
.   .   .   return error;
.   .   // [0,"",'e',[2,'s']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "se";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "seh";
.   .   .   .   return error;
.   .   .   // [0,"",'s',[0]]
.   .   .   case 's':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ses";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "sg";
.   .   .   return error;
.   .   // [0,"h",'i',[1,'_']]
.   .   case 'h':
.   .   .   if (*p ++ == 'i') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "shi";
.   .   .   .   // [1,"h_Lat",'n',[0]]
.   .   .   .   if (*p ++ == '_' &&
.   .   .   .   .   *p ++ == 'L' &&
.   .   .   .   .   *p ++ == 'a' &&
.   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   *p ++ == 'n' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "shi_Latn";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "si";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "sk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "sl";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "sn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "so";
.   .   .   return error;
.   .   // [0,"",'q',[0]]
.   .   case 'q':
.   .   .   if (*p == 0)
.   .   .   .   return "sq";
.   .   .   return error;
.   .   // [0,"",'r',[1,'_']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "sr";
.   .   .   // [0,"_Lat",'n',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'L' &&
.   .   .   .   *p ++ == 'a' &&
.   .   .   .   *p ++ == 't' &&
.   .   .   .   *p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "sr_Latn";
.   .   .   return error;
.   .   // [0,"",'s',[1,'y']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ss";
.   .   .   // [0,"",'y',[0]]
.   .   .   if (*p ++ == 'y' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ssy";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "st";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "sv";
.   .   .   return error;
.   .   // [0,"",'w',[1,'c']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "sw";
.   .   .   // [0,"",'c',[0]]
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "swc";
.   .   }
.   .   return error;
.   // [0,"",'t',[11,'z']]
.   case 't':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ta";
.   .   .   return error;
.   .   // [0,"",'e',[1,'o']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "te";
.   .   .   // [0,"",'o',[0]]
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "teo";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "tg";
.   .   .   return error;
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "th";
.   .   .   return error;
.   .   // [0,"",'i',[2,'g']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ti";
.   .   .   switch (*p ++) {
.   .   .   // [0,"_E",'R',[0]]
.   .   .   case '_':
.   .   .   .   if (*p ++ == 'E' &&
.   .   .   .   .   *p ++ == 'R' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "ti_ER";
.   .   .   .   return error;
.   .   .   // [0,"",'g',[0]]
.   .   .   case 'g':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tig";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "tn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "to";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "tr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ts";
.   .   .   return error;
.   .   // [0,"w",'q',[0]]
.   .   case 'w':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "twq";
.   .   .   return error;
.   .   // [0,"z",'m',[0]]
.   .   case 'z':
.   .   .   if (*p ++ == 'm' &&
.   .   .   .   *p == 0)
.   .   .   .   return "tzm";
.   .   }
.   .   return error;
.   // [0,"",'u',[4,'z']]
.   case 'u':
.   .   switch (*p ++) {
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ug";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "uk";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ur";
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "uz";
.   .   .   // [0,"",'_',[2,'C']]
.   .   .   if (*p ++ == '_') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [0,"Ara",'b',[0]]
.   .   .   .   case 'A':
.   .   .   .   .   if (*p ++ == 'r' &&
.   .   .   .   .   .   *p ++ == 'a' &&
.   .   .   .   .   .   *p ++ == 'b' &&
.   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   return "uz_Arab";
.   .   .   .   .   return error;
.   .   .   .   // [0,"Cyr",'l',[0]]
.   .   .   .   case 'C':
.   .   .   .   .   if (*p ++ == 'y' &&
.   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   *p ++ == 'l' &&
.   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   return "uz_Cyrl";
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'v',[5,'u']]
.   case 'v':
.   .   switch (*p ++) {
.   .   // [0,"ai_Lat",'n',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'i' &&
.   .   .   .   *p ++ == '_' &&
.   .   .   .   *p ++ == 'L' &&
.   .   .   .   *p ++ == 'a' &&
.   .   .   .   *p ++ == 't' &&
.   .   .   .   *p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "vai_Latn";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ve";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "vi";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "vo";
.   .   .   return error;
.   .   // [0,"u",'n',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "vun";
.   .   }
.   .   return error;
.   // [0,"w",'a',[2,'l']]
.   case 'w':
.   .   if (*p ++ == 'a') {
.   .   .   switch (*p ++) {
.   .   .   // [1,"w",'e',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wae";
.   .   .   .   return error;
.   .   .   // [1,"w",'l',[0]]
.   .   .   case 'l':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wal";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'x',[2,'o']]
.   case 'x':
.   .   switch (*p ++) {
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "xh";
.   .   .   return error;
.   .   // [0,"o",'g',[0]]
.   .   case 'o':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "xog";
.   .   }
.   .   return error;
.   // [0,"",'y',[2,'o']]
.   case 'y':
.   .   switch (*p ++) {
.   .   // [0,"a",'v',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'v' &&
.   .   .   .   *p == 0)
.   .   .   .   return "yav";
.   .   .   return error;
.   .   // [0,"",'o',[1,'_']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "yo";
.   .   .   // [0,"_B",'J',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'B' &&
.   .   .   .   *p ++ == 'J' &&
.   .   .   .   *p == 0)
.   .   .   .   return "yo_BJ";
.   .   }
.   .   return error;
.   // [0,"",'z',[3,'u']]
.   case 'z':
.   .   switch (*p ++) {
.   .   // [0,"g",'h',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'h' &&
.   .   .   .   *p == 0)
.   .   .   .   return "zgh";
.   .   .   return error;
.   .   // [0,"",'h',[1,'_']]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "zh";
.   .   .   // [0,"_Han",'t',[0]]
.   .   .   if (*p ++ == '_' &&
.   .   .   .   *p ++ == 'H' &&
.   .   .   .   *p ++ == 'a' &&
.   .   .   .   *p ++ == 'n' &&
.   .   .   .   *p ++ == 't' &&
.   .   .   .   *p == 0)
.   .   .   .   return "zh_Hant";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "zu";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-filenames-array ]----------------------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --trie=array < filenames.txt
.   // [1,'c']
.   // [0,"c++py-tree-demo",'/',[3,'c']]
.   if (*p ++ == 'c' &&
.   .   *p ++ == '+' &&
.   .   *p ++ == '+' &&
.   .   *p ++ == 'p' &&
.   .   *p ++ == 'y' &&
.   .   *p ++ == '-' &&
.   .   *p ++ == 't' &&
.   .   *p ++ == 'r' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == '-' &&
.   .   *p ++ == 'd' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == 'm' &&
.   .   *p ++ == 'o' &&
.   .   *p ++ == '/') {
.   .   switch (*p ++) {
.   .   // [15,"c++py-tree-demo.src",'-',[2,'f']]
.   .   case '.':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p ++ == 'r' &&
.   .   .   .   *p ++ == 'c' &&
.   .   .   .   *p ++ == '-') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-demo.srcdir",'s',[0]]
.   .   .   .   case 'd':
.   .   .   .   .   if (*p ++ == 'i' &&
.   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   *p ++ == 's' &&
.   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   return "c++py-tree-demo/.src-dirs";
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-demo.srcfile",'s',[0]]
.   .   .   .   case 'f':
.   .   .   .   .   if (*p ++ == 'i' &&
.   .   .   .   .   .   *p ++ == 'l' &&
.   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   *p ++ == 's' &&
.   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   return "c++py-tree-demo/.src-files";
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [15,"c++py-tree-demobin.patc",'h',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'i' &&
.   .   .   .   *p ++ == 'n' &&
.   .   .   .   *p ++ == '.' &&
.   .   .   .   *p ++ == 'p' &&
.   .   .   .   *p ++ == 'a' &&
.   .   .   .   *p ++ == 't' &&
.   .   .   .   *p ++ == 'c' &&
.   .   .   .   *p ++ == 'h' &&
.   .   .   .   *p == 0)
.   .   .   .   return "c++py-tree-demo/bin.patch";
.   .   .   return error;
.   .   // [15,"c++py-tree-democ++p",'y',[2,'/']]
.   .   case 'c':
.   .   .   if (*p ++ == '+' &&
.   .   .   .   *p ++ == '+' &&
.   .   .   .   *p ++ == 'p' &&
.   .   .   .   *p ++ == 'y') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-democ++p-tre",'e',[2,'.']]
.   .   .   .   case '-':
.   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   *p ++ == 'e') {
.   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'-',[3,'r']]
.   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-treauthor.tx",'t',[0]]
.   .   .   .   .   .   .   case 'a':
.   .   .   .   .   .   .   .   if (*p ++ == 'u' &&
.   .   .   .   .   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'h' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'o' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   .   .   .   *p ++ == '.' &&
.   .   .   .   .   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-author.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tredemo.tx",'t',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (*p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'm' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'o' &&
.   .   .   .   .   .   .   .   .   *p ++ == '.' &&
.   .   .   .   .   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-demo.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trereadme",'.',[2,'t']]
.   .   .   .   .   .   .   case 'r':
.   .   .   .   .   .   .   .   if (*p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'a' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'm' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == '.') {
.   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmepd",'f',[0]]
.   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   if (*p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   .   .   *p ++ == 'f' &&
.   .   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.pdf";
.   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadme",'t',[2,'x']]
.   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmee",'x',[0]]
.   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.tex";
.   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmex",'t',[0]]
.   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.txt";
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   return error;
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'.',[2,'t']]
.   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trepd",'f',[0]]
.   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   if (*p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'f' &&
.   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.pdf";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'t',[2,'x']]
.   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tree",'x',[0]]
.   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   if (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.tex";
.   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trex",'t',[0]]
.   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.txt";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-democ++p",'/',[4,'R']]
.   .   .   .   case '/':
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [19,"c++py-tree-democ++p.src",'-',[2,'f']]
.   .   .   .   .   case '.':
.   .   .   .   .   .   if (*p ++ == 's' &&
.   .   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   .   *p ++ == 'c' &&
.   .   .   .   .   .   .   *p ++ == '-') {
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcdir",'s',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (*p ++ == 'i' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   .   .   .   *p ++ == 's' &&
.   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-dirs";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcfile",'s',[0]]
.   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   if (*p ++ == 'i' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'l' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == 's' &&
.   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-files";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pAUTHO",'R',[0]]
.   .   .   .   .   case 'A':
.   .   .   .   .   .   if (*p ++ == 'U' &&
.   .   .   .   .   .   .   *p ++ == 'T' &&
.   .   .   .   .   .   .   *p ++ == 'H' &&
.   .   .   .   .   .   .   *p ++ == 'O' &&
.   .   .   .   .   .   .   *p ++ == 'R' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/AUTHOR";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pMakefil",'e',[0]]
.   .   .   .   .   case 'M':
.   .   .   .   .   .   if (*p ++ == 'a' &&
.   .   .   .   .   .   .   *p ++ == 'k' &&
.   .   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   .   *p ++ == 'f' &&
.   .   .   .   .   .   .   *p ++ == 'i' &&
.   .   .   .   .   .   .   *p ++ == 'l' &&
.   .   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/Makefile";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pREADM",'E',[0]]
.   .   .   .   .   case 'R':
.   .   .   .   .   .   if (*p ++ == 'E' &&
.   .   .   .   .   .   .   *p ++ == 'A' &&
.   .   .   .   .   .   .   *p ++ == 'D' &&
.   .   .   .   .   .   .   *p ++ == 'M' &&
.   .   .   .   .   .   .   *p ++ == 'E' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/README";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-filenames-ternary ]--------------------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --trie=ternary < filenames.txt
.   // [1,'c']
.   // [0,"c++py-tree-demo",'/',[3,'c']]
.   if (*p ++ == 'c' &&
.   .   *p ++ == '+' &&
.   .   *p ++ == '+' &&
.   .   *p ++ == 'p' &&
.   .   *p ++ == 'y' &&
.   .   *p ++ == '-' &&
.   .   *p ++ == 't' &&
.   .   *p ++ == 'r' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == '-' &&
.   .   *p ++ == 'd' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == 'm' &&
.   .   *p ++ == 'o' &&
.   .   *p ++ == '/') {
.   .   switch (*p ++) {
.   .   // [15,"c++py-tree-demo.src",'-',[2,'f']]
.   .   case '.':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p ++ == 'r' &&
.   .   .   .   *p ++ == 'c' &&
.   .   .   .   *p ++ == '-') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-demo.srcdir",'s',[0]]
.   .   .   .   case 'd':
.   .   .   .   .   if (*p ++ == 'i' &&
.   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   *p ++ == 's' &&
.   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   return "c++py-tree-demo/.src-dirs";
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-demo.srcfile",'s',[0]]
.   .   .   .   case 'f':
.   .   .   .   .   if (*p ++ == 'i' &&
.   .   .   .   .   .   *p ++ == 'l' &&
.   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   *p ++ == 's' &&
.   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   return "c++py-tree-demo/.src-files";
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [15,"c++py-tree-demobin.patc",'h',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'i' &&
.   .   .   .   *p ++ == 'n' &&
.   .   .   .   *p ++ == '.' &&
.   .   .   .   *p ++ == 'p' &&
.   .   .   .   *p ++ == 'a' &&
.   .   .   .   *p ++ == 't' &&
.   .   .   .   *p ++ == 'c' &&
.   .   .   .   *p ++ == 'h' &&
.   .   .   .   *p == 0)
.   .   .   .   return "c++py-tree-demo/bin.patch";
.   .   .   return error;
.   .   // [15,"c++py-tree-democ++p",'y',[2,'/']]
.   .   case 'c':
.   .   .   if (*p ++ == '+' &&
.   .   .   .   *p ++ == '+' &&
.   .   .   .   *p ++ == 'p' &&
.   .   .   .   *p ++ == 'y') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-democ++p-tre",'e',[2,'.']]
.   .   .   .   case '-':
.   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   *p ++ == 'e') {
.   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'-',[3,'r']]
.   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-treauthor.tx",'t',[0]]
.   .   .   .   .   .   .   case 'a':
.   .   .   .   .   .   .   .   if (*p ++ == 'u' &&
.   .   .   .   .   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'h' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'o' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   .   .   .   *p ++ == '.' &&
.   .   .   .   .   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-author.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tredemo.tx",'t',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (*p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'm' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'o' &&
.   .   .   .   .   .   .   .   .   *p ++ == '.' &&
.   .   .   .   .   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   *p ++ == 't' &&
.   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-demo.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trereadme",'.',[2,'t']]
.   .   .   .   .   .   .   case 'r':
.   .   .   .   .   .   .   .   if (*p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'a' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'm' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == '.') {
.   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmepd",'f',[0]]
.   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   if (*p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   .   .   *p ++ == 'f' &&
.   .   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.pdf";
.   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadme",'t',[2,'x']]
.   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmee",'x',[0]]
.   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.tex";
.   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmex",'t',[0]]
.   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.txt";
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   return error;
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'.',[2,'t']]
.   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trepd",'f',[0]]
.   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   if (*p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'f' &&
.   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.pdf";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'t',[2,'x']]
.   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tree",'x',[0]]
.   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   if (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.tex";
.   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trex",'t',[0]]
.   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.txt";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-democ++p",'/',[4,'R']]
.   .   .   .   case '/':
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [19,"c++py-tree-democ++p.src",'-',[2,'f']]
.   .   .   .   .   case '.':
.   .   .   .   .   .   if (*p ++ == 's' &&
.   .   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   .   *p ++ == 'c' &&
.   .   .   .   .   .   .   *p ++ == '-') {
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcdir",'s',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (*p ++ == 'i' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   .   .   .   *p ++ == 's' &&
.   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-dirs";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcfile",'s',[0]]
.   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   if (*p ++ == 'i' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'l' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == 's' &&
.   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-files";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pAUTHO",'R',[0]]
.   .   .   .   .   case 'A':
.   .   .   .   .   .   if (*p ++ == 'U' &&
.   .   .   .   .   .   .   *p ++ == 'T' &&
.   .   .   .   .   .   .   *p ++ == 'H' &&
.   .   .   .   .   .   .   *p ++ == 'O' &&
.   .   .   .   .   .   .   *p ++ == 'R' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/AUTHOR";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pMakefil",'e',[0]]
.   .   .   .   .   case 'M':
.   .   .   .   .   .   if (*p ++ == 'a' &&
.   .   .   .   .   .   .   *p ++ == 'k' &&
.   .   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   .   *p ++ == 'f' &&
.   .   .   .   .   .   .   *p ++ == 'i' &&
.   .   .   .   .   .   .   *p ++ == 'l' &&
.   .   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/Makefile";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pREADM",'E',[0]]
.   .   .   .   .   case 'R':
.   .   .   .   .   .   if (*p ++ == 'E' &&
.   .   .   .   .   .   .   *p ++ == 'A' &&
.   .   .   .   .   .   .   *p ++ == 'D' &&
.   .   .   .   .   .   .   *p ++ == 'M' &&
.   .   .   .   .   .   .   *p ++ == 'E' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/README";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-unique-prefix-base0-array ]------------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --unique-prefix --trie=array "$@"; }
$ print a|trie
    if ((*p == 0 || (*p ++ == 'a' &&
        (*p == 0))))
        return "a";
    return error;
$ print a ab|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
    }
    return error;
$ print a ab abc|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            if ((*p == 0 || (*p ++ == 'c' &&
                (*p == 0))))
                return "abc";
        }
    }
    return error;
$ print a b|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        if (*p == 0)
            return "b";
    }
    return error;
$ print a b abc bac abd|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
            }
        }
        return error;
    case 'b':
        if (*p == 0)
            return "b";
        if ((*p == 0 || (*p ++ == 'a' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "bac";
    }
    return error;
$ print a bb ba c|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print a bb ba cc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))
            return "cc";
    }
    return error;
$ print a bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print a bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'd' &&
            (*p == 0 || (*p ++ == 'e' &&
            (*p == 0))))))
            return "cde";
    }
    return error;
$ print a bb ba cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'd' &&
            (*p == 0 || (*p ++ == 'e' &&
            (*p == 0 || (*p ++ == 'f' &&
            (*p == 0))))))))
            return "cdef";
    }
    return error;
$ print a bb ba cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if ((*p == 0 || (*p ++ == 'g' &&
                (*p == 0))))
                return "cdefg";
        }
    }
    return error;
$ print a bb bac cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 'c' &&
                (*p == 0))))
                return "bac";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'd' &&
            (*p == 0 || (*p ++ == 'e' &&
            (*p == 0 || (*p ++ == 'f' &&
            (*p == 0))))))))
            return "cdef";
    }
    return error;
$ print a bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print a bbx bay ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 'y' &&
                (*p == 0))))
                return "bay";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print a cde cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "cdef";
        }
    }
    return error;
$ print a cde cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if ((*p == 0 || (*p ++ == 'g' &&
                    (*p == 0))))
                    return "cdefg";
            }
        }
    }
    return error;
$ print a cde cdef cdefgh|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if ((*p == 0 || (*p ++ == 'g' &&
                    (*p == 0 || (*p ++ == 'h' &&
                    (*p == 0))))))
                    return "cdefgh";
            }
        }
    }
    return error;
$ print a cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if ((*p == 0 || (*p ++ == 'g' &&
                (*p == 0))))
                return "cdefg";
        }
    }
    return error;
$ print ab|trie
    if ((*p == 0 || (*p ++ == 'a' &&
        (*p == 0 || (*p ++ == 'b' &&
        (*p == 0))))))
        return "ab";
    return error;
$ print ab bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print ab bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'd' &&
            (*p == 0 || (*p ++ == 'e' &&
            (*p == 0))))))
            return "cde";
    }
    return error;
$ print ab bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print ab c|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print abc bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "abc";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print abcd abde abef|trie
    if (*p ++ == 'a' &&
        *p ++ == 'b') {
        switch (*p ++) {
        case 'c':
            if ((*p == 0 || (*p ++ == 'd' &&
                (*p == 0))))
                return "abcd";
            return error;
        case 'd':
            if ((*p == 0 || (*p ++ == 'e' &&
                (*p == 0))))
                return "abde";
            return error;
        case 'e':
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "abef";
        }
    }
    return error;
$ print abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
        }
    }
    return error;
$ print ac ab|trie
    if (*p ++ == 'a') {
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            return error;
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print aef ae abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ae";
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "aef";
        }
    }
    return error;
$ print cde cdef cdefgh|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd' &&
        *p ++ == 'e') {
        if (*p == 0)
            return "cde";
        if (*p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if ((*p == 0 || (*p ++ == 'g' &&
                (*p == 0 || (*p ++ == 'h' &&
                (*p == 0))))))
                return "cdefgh";
        }
    }
    return error;
$ print cdef cdefg|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd' &&
        *p ++ == 'e' &&
        *p ++ == 'f') {
        if (*p == 0)
            return "cdef";
        if ((*p == 0 || (*p ++ == 'g' &&
            (*p == 0))))
            return "cdefg";
    }
    return error;
$ print cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd') {
        switch (*p ++) {
        case 'e':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "cdex";
            return error;
        case 'f':
            if ((*p == 0 || (*p ++ == 'y' &&
                (*p == 0))))
                return "cdfy";
            return error;
        case 'g':
            if ((*p == 0 || (*p ++ == 'z' &&
                (*p == 0))))
                return "cdgz";
            return error;
        case 'h':
            if ((*p == 0 || (*p ++ == 'w' &&
                (*p == 0))))
                return "cdhw";
        }
    }
    return error;
$ print ce cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        switch (*p ++) {
        case 'd':
            switch (*p ++) {
            case 'e':
                if ((*p == 0 || (*p ++ == 'x' &&
                    (*p == 0))))
                    return "cdex";
                return error;
            case 'f':
                if ((*p == 0 || (*p ++ == 'y' &&
                    (*p == 0))))
                    return "cdfy";
                return error;
            case 'g':
                if ((*p == 0 || (*p ++ == 'z' &&
                    (*p == 0))))
                    return "cdgz";
                return error;
            case 'h':
                if ((*p == 0 || (*p ++ == 'w' &&
                    (*p == 0))))
                    return "cdhw";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ce";
        }
    }
    return error;
$ print pot potato pottery tattoo tempo|trie
    switch (*p ++) {
    case 'p':
        if (*p ++ == 'o' &&
            *p ++ == 't') {
            if (*p == 0)
                return "pot";
            switch (*p ++) {
            case 'a':
                if ((*p == 0 || (*p ++ == 't' &&
                    (*p == 0 || (*p ++ == 'o' &&
                    (*p == 0))))))
                    return "potato";
                return error;
            case 't':
                if ((*p == 0 || (*p ++ == 'e' &&
                    (*p == 0 || (*p ++ == 'r' &&
                    (*p == 0 || (*p ++ == 'y' &&
                    (*p == 0))))))))
                    return "pottery";
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 't' &&
                (*p == 0 || (*p ++ == 't' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0))))))))))
                return "tattoo";
            return error;
        case 'e':
            if ((*p == 0 || (*p ++ == 'm' &&
                (*p == 0 || (*p ++ == 'p' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0))))))))
                return "tempo";
        }
    }
    return error;
$

--[ gen-compact-c-code-unique-prefix-base0-ternary ]----------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --unique-prefix --trie=ternary "$@"; }
$ print a|trie
    if ((*p == 0 || (*p ++ == 'a' &&
        (*p == 0))))
        return "a";
    return error;
$ print a ab|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
    }
    return error;
$ print a ab abc|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            if ((*p == 0 || (*p ++ == 'c' &&
                (*p == 0))))
                return "abc";
        }
    }
    return error;
$ print a b|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        if (*p == 0)
            return "b";
    }
    return error;
$ print a b abc bac abd|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
            }
        }
        return error;
    case 'b':
        if (*p == 0)
            return "b";
        if ((*p == 0 || (*p ++ == 'a' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "bac";
    }
    return error;
$ print a bb ba c|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print a bb ba cc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))
            return "cc";
    }
    return error;
$ print a bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print a bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'd' &&
            (*p == 0 || (*p ++ == 'e' &&
            (*p == 0))))))
            return "cde";
    }
    return error;
$ print a bb ba cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'd' &&
            (*p == 0 || (*p ++ == 'e' &&
            (*p == 0 || (*p ++ == 'f' &&
            (*p == 0))))))))
            return "cdef";
    }
    return error;
$ print a bb ba cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if ((*p == 0 || (*p ++ == 'g' &&
                (*p == 0))))
                return "cdefg";
        }
    }
    return error;
$ print a bb bac cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 'c' &&
                (*p == 0))))
                return "bac";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'd' &&
            (*p == 0 || (*p ++ == 'e' &&
            (*p == 0 || (*p ++ == 'f' &&
            (*p == 0))))))))
            return "cdef";
    }
    return error;
$ print a bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print a bbx bay ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 'y' &&
                (*p == 0))))
                return "bay";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print a cde cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "cdef";
        }
    }
    return error;
$ print a cde cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if ((*p == 0 || (*p ++ == 'g' &&
                    (*p == 0))))
                    return "cdefg";
            }
        }
    }
    return error;
$ print a cde cdef cdefgh|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e') {
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if ((*p == 0 || (*p ++ == 'g' &&
                    (*p == 0 || (*p ++ == 'h' &&
                    (*p == 0))))))
                    return "cdefgh";
            }
        }
    }
    return error;
$ print a cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (*p ++ == 'd' &&
            *p ++ == 'e' &&
            *p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if ((*p == 0 || (*p ++ == 'g' &&
                (*p == 0))))
                return "cdefg";
        }
    }
    return error;
$ print ab|trie
    if ((*p == 0 || (*p ++ == 'a' &&
        (*p == 0 || (*p ++ == 'b' &&
        (*p == 0))))))
        return "ab";
    return error;
$ print ab bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print ab bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'd' &&
            (*p == 0 || (*p ++ == 'e' &&
            (*p == 0))))))
            return "cde";
    }
    return error;
$ print ab bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print ab c|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print abc bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "abc";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))))
            return "ccc";
    }
    return error;
$ print abcd abde abef|trie
    if (*p ++ == 'a' &&
        *p ++ == 'b') {
        switch (*p ++) {
        case 'c':
            if ((*p == 0 || (*p ++ == 'd' &&
                (*p == 0))))
                return "abcd";
            return error;
        case 'd':
            if ((*p == 0 || (*p ++ == 'e' &&
                (*p == 0))))
                return "abde";
            return error;
        case 'e':
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "abef";
        }
    }
    return error;
$ print abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
        }
    }
    return error;
$ print ac ab|trie
    if (*p ++ == 'a') {
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            return error;
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print aef ae abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ae";
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "aef";
        }
    }
    return error;
$ print cde cdef cdefgh|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd' &&
        *p ++ == 'e') {
        if (*p == 0)
            return "cde";
        if (*p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if ((*p == 0 || (*p ++ == 'g' &&
                (*p == 0 || (*p ++ == 'h' &&
                (*p == 0))))))
                return "cdefgh";
        }
    }
    return error;
$ print cdef cdefg|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd' &&
        *p ++ == 'e' &&
        *p ++ == 'f') {
        if (*p == 0)
            return "cdef";
        if ((*p == 0 || (*p ++ == 'g' &&
            (*p == 0))))
            return "cdefg";
    }
    return error;
$ print cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c' &&
        *p ++ == 'd') {
        switch (*p ++) {
        case 'e':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "cdex";
            return error;
        case 'f':
            if ((*p == 0 || (*p ++ == 'y' &&
                (*p == 0))))
                return "cdfy";
            return error;
        case 'g':
            if ((*p == 0 || (*p ++ == 'z' &&
                (*p == 0))))
                return "cdgz";
            return error;
        case 'h':
            if ((*p == 0 || (*p ++ == 'w' &&
                (*p == 0))))
                return "cdhw";
        }
    }
    return error;
$ print ce cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        switch (*p ++) {
        case 'd':
            switch (*p ++) {
            case 'e':
                if ((*p == 0 || (*p ++ == 'x' &&
                    (*p == 0))))
                    return "cdex";
                return error;
            case 'f':
                if ((*p == 0 || (*p ++ == 'y' &&
                    (*p == 0))))
                    return "cdfy";
                return error;
            case 'g':
                if ((*p == 0 || (*p ++ == 'z' &&
                    (*p == 0))))
                    return "cdgz";
                return error;
            case 'h':
                if ((*p == 0 || (*p ++ == 'w' &&
                    (*p == 0))))
                    return "cdhw";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ce";
        }
    }
    return error;
$ print pot potato pottery tattoo tempo|trie
    switch (*p ++) {
    case 'p':
        if (*p ++ == 'o' &&
            *p ++ == 't') {
            if (*p == 0)
                return "pot";
            switch (*p ++) {
            case 'a':
                if ((*p == 0 || (*p ++ == 't' &&
                    (*p == 0 || (*p ++ == 'o' &&
                    (*p == 0))))))
                    return "potato";
                return error;
            case 't':
                if ((*p == 0 || (*p ++ == 'e' &&
                    (*p == 0 || (*p ++ == 'r' &&
                    (*p == 0 || (*p ++ == 'y' &&
                    (*p == 0))))))))
                    return "pottery";
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 't' &&
                (*p == 0 || (*p ++ == 't' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0))))))))))
                return "tattoo";
            return error;
        case 'e':
            if ((*p == 0 || (*p ++ == 'm' &&
                (*p == 0 || (*p ++ == 'p' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0))))))))
                return "tempo";
        }
    }
    return error;
$

--[ gen-compact-c-code-unique-prefix-base ]-------------------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --unique-prefix --attrs --no-dots "$@"; }
$ print a ab abc abd ac|trie
    // [1,'a']
    // [0,"",'a',[2,'c']]
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        // [0,"",'b',[2,'d']]
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            // [0,"",'c',[0]]
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            // [0,"",'d',[0]]
            case 'd':
                if (*p == 0)
                    return "abd";
            }
            return error;
        // [0,"",'c',[0]]
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print a ab abc abd ac|trie -t int
    // [1,'a']
    // [0,"",'a',[2,'c']]
    if (*p ++ == 'a') {
        if (*p == 0)
            return 1;
        switch (*p ++) {
        // [0,"",'b',[2,'d']]
        case 'b':
            if (*p == 0)
                return 2;
            switch (*p ++) {
            // [0,"",'c',[0]]
            case 'c':
                if (*p == 0)
                    return 3;
                return error;
            // [0,"",'d',[0]]
            case 'd':
                if (*p == 0)
                    return 4;
            }
            return error;
        // [0,"",'c',[0]]
        case 'c':
            if (*p == 0)
                return 5;
        }
    }
    return error;
$ print a ab abc abd ac|trie -t float
    // [1,'a']
    // [0,"",'a',[2,'c']]
    if (*p ++ == 'a') {
        if (*p == 0)
            return 1.0;
        switch (*p ++) {
        // [0,"",'b',[2,'d']]
        case 'b':
            if (*p == 0)
                return 2.0;
            switch (*p ++) {
            // [0,"",'c',[0]]
            case 'c':
                if (*p == 0)
                    return 3.0;
                return error;
            // [0,"",'d',[0]]
            case 'd':
                if (*p == 0)
                    return 4.0;
            }
            return error;
        // [0,"",'c',[0]]
        case 'c':
            if (*p == 0)
                return 5.0;
        }
    }
    return error;
$

--[ gen-compact-c-code-unique-prefix-base-array ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --unique-prefix --attrs --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
.   // [1,'a']
.   // [0,"",'a',[0]]
.   if ((*p == 0 || (*p ++ == 'a' &&
.   .   (*p == 0))))
.   .   return "a";
.   return error;
$ print a b|trie
.   // [2,'b']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   }
.   return error;
$ print a b c|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   .   return error;
.   // [0,"",'c',[0]]
.   case 'c':
.   .   if (*p == 0)
.   .   .   return "c";
.   }
.   return error;
$ print a ab abc|trie
.   // [1,'a']
.   // [0,"",'a',[1,'b']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"",'b',[1,'c']]
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   // [0,"",'c',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "abc";
.   .   }
.   }
.   return error;
$ print a ab ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac ad|trie
.   // [1,'a']
.   // [0,"",'a',[3,'d']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "ad";
.   .   }
.   }
.   return error;
$ print a abd ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"b",'d',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "abd";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac acd|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"",'d',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "acd";
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0))))))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"b",'b',[0]]
.   case 'b':
.   .   if ((*p == 0 || (*p ++ == 'b' &&
.   .   .   (*p == 0))))
.   .   .   return "bb";
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0))))))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0))))))
.   .   .   return "ccc";
.   }
.   return error;
$ print abc abd acde|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"cd",'e',[0]]
.   .   case 'c':
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"d",'e',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde acfg|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[2,'f']]
.   .   case 'c':
.   .   .   switch (*p ++) {
.   .   .   // [0,"d",'e',[0]]
.   .   .   case 'd':
.   .   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   (*p == 0))))
.   .   .   .   .   return "acde";
.   .   .   .   return error;
.   .   .   // [0,"f",'g',[0]]
.   .   .   case 'f':
.   .   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   .   (*p == 0))))
.   .   .   .   .   return "acfg";
.   .   .   }
.   .   }
.   }
.   return error;
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'f']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cde";
.   .   .   return error;
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'g']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [0,"g",'e',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cge";
.   .   }
.   }
.   return error;
$ print a abcd abcdefg h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[1,'e']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0 || (*p ++ == 'f' &&
.   .   .   .   (*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))))))
.   .   .   .   return "abcdefg";
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   (*p == 0 || (*p ++ == 'j' &&
.   .   .   (*p == 0 || (*p ++ == 'k' &&
.   .   .   (*p == 0))))))))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if ((*p == 0 || (*p ++ == 'f' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'g' &&
.   .   .   .   .   (*p == 0))))))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if ((*p == 0 || (*p ++ == 'y' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   (*p == 0))))))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   (*p == 0 || (*p ++ == 'j' &&
.   .   .   (*p == 0 || (*p ++ == 'k' &&
.   .   .   (*p == 0))))))))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if ((*p == 0 || (*p ++ == 'f' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'g' &&
.   .   .   .   .   (*p == 0))))))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if ((*p == 0 || (*p ++ == 'y' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   (*p == 0))))))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[2,'l']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   switch (*p ++) {
.   .   // [0,"ij",'k',[0]]
.   .   case 'i':
.   .   .   if ((*p == 0 || (*p ++ == 'j' &&
.   .   .   .   (*p == 0 || (*p ++ == 'k' &&
.   .   .   .   (*p == 0))))))
.   .   .   .   return "hijk";
.   .   .   return error;
.   .   // [0,"l",'m',[0]]
.   .   case 'l':
.   .   .   if ((*p == 0 || (*p ++ == 'm' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "hlm";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-unique-prefix-base-ternary ]-----------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --unique-prefix --attrs --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
.   // [1,'a']
.   // [0,"",'a',[0]]
.   if ((*p == 0 || (*p ++ == 'a' &&
.   .   (*p == 0))))
.   .   return "a";
.   return error;
$ print a b|trie
.   // [2,'b']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   }
.   return error;
$ print a b c|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   .   return error;
.   // [0,"",'c',[0]]
.   case 'c':
.   .   if (*p == 0)
.   .   .   return "c";
.   }
.   return error;
$ print a ab abc|trie
.   // [1,'a']
.   // [0,"",'a',[1,'b']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"",'b',[1,'c']]
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   // [0,"",'c',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "abc";
.   .   }
.   }
.   return error;
$ print a ab ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac ad|trie
.   // [1,'a']
.   // [0,"",'a',[3,'d']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "ad";
.   .   }
.   }
.   return error;
$ print a abd ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"b",'d',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "abd";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac acd|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"",'d',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "acd";
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0))))))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"b",'b',[0]]
.   case 'b':
.   .   if ((*p == 0 || (*p ++ == 'b' &&
.   .   .   (*p == 0))))
.   .   .   return "bb";
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0))))))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0 || (*p ++ == 'c' &&
.   .   .   (*p == 0))))))
.   .   .   return "ccc";
.   }
.   return error;
$ print abc abd acde|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"cd",'e',[0]]
.   .   case 'c':
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"d",'e',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde acfg|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[2,'f']]
.   .   case 'c':
.   .   .   switch (*p ++) {
.   .   .   // [0,"d",'e',[0]]
.   .   .   case 'd':
.   .   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   (*p == 0))))
.   .   .   .   .   return "acde";
.   .   .   .   return error;
.   .   .   // [0,"f",'g',[0]]
.   .   .   case 'f':
.   .   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   .   (*p == 0))))
.   .   .   .   .   return "acfg";
.   .   .   }
.   .   }
.   }
.   return error;
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'f']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cde";
.   .   .   return error;
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'g']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [0,"g",'e',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cge";
.   .   }
.   }
.   return error;
$ print a abcd abcdefg h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[1,'e']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0 || (*p ++ == 'f' &&
.   .   .   .   (*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))))))
.   .   .   .   return "abcdefg";
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   (*p == 0 || (*p ++ == 'j' &&
.   .   .   (*p == 0 || (*p ++ == 'k' &&
.   .   .   (*p == 0))))))))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if ((*p == 0 || (*p ++ == 'f' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'g' &&
.   .   .   .   .   (*p == 0))))))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if ((*p == 0 || (*p ++ == 'y' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   (*p == 0))))))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   (*p == 0 || (*p ++ == 'j' &&
.   .   .   (*p == 0 || (*p ++ == 'k' &&
.   .   .   (*p == 0))))))))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (*p ++ == 'b' &&
.   .   .   *p ++ == 'c' &&
.   .   .   *p ++ == 'd') {
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if ((*p == 0 || (*p ++ == 'f' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'g' &&
.   .   .   .   .   (*p == 0))))))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if ((*p == 0 || (*p ++ == 'y' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   (*p == 0))))))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[2,'l']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   switch (*p ++) {
.   .   // [0,"ij",'k',[0]]
.   .   case 'i':
.   .   .   if ((*p == 0 || (*p ++ == 'j' &&
.   .   .   .   (*p == 0 || (*p ++ == 'k' &&
.   .   .   .   (*p == 0))))))
.   .   .   .   return "hijk";
.   .   .   return error;
.   .   // [0,"l",'m',[0]]
.   .   case 'l':
.   .   .   if ((*p == 0 || (*p ++ == 'm' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "hlm";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-unique-prefix-alphabets-array ]--------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --unique-prefix --trie=array < alphabets.txt
.   // [25,'z']
.   switch (*p ++) {
.   // [0,"",'a',[8,'z']]
.   case 'a':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "aa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "af";
.   .   .   return error;
.   .   // [0,"g",'q',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "agq";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "ak";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "am";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ar";
.   .   .   return error;
.   .   // [0,"",'s',[2,'t']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "as";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'a',[0]]
.   .   .   case 'a':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "asa";
.   .   .   .   return error;
.   .   .   // [0,"",'t',[0]]
.   .   .   case 't':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ast";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "az";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'C' &&
.   .   .   .   (*p == 0 || (*p ++ == 'y' &&
.   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   (*p == 0))))))))))))
.   .   .   .   return "az_Cyrl";
.   .   }
.   .   return error;
.   // [0,"",'b',[9,'y']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "bas";
.   .   .   return error;
.   .   // [0,"",'e',[2,'z']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "be";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bem";
.   .   .   .   return error;
.   .   .   // [0,"",'z',[0]]
.   .   .   case 'z':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bez";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "bg";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "bm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "bn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "bo";
.   .   .   return error;
.   .   // [0,"",'r',[1,'x']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "br";
.   .   .   // [0,"",'x',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "brx";
.   .   .   return error;
.   .   // [0,"",'s',[1,'_']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "bs";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'C' &&
.   .   .   .   (*p == 0 || (*p ++ == 'y' &&
.   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   (*p == 0))))))))))))
.   .   .   .   return "bs_Cyrl";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "byn";
.   .   }
.   .   return error;
.   // [0,"",'c',[5,'y']]
.   case 'c':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ca";
.   .   .   return error;
.   .   // [0,"g",'g',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cgg";
.   .   .   return error;
.   .   // [0,"h",'r',[0]]
.   .   case 'h':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "chr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "cs";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "cy";
.   .   }
.   .   return error;
.   // [0,"",'d',[6,'z']]
.   case 'd':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'v']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "da";
.   .   .   // [0,"",'v',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'v' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dav";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "de";
.   .   .   return error;
.   .   // [0,"j",'e',[0]]
.   .   case 'j':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dje";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dua";
.   .   .   return error;
.   .   // [0,"y",'o',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dyo";
.   .   .   return error;
.   .   // [0,"",'z',[0]]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "dz";
.   .   }
.   .   return error;
.   // [0,"",'e',[9,'w']]
.   case 'e':
.   .   switch (*p ++) {
.   .   // [0,"b",'u',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'u' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ebu";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ee";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "el";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "en";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "eo";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "es";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "et";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "eu";
.   .   .   return error;
.   .   // [0,"w",'o',[0]]
.   .   case 'w':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ewo";
.   .   }
.   .   return error;
.   // [0,"",'f',[7,'y']]
.   case 'f':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "fa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "ff";
.   .   .   return error;
.   .   // [0,"",'i',[1,'l']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "fi";
.   .   .   // [0,"",'l',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'l' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "fil";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "fo";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "fr";
.   .   .   return error;
.   .   // [0,"u",'r',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "fur";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "fy";
.   .   }
.   .   return error;
.   // [0,"",'g',[6,'v']]
.   case 'g':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ga";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "gd";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "gl";
.   .   .   return error;
.   .   // [0,"s",'w',[0]]
.   .   case 's':
.   .   .   if ((*p == 0 || (*p ++ == 'w' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "gsw";
.   .   .   return error;
.   .   // [0,"",'u',[1,'z']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "gu";
.   .   .   // [0,"",'z',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "guz";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "gv";
.   .   }
.   .   return error;
.   // [0,"",'h',[6,'y']]
.   case 'h':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'w']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ha";
.   .   .   // [0,"",'w',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'w' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "haw";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "he";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "hi";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "hr";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "hu";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "hy";
.   .   }
.   .   return error;
.   // [0,"",'i',[6,'t']]
.   case 'i':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ia";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "id";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ig";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ii";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "is";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "it";
.   .   }
.   .   return error;
.   // [0,"",'j',[3,'m']]
.   case 'j':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ja";
.   .   .   return error;
.   .   // [0,"g",'o',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "jgo";
.   .   .   return error;
.   .   // [0,"m",'c',[0]]
.   .   case 'm':
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "jmc";
.   .   }
.   .   return error;
.   // [0,"",'k',[13,'y']]
.   case 'k':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'m']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ka";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kab";
.   .   .   .   return error;
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kam";
.   .   .   }
.   .   .   return error;
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kde";
.   .   .   return error;
.   .   // [0,"e",'a',[0]]
.   .   case 'e':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kea";
.   .   .   return error;
.   .   // [0,"h",'q',[0]]
.   .   case 'h':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "khq";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ki";
.   .   .   return error;
.   .   // [0,"",'k',[1,'j']]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "kk";
.   .   .   // [0,"",'j',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'j' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kkj";
.   .   .   return error;
.   .   // [0,"",'l',[1,'n']]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "kl";
.   .   .   // [0,"",'n',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kln";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "km";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "kn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'k']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ko";
.   .   .   // [0,"",'k',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'k' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kok";
.   .   .   return error;
.   .   // [0,"",'s',[3,'h']]
.   .   case 's':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksb";
.   .   .   .   return error;
.   .   .   // [0,"",'f',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksf";
.   .   .   .   return error;
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksh";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'w',[0]]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "kw";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "ky";
.   .   }
.   .   return error;
.   // [0,"",'l',[8,'v']]
.   case 'l':
.   .   switch (*p ++) {
.   .   // [0,"a",'g',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "lag";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "lg";
.   .   .   return error;
.   .   // [0,"k",'t',[0]]
.   .   case 'k':
.   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "lkt";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "ln";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "lo";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "lt";
.   .   .   return error;
.   .   // [0,"",'u',[2,'y']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "lu";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luo";
.   .   .   .   return error;
.   .   .   // [0,"",'y',[0]]
.   .   .   case 'y':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luy";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "lv";
.   .   }
.   .   return error;
.   // [0,"",'m',[12,'y']]
.   case 'm':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mas";
.   .   .   return error;
.   .   // [0,"e",'r',[0]]
.   .   case 'e':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mer";
.   .   .   return error;
.   .   // [0,"f",'e',[0]]
.   .   case 'f':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mfe";
.   .   .   return error;
.   .   // [0,"",'g',[2,'o']]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "mg";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgh";
.   .   .   .   return error;
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgo";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "mk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "ml";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "mn";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "mr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ms";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "mt";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mua";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "my";
.   .   }
.   .   return error;
.   // [0,"",'n',[11,'y']]
.   case 'n':
.   .   switch (*p ++) {
.   .   // [0,"a",'q',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "naq";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "nb";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "nd";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ne";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "nl";
.   .   .   return error;
.   .   // [0,"m",'g',[0]]
.   .   case 'm':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nmg";
.   .   .   return error;
.   .   // [0,"",'n',[1,'h']]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "nn";
.   .   .   // [0,"",'h',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'h' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nnh";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "nr";
.   .   .   return error;
.   .   // [0,"s",'o',[0]]
.   .   case 's':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nso";
.   .   .   return error;
.   .   // [0,"u",'s',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nus";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nyn";
.   .   }
.   .   return error;
.   // [0,"",'o',[3,'s']]
.   case 'o':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "om";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "or";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "os";
.   .   }
.   .   return error;
.   // [0,"",'p',[4,'t']]
.   case 'p':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'_']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "pa";
.   .   .   // [0,"_Ara",'b',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'A' &&
.   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0 || (*p ++ == 'b' &&
.   .   .   .   (*p == 0))))))))))))
.   .   .   .   return "pa_Arab";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "pl";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ps";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "pt";
.   .   }
.   .   return error;
.   // [0,"",'r',[5,'w']]
.   case 'r':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "rm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "rn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'f']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ro";
.   .   .   // [0,"",'f',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'f' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "rof";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "ru";
.   .   .   return error;
.   .   // [0,"",'w',[1,'k']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "rw";
.   .   .   // [0,"",'k',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'k' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "rwk";
.   .   }
.   .   return error;
.   // [0,"",'s',[16,'w']]
.   case 's':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'q']]
.   .   case 'a':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sah";
.   .   .   .   return error;
.   .   .   // [0,"",'q',[0]]
.   .   .   case 'q':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "saq";
.   .   .   }
.   .   .   return error;
.   .   // [0,"b",'p',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'p' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "sbp";
.   .   .   return error;
.   .   // [0,"",'e',[2,'s']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "se";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "seh";
.   .   .   .   return error;
.   .   .   // [0,"",'s',[0]]
.   .   .   case 's':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ses";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "sg";
.   .   .   return error;
.   .   // [0,"h",'i',[1,'_']]
.   .   case 'h':
.   .   .   if (*p ++ == 'i') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "shi";
.   .   .   .   // [1,"h_Lat",'n',[0]]
.   .   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'L' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'n' &&
.   .   .   .   .   (*p == 0))))))))))))
.   .   .   .   .   return "shi_Latn";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "si";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "sk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "sl";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "sn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "so";
.   .   .   return error;
.   .   // [0,"",'q',[0]]
.   .   case 'q':
.   .   .   if (*p == 0)
.   .   .   .   return "sq";
.   .   .   return error;
.   .   // [0,"",'r',[1,'_']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "sr";
.   .   .   // [0,"_Lat",'n',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'L' &&
.   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))))))))))
.   .   .   .   return "sr_Latn";
.   .   .   return error;
.   .   // [0,"",'s',[1,'y']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ss";
.   .   .   // [0,"",'y',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'y' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ssy";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "st";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "sv";
.   .   .   return error;
.   .   // [0,"",'w',[1,'c']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "sw";
.   .   .   // [0,"",'c',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "swc";
.   .   }
.   .   return error;
.   // [0,"",'t',[11,'z']]
.   case 't':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ta";
.   .   .   return error;
.   .   // [0,"",'e',[1,'o']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "te";
.   .   .   // [0,"",'o',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "teo";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "tg";
.   .   .   return error;
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "th";
.   .   .   return error;
.   .   // [0,"",'i',[2,'g']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ti";
.   .   .   switch (*p ++) {
.   .   .   // [0,"_E",'R',[0]]
.   .   .   case '_':
.   .   .   .   if ((*p == 0 || (*p ++ == 'E' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'R' &&
.   .   .   .   .   (*p == 0))))))
.   .   .   .   .   return "ti_ER";
.   .   .   .   return error;
.   .   .   // [0,"",'g',[0]]
.   .   .   case 'g':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tig";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "tn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "to";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "tr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ts";
.   .   .   return error;
.   .   // [0,"w",'q',[0]]
.   .   case 'w':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "twq";
.   .   .   return error;
.   .   // [0,"z",'m',[0]]
.   .   case 'z':
.   .   .   if ((*p == 0 || (*p ++ == 'm' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "tzm";
.   .   }
.   .   return error;
.   // [0,"",'u',[4,'z']]
.   case 'u':
.   .   switch (*p ++) {
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ug";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "uk";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ur";
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "uz";
.   .   .   // [0,"",'_',[2,'C']]
.   .   .   if (*p ++ == '_') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [0,"Ara",'b',[0]]
.   .   .   .   case 'A':
.   .   .   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'b' &&
.   .   .   .   .   .   (*p == 0))))))))
.   .   .   .   .   .   return "uz_Arab";
.   .   .   .   .   return error;
.   .   .   .   // [0,"Cyr",'l',[0]]
.   .   .   .   case 'C':
.   .   .   .   .   if ((*p == 0 || (*p ++ == 'y' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   .   .   (*p == 0))))))))
.   .   .   .   .   .   return "uz_Cyrl";
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'v',[5,'u']]
.   case 'v':
.   .   switch (*p ++) {
.   .   // [0,"ai_Lat",'n',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   (*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'L' &&
.   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))))))))))))
.   .   .   .   return "vai_Latn";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ve";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "vi";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "vo";
.   .   .   return error;
.   .   // [0,"u",'n',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "vun";
.   .   }
.   .   return error;
.   // [0,"w",'a',[2,'l']]
.   case 'w':
.   .   if (*p ++ == 'a') {
.   .   .   switch (*p ++) {
.   .   .   // [1,"w",'e',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wae";
.   .   .   .   return error;
.   .   .   // [1,"w",'l',[0]]
.   .   .   case 'l':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wal";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'x',[2,'o']]
.   case 'x':
.   .   switch (*p ++) {
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "xh";
.   .   .   return error;
.   .   // [0,"o",'g',[0]]
.   .   case 'o':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "xog";
.   .   }
.   .   return error;
.   // [0,"",'y',[2,'o']]
.   case 'y':
.   .   switch (*p ++) {
.   .   // [0,"a",'v',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'v' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "yav";
.   .   .   return error;
.   .   // [0,"",'o',[1,'_']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "yo";
.   .   .   // [0,"_B",'J',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'B' &&
.   .   .   .   (*p == 0 || (*p ++ == 'J' &&
.   .   .   .   (*p == 0))))))))
.   .   .   .   return "yo_BJ";
.   .   }
.   .   return error;
.   // [0,"",'z',[3,'u']]
.   case 'z':
.   .   switch (*p ++) {
.   .   // [0,"g",'h',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'h' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "zgh";
.   .   .   return error;
.   .   // [0,"",'h',[1,'_']]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "zh";
.   .   .   // [0,"_Han",'t',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'H' &&
.   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0))))))))))))
.   .   .   .   return "zh_Hant";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "zu";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-unique-prefix-alphabets-ternary ]------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --unique-prefix --trie=ternary < alphabets.txt
.   // [25,'z']
.   switch (*p ++) {
.   // [0,"",'a',[8,'z']]
.   case 'a':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "aa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "af";
.   .   .   return error;
.   .   // [0,"g",'q',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "agq";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "ak";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "am";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ar";
.   .   .   return error;
.   .   // [0,"",'s',[2,'t']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "as";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'a',[0]]
.   .   .   case 'a':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "asa";
.   .   .   .   return error;
.   .   .   // [0,"",'t',[0]]
.   .   .   case 't':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ast";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "az";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'C' &&
.   .   .   .   (*p == 0 || (*p ++ == 'y' &&
.   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   (*p == 0))))))))))))
.   .   .   .   return "az_Cyrl";
.   .   }
.   .   return error;
.   // [0,"",'b',[9,'y']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "bas";
.   .   .   return error;
.   .   // [0,"",'e',[2,'z']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "be";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bem";
.   .   .   .   return error;
.   .   .   // [0,"",'z',[0]]
.   .   .   case 'z':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bez";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "bg";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "bm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "bn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "bo";
.   .   .   return error;
.   .   // [0,"",'r',[1,'x']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "br";
.   .   .   // [0,"",'x',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "brx";
.   .   .   return error;
.   .   // [0,"",'s',[1,'_']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "bs";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'C' &&
.   .   .   .   (*p == 0 || (*p ++ == 'y' &&
.   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   (*p == 0))))))))))))
.   .   .   .   return "bs_Cyrl";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "byn";
.   .   }
.   .   return error;
.   // [0,"",'c',[5,'y']]
.   case 'c':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ca";
.   .   .   return error;
.   .   // [0,"g",'g',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cgg";
.   .   .   return error;
.   .   // [0,"h",'r',[0]]
.   .   case 'h':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "chr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "cs";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "cy";
.   .   }
.   .   return error;
.   // [0,"",'d',[6,'z']]
.   case 'd':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'v']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "da";
.   .   .   // [0,"",'v',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'v' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dav";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "de";
.   .   .   return error;
.   .   // [0,"j",'e',[0]]
.   .   case 'j':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dje";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dua";
.   .   .   return error;
.   .   // [0,"y",'o',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dyo";
.   .   .   return error;
.   .   // [0,"",'z',[0]]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "dz";
.   .   }
.   .   return error;
.   // [0,"",'e',[9,'w']]
.   case 'e':
.   .   switch (*p ++) {
.   .   // [0,"b",'u',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'u' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ebu";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ee";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "el";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "en";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "eo";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "es";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "et";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "eu";
.   .   .   return error;
.   .   // [0,"w",'o',[0]]
.   .   case 'w':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ewo";
.   .   }
.   .   return error;
.   // [0,"",'f',[7,'y']]
.   case 'f':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "fa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "ff";
.   .   .   return error;
.   .   // [0,"",'i',[1,'l']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "fi";
.   .   .   // [0,"",'l',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'l' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "fil";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "fo";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "fr";
.   .   .   return error;
.   .   // [0,"u",'r',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "fur";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "fy";
.   .   }
.   .   return error;
.   // [0,"",'g',[6,'v']]
.   case 'g':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ga";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "gd";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "gl";
.   .   .   return error;
.   .   // [0,"s",'w',[0]]
.   .   case 's':
.   .   .   if ((*p == 0 || (*p ++ == 'w' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "gsw";
.   .   .   return error;
.   .   // [0,"",'u',[1,'z']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "gu";
.   .   .   // [0,"",'z',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "guz";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "gv";
.   .   }
.   .   return error;
.   // [0,"",'h',[6,'y']]
.   case 'h':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'w']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ha";
.   .   .   // [0,"",'w',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'w' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "haw";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "he";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "hi";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "hr";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "hu";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "hy";
.   .   }
.   .   return error;
.   // [0,"",'i',[6,'t']]
.   case 'i':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ia";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "id";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ig";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ii";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "is";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "it";
.   .   }
.   .   return error;
.   // [0,"",'j',[3,'m']]
.   case 'j':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ja";
.   .   .   return error;
.   .   // [0,"g",'o',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "jgo";
.   .   .   return error;
.   .   // [0,"m",'c',[0]]
.   .   case 'm':
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "jmc";
.   .   }
.   .   return error;
.   // [0,"",'k',[13,'y']]
.   case 'k':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'m']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ka";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kab";
.   .   .   .   return error;
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kam";
.   .   .   }
.   .   .   return error;
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kde";
.   .   .   return error;
.   .   // [0,"e",'a',[0]]
.   .   case 'e':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kea";
.   .   .   return error;
.   .   // [0,"h",'q',[0]]
.   .   case 'h':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "khq";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ki";
.   .   .   return error;
.   .   // [0,"",'k',[1,'j']]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "kk";
.   .   .   // [0,"",'j',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'j' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kkj";
.   .   .   return error;
.   .   // [0,"",'l',[1,'n']]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "kl";
.   .   .   // [0,"",'n',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kln";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "km";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "kn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'k']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ko";
.   .   .   // [0,"",'k',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'k' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kok";
.   .   .   return error;
.   .   // [0,"",'s',[3,'h']]
.   .   case 's':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksb";
.   .   .   .   return error;
.   .   .   // [0,"",'f',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksf";
.   .   .   .   return error;
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksh";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'w',[0]]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "kw";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "ky";
.   .   }
.   .   return error;
.   // [0,"",'l',[8,'v']]
.   case 'l':
.   .   switch (*p ++) {
.   .   // [0,"a",'g',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "lag";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "lg";
.   .   .   return error;
.   .   // [0,"k",'t',[0]]
.   .   case 'k':
.   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "lkt";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "ln";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "lo";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "lt";
.   .   .   return error;
.   .   // [0,"",'u',[2,'y']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "lu";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luo";
.   .   .   .   return error;
.   .   .   // [0,"",'y',[0]]
.   .   .   case 'y':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luy";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "lv";
.   .   }
.   .   return error;
.   // [0,"",'m',[12,'y']]
.   case 'm':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mas";
.   .   .   return error;
.   .   // [0,"e",'r',[0]]
.   .   case 'e':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mer";
.   .   .   return error;
.   .   // [0,"f",'e',[0]]
.   .   case 'f':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mfe";
.   .   .   return error;
.   .   // [0,"",'g',[2,'o']]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "mg";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgh";
.   .   .   .   return error;
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgo";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "mk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "ml";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "mn";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "mr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ms";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "mt";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mua";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "my";
.   .   }
.   .   return error;
.   // [0,"",'n',[11,'y']]
.   case 'n':
.   .   switch (*p ++) {
.   .   // [0,"a",'q',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "naq";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "nb";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "nd";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ne";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "nl";
.   .   .   return error;
.   .   // [0,"m",'g',[0]]
.   .   case 'm':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nmg";
.   .   .   return error;
.   .   // [0,"",'n',[1,'h']]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "nn";
.   .   .   // [0,"",'h',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'h' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nnh";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "nr";
.   .   .   return error;
.   .   // [0,"s",'o',[0]]
.   .   case 's':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nso";
.   .   .   return error;
.   .   // [0,"u",'s',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nus";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nyn";
.   .   }
.   .   return error;
.   // [0,"",'o',[3,'s']]
.   case 'o':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "om";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "or";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "os";
.   .   }
.   .   return error;
.   // [0,"",'p',[4,'t']]
.   case 'p':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'_']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "pa";
.   .   .   // [0,"_Ara",'b',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'A' &&
.   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0 || (*p ++ == 'b' &&
.   .   .   .   (*p == 0))))))))))))
.   .   .   .   return "pa_Arab";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "pl";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ps";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "pt";
.   .   }
.   .   return error;
.   // [0,"",'r',[5,'w']]
.   case 'r':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "rm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "rn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'f']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ro";
.   .   .   // [0,"",'f',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'f' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "rof";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "ru";
.   .   .   return error;
.   .   // [0,"",'w',[1,'k']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "rw";
.   .   .   // [0,"",'k',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'k' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "rwk";
.   .   }
.   .   return error;
.   // [0,"",'s',[16,'w']]
.   case 's':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'q']]
.   .   case 'a':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sah";
.   .   .   .   return error;
.   .   .   // [0,"",'q',[0]]
.   .   .   case 'q':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "saq";
.   .   .   }
.   .   .   return error;
.   .   // [0,"b",'p',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'p' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "sbp";
.   .   .   return error;
.   .   // [0,"",'e',[2,'s']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "se";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "seh";
.   .   .   .   return error;
.   .   .   // [0,"",'s',[0]]
.   .   .   case 's':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ses";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "sg";
.   .   .   return error;
.   .   // [0,"h",'i',[1,'_']]
.   .   case 'h':
.   .   .   if (*p ++ == 'i') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "shi";
.   .   .   .   // [1,"h_Lat",'n',[0]]
.   .   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'L' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'n' &&
.   .   .   .   .   (*p == 0))))))))))))
.   .   .   .   .   return "shi_Latn";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "si";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "sk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "sl";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "sn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "so";
.   .   .   return error;
.   .   // [0,"",'q',[0]]
.   .   case 'q':
.   .   .   if (*p == 0)
.   .   .   .   return "sq";
.   .   .   return error;
.   .   // [0,"",'r',[1,'_']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "sr";
.   .   .   // [0,"_Lat",'n',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'L' &&
.   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))))))))))
.   .   .   .   return "sr_Latn";
.   .   .   return error;
.   .   // [0,"",'s',[1,'y']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ss";
.   .   .   // [0,"",'y',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'y' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ssy";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "st";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "sv";
.   .   .   return error;
.   .   // [0,"",'w',[1,'c']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "sw";
.   .   .   // [0,"",'c',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "swc";
.   .   }
.   .   return error;
.   // [0,"",'t',[11,'z']]
.   case 't':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ta";
.   .   .   return error;
.   .   // [0,"",'e',[1,'o']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "te";
.   .   .   // [0,"",'o',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "teo";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "tg";
.   .   .   return error;
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "th";
.   .   .   return error;
.   .   // [0,"",'i',[2,'g']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ti";
.   .   .   switch (*p ++) {
.   .   .   // [0,"_E",'R',[0]]
.   .   .   case '_':
.   .   .   .   if ((*p == 0 || (*p ++ == 'E' &&
.   .   .   .   .   (*p == 0 || (*p ++ == 'R' &&
.   .   .   .   .   (*p == 0))))))
.   .   .   .   .   return "ti_ER";
.   .   .   .   return error;
.   .   .   // [0,"",'g',[0]]
.   .   .   case 'g':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tig";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "tn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "to";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "tr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ts";
.   .   .   return error;
.   .   // [0,"w",'q',[0]]
.   .   case 'w':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "twq";
.   .   .   return error;
.   .   // [0,"z",'m',[0]]
.   .   case 'z':
.   .   .   if ((*p == 0 || (*p ++ == 'm' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "tzm";
.   .   }
.   .   return error;
.   // [0,"",'u',[4,'z']]
.   case 'u':
.   .   switch (*p ++) {
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ug";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "uk";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ur";
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "uz";
.   .   .   // [0,"",'_',[2,'C']]
.   .   .   if (*p ++ == '_') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [0,"Ara",'b',[0]]
.   .   .   .   case 'A':
.   .   .   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'b' &&
.   .   .   .   .   .   (*p == 0))))))))
.   .   .   .   .   .   return "uz_Arab";
.   .   .   .   .   return error;
.   .   .   .   // [0,"Cyr",'l',[0]]
.   .   .   .   case 'C':
.   .   .   .   .   if ((*p == 0 || (*p ++ == 'y' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   .   .   (*p == 0))))))))
.   .   .   .   .   .   return "uz_Cyrl";
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'v',[5,'u']]
.   case 'v':
.   .   switch (*p ++) {
.   .   // [0,"ai_Lat",'n',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   (*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'L' &&
.   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))))))))))))
.   .   .   .   return "vai_Latn";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ve";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "vi";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "vo";
.   .   .   return error;
.   .   // [0,"u",'n',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "vun";
.   .   }
.   .   return error;
.   // [0,"w",'a',[2,'l']]
.   case 'w':
.   .   if (*p ++ == 'a') {
.   .   .   switch (*p ++) {
.   .   .   // [1,"w",'e',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wae";
.   .   .   .   return error;
.   .   .   // [1,"w",'l',[0]]
.   .   .   case 'l':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wal";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'x',[2,'o']]
.   case 'x':
.   .   switch (*p ++) {
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "xh";
.   .   .   return error;
.   .   // [0,"o",'g',[0]]
.   .   case 'o':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "xog";
.   .   }
.   .   return error;
.   // [0,"",'y',[2,'o']]
.   case 'y':
.   .   switch (*p ++) {
.   .   // [0,"a",'v',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'v' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "yav";
.   .   .   return error;
.   .   // [0,"",'o',[1,'_']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "yo";
.   .   .   // [0,"_B",'J',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'B' &&
.   .   .   .   (*p == 0 || (*p ++ == 'J' &&
.   .   .   .   (*p == 0))))))))
.   .   .   .   return "yo_BJ";
.   .   }
.   .   return error;
.   // [0,"",'z',[3,'u']]
.   case 'z':
.   .   switch (*p ++) {
.   .   // [0,"g",'h',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'h' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "zgh";
.   .   .   return error;
.   .   // [0,"",'h',[1,'_']]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "zh";
.   .   .   // [0,"_Han",'t',[0]]
.   .   .   if ((*p == 0 || (*p ++ == '_' &&
.   .   .   .   (*p == 0 || (*p ++ == 'H' &&
.   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0))))))))))))
.   .   .   .   return "zh_Hant";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "zu";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-unique-prefix-filenames-array ]--------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --unique-prefix --trie=array < filenames.txt
.   // [1,'c']
.   // [0,"c++py-tree-demo",'/',[3,'c']]
.   if (*p ++ == 'c' &&
.   .   *p ++ == '+' &&
.   .   *p ++ == '+' &&
.   .   *p ++ == 'p' &&
.   .   *p ++ == 'y' &&
.   .   *p ++ == '-' &&
.   .   *p ++ == 't' &&
.   .   *p ++ == 'r' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == '-' &&
.   .   *p ++ == 'd' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == 'm' &&
.   .   *p ++ == 'o' &&
.   .   *p ++ == '/') {
.   .   switch (*p ++) {
.   .   // [15,"c++py-tree-demo.src",'-',[2,'f']]
.   .   case '.':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p ++ == 'r' &&
.   .   .   .   *p ++ == 'c' &&
.   .   .   .   *p ++ == '-') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-demo.srcdir",'s',[0]]
.   .   .   .   case 'd':
.   .   .   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 's' &&
.   .   .   .   .   .   (*p == 0))))))))
.   .   .   .   .   .   return "c++py-tree-demo/.src-dirs";
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-demo.srcfile",'s',[0]]
.   .   .   .   case 'f':
.   .   .   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 's' &&
.   .   .   .   .   .   (*p == 0))))))))))
.   .   .   .   .   .   return "c++py-tree-demo/.src-files";
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [15,"c++py-tree-demobin.patc",'h',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   (*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0 || (*p ++ == '.' &&
.   .   .   .   (*p == 0 || (*p ++ == 'p' &&
.   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0 || (*p ++ == 'h' &&
.   .   .   .   (*p == 0))))))))))))))))))
.   .   .   .   return "c++py-tree-demo/bin.patch";
.   .   .   return error;
.   .   // [15,"c++py-tree-democ++p",'y',[2,'/']]
.   .   case 'c':
.   .   .   if (*p ++ == '+' &&
.   .   .   .   *p ++ == '+' &&
.   .   .   .   *p ++ == 'p' &&
.   .   .   .   *p ++ == 'y') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-democ++p-tre",'e',[2,'.']]
.   .   .   .   case '-':
.   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   *p ++ == 'e') {
.   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'-',[3,'r']]
.   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-treauthor.tx",'t',[0]]
.   .   .   .   .   .   .   case 'a':
.   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'u' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'h' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'o' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == '.' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   (*p == 0))))))))))))))))))))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-author.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tredemo.tx",'t',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'm' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'o' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == '.' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   (*p == 0))))))))))))))))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-demo.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trereadme",'.',[2,'t']]
.   .   .   .   .   .   .   case 'r':
.   .   .   .   .   .   .   .   if (*p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'a' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'm' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == '.') {
.   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmepd",'f',[0]]
.   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'f' &&
.   .   .   .   .   .   .   .   .   .   .   (*p == 0))))))
.   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.pdf";
.   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadme",'t',[2,'x']]
.   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmee",'x',[0]]
.   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.tex";
.   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmex",'t',[0]]
.   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.txt";
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   return error;
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'.',[2,'t']]
.   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trepd",'f',[0]]
.   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'f' &&
.   .   .   .   .   .   .   .   .   (*p == 0))))))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.pdf";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'t',[2,'x']]
.   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tree",'x',[0]]
.   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.tex";
.   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trex",'t',[0]]
.   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.txt";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-democ++p",'/',[4,'R']]
.   .   .   .   case '/':
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [19,"c++py-tree-democ++p.src",'-',[2,'f']]
.   .   .   .   .   case '.':
.   .   .   .   .   .   if (*p ++ == 's' &&
.   .   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   .   *p ++ == 'c' &&
.   .   .   .   .   .   .   *p ++ == '-') {
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcdir",'s',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 's' &&
.   .   .   .   .   .   .   .   .   (*p == 0))))))))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-dirs";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcfile",'s',[0]]
.   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 's' &&
.   .   .   .   .   .   .   .   .   (*p == 0))))))))))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-files";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pAUTHO",'R',[0]]
.   .   .   .   .   case 'A':
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'U' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'T' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'H' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'O' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'R' &&
.   .   .   .   .   .   .   (*p == 0))))))))))))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/AUTHOR";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pMakefil",'e',[0]]
.   .   .   .   .   case 'M':
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'k' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'f' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'i' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   .   .   (*p == 0))))))))))))))))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/Makefile";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pREADM",'E',[0]]
.   .   .   .   .   case 'R':
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'E' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'A' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'D' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'M' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'E' &&
.   .   .   .   .   .   .   (*p == 0))))))))))))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/README";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-unique-prefix-filenames-ternary ]------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --unique-prefix --trie=ternary < filenames.txt
.   // [1,'c']
.   // [0,"c++py-tree-demo",'/',[3,'c']]
.   if (*p ++ == 'c' &&
.   .   *p ++ == '+' &&
.   .   *p ++ == '+' &&
.   .   *p ++ == 'p' &&
.   .   *p ++ == 'y' &&
.   .   *p ++ == '-' &&
.   .   *p ++ == 't' &&
.   .   *p ++ == 'r' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == '-' &&
.   .   *p ++ == 'd' &&
.   .   *p ++ == 'e' &&
.   .   *p ++ == 'm' &&
.   .   *p ++ == 'o' &&
.   .   *p ++ == '/') {
.   .   switch (*p ++) {
.   .   // [15,"c++py-tree-demo.src",'-',[2,'f']]
.   .   case '.':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p ++ == 'r' &&
.   .   .   .   *p ++ == 'c' &&
.   .   .   .   *p ++ == '-') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-demo.srcdir",'s',[0]]
.   .   .   .   case 'd':
.   .   .   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 's' &&
.   .   .   .   .   .   (*p == 0))))))))
.   .   .   .   .   .   return "c++py-tree-demo/.src-dirs";
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-demo.srcfile",'s',[0]]
.   .   .   .   case 'f':
.   .   .   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   .   (*p == 0 || (*p ++ == 's' &&
.   .   .   .   .   .   (*p == 0))))))))))
.   .   .   .   .   .   return "c++py-tree-demo/.src-files";
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [15,"c++py-tree-demobin.patc",'h',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   (*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0 || (*p ++ == '.' &&
.   .   .   .   (*p == 0 || (*p ++ == 'p' &&
.   .   .   .   (*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0 || (*p ++ == 'h' &&
.   .   .   .   (*p == 0))))))))))))))))))
.   .   .   .   return "c++py-tree-demo/bin.patch";
.   .   .   return error;
.   .   // [15,"c++py-tree-democ++p",'y',[2,'/']]
.   .   case 'c':
.   .   .   if (*p ++ == '+' &&
.   .   .   .   *p ++ == '+' &&
.   .   .   .   *p ++ == 'p' &&
.   .   .   .   *p ++ == 'y') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-democ++p-tre",'e',[2,'.']]
.   .   .   .   case '-':
.   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   *p ++ == 'e') {
.   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'-',[3,'r']]
.   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-treauthor.tx",'t',[0]]
.   .   .   .   .   .   .   case 'a':
.   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'u' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'h' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'o' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == '.' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   (*p == 0))))))))))))))))))))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-author.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tredemo.tx",'t',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'm' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'o' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == '.' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   (*p == 0))))))))))))))))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-demo.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trereadme",'.',[2,'t']]
.   .   .   .   .   .   .   case 'r':
.   .   .   .   .   .   .   .   if (*p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'a' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'm' &&
.   .   .   .   .   .   .   .   .   *p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   *p ++ == '.') {
.   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmepd",'f',[0]]
.   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'f' &&
.   .   .   .   .   .   .   .   .   .   .   (*p == 0))))))
.   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.pdf";
.   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadme",'t',[2,'x']]
.   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmee",'x',[0]]
.   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.tex";
.   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmex",'t',[0]]
.   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.txt";
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   return error;
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'.',[2,'t']]
.   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trepd",'f',[0]]
.   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'f' &&
.   .   .   .   .   .   .   .   .   (*p == 0))))))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.pdf";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'t',[2,'x']]
.   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tree",'x',[0]]
.   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.tex";
.   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trex",'t',[0]]
.   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.txt";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-democ++p",'/',[4,'R']]
.   .   .   .   case '/':
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [19,"c++py-tree-democ++p.src",'-',[2,'f']]
.   .   .   .   .   case '.':
.   .   .   .   .   .   if (*p ++ == 's' &&
.   .   .   .   .   .   .   *p ++ == 'r' &&
.   .   .   .   .   .   .   *p ++ == 'c' &&
.   .   .   .   .   .   .   *p ++ == '-') {
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcdir",'s',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'r' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 's' &&
.   .   .   .   .   .   .   .   .   (*p == 0))))))))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-dirs";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcfile",'s',[0]]
.   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'i' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   .   .   .   .   (*p == 0 || (*p ++ == 's' &&
.   .   .   .   .   .   .   .   .   (*p == 0))))))))))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-files";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pAUTHO",'R',[0]]
.   .   .   .   .   case 'A':
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'U' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'T' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'H' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'O' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'R' &&
.   .   .   .   .   .   .   (*p == 0))))))))))))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/AUTHOR";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pMakefil",'e',[0]]
.   .   .   .   .   case 'M':
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'k' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'f' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'i' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'l' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   .   .   (*p == 0))))))))))))))))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/Makefile";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pREADM",'E',[0]]
.   .   .   .   .   case 'R':
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'E' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'A' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'D' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'M' &&
.   .   .   .   .   .   .   (*p == 0 || (*p ++ == 'E' &&
.   .   .   .   .   .   .   (*p == 0))))))))))))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/README";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-base0-array ]------------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --path=function --trie=array "$@"; }
$ print a|trie
    if (*p ++ == 'a' &&
        *p == 0)
        return "a";
    return error;
$ print a ab|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
    }
    return error;
$ print a ab abc|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            if (*p ++ == 'c' &&
                *p == 0)
                return "abc";
        }
    }
    return error;
$ print a b|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        if (*p == 0)
            return "b";
    }
    return error;
$ print a b abc bac abd|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
            }
        }
        return error;
    case 'b':
        if (*p == 0)
            return "b";
        if (equal(p, "ac"))
            return "bac";
    }
    return error;
$ print a bb ba c|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print a bb ba cc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p == 0)
            return "cc";
    }
    return error;
$ print a bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print a bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "de"))
            return "cde";
    }
    return error;
$ print a bb ba cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "def"))
            return "cdef";
    }
    return error;
$ print a bb ba cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix("def", p)) {
            p += 3;
            if (*p == 0)
                return "cdef";
            if (*p ++ == 'g' &&
                *p == 0)
                return "cdefg";
        }
    }
    return error;
$ print a bb bac cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'c' &&
                *p == 0)
                return "bac";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "def"))
            return "cdef";
    }
    return error;
$ print a bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print a bbx bay ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'y' &&
                *p == 0)
                return "bay";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print a cde cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f' &&
                *p == 0)
                return "cdef";
        }
    }
    return error;
$ print a cde cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if (*p ++ == 'g' &&
                    *p == 0)
                    return "cdefg";
            }
        }
    }
    return error;
$ print a cde cdef cdefgh|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if (equal(p, "gh"))
                    return "cdefgh";
            }
        }
    }
    return error;
$ print a cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("def", p)) {
            p += 3;
            if (*p == 0)
                return "cdef";
            if (*p ++ == 'g' &&
                *p == 0)
                return "cdefg";
        }
    }
    return error;
$ print ab|trie
    if (equal(p, "ab"))
        return "ab";
    return error;
$ print ab bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print ab bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "de"))
            return "cde";
    }
    return error;
$ print ab bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print ab c|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print abc bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (equal(p, "bc"))
            return "abc";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print abcd abde abef|trie
    if (prefix("ab", p)) {
        p += 2;
        switch (*p ++) {
        case 'c':
            if (*p ++ == 'd' &&
                *p == 0)
                return "abcd";
            return error;
        case 'd':
            if (*p ++ == 'e' &&
                *p == 0)
                return "abde";
            return error;
        case 'e':
            if (*p ++ == 'f' &&
                *p == 0)
                return "abef";
        }
    }
    return error;
$ print abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
        }
    }
    return error;
$ print ac ab|trie
    if (*p ++ == 'a') {
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            return error;
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print aef ae abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ae";
            if (*p ++ == 'f' &&
                *p == 0)
                return "aef";
        }
    }
    return error;
$ print cde cdef cdefgh|trie
    if (prefix("cde", p)) {
        p += 3;
        if (*p == 0)
            return "cde";
        if (*p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if (equal(p, "gh"))
                return "cdefgh";
        }
    }
    return error;
$ print cdef cdefg|trie
    if (prefix("cdef", p)) {
        p += 4;
        if (*p == 0)
            return "cdef";
        if (*p ++ == 'g' &&
            *p == 0)
            return "cdefg";
    }
    return error;
$ print cdex cdfy cdgz cdhw|trie
    if (prefix("cd", p)) {
        p += 2;
        switch (*p ++) {
        case 'e':
            if (*p ++ == 'x' &&
                *p == 0)
                return "cdex";
            return error;
        case 'f':
            if (*p ++ == 'y' &&
                *p == 0)
                return "cdfy";
            return error;
        case 'g':
            if (*p ++ == 'z' &&
                *p == 0)
                return "cdgz";
            return error;
        case 'h':
            if (*p ++ == 'w' &&
                *p == 0)
                return "cdhw";
        }
    }
    return error;
$ print ce cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        switch (*p ++) {
        case 'd':
            switch (*p ++) {
            case 'e':
                if (*p ++ == 'x' &&
                    *p == 0)
                    return "cdex";
                return error;
            case 'f':
                if (*p ++ == 'y' &&
                    *p == 0)
                    return "cdfy";
                return error;
            case 'g':
                if (*p ++ == 'z' &&
                    *p == 0)
                    return "cdgz";
                return error;
            case 'h':
                if (*p ++ == 'w' &&
                    *p == 0)
                    return "cdhw";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ce";
        }
    }
    return error;
$ print pot potato pottery tattoo tempo|trie
    switch (*p ++) {
    case 'p':
        if (prefix("ot", p)) {
            p += 2;
            if (*p == 0)
                return "pot";
            switch (*p ++) {
            case 'a':
                if (equal(p, "to"))
                    return "potato";
                return error;
            case 't':
                if (equal(p, "ery"))
                    return "pottery";
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (equal(p, "ttoo"))
                return "tattoo";
            return error;
        case 'e':
            if (equal(p, "mpo"))
                return "tempo";
        }
    }
    return error;
$

--[ gen-compact-c-code-path-function-base0-ternary ]----------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --path=function --trie=ternary "$@"; }
$ print a|trie
    if (*p ++ == 'a' &&
        *p == 0)
        return "a";
    return error;
$ print a ab|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
    }
    return error;
$ print a ab abc|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            if (*p ++ == 'c' &&
                *p == 0)
                return "abc";
        }
    }
    return error;
$ print a b|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        if (*p == 0)
            return "b";
    }
    return error;
$ print a b abc bac abd|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
            }
        }
        return error;
    case 'b':
        if (*p == 0)
            return "b";
        if (equal(p, "ac"))
            return "bac";
    }
    return error;
$ print a bb ba c|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print a bb ba cc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p ++ == 'c' &&
            *p == 0)
            return "cc";
    }
    return error;
$ print a bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print a bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "de"))
            return "cde";
    }
    return error;
$ print a bb ba cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "def"))
            return "cdef";
    }
    return error;
$ print a bb ba cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix("def", p)) {
            p += 3;
            if (*p == 0)
                return "cdef";
            if (*p ++ == 'g' &&
                *p == 0)
                return "cdefg";
        }
    }
    return error;
$ print a bb bac cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'c' &&
                *p == 0)
                return "bac";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "def"))
            return "cdef";
    }
    return error;
$ print a bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print a bbx bay ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 'y' &&
                *p == 0)
                return "bay";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print a cde cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f' &&
                *p == 0)
                return "cdef";
        }
    }
    return error;
$ print a cde cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if (*p ++ == 'g' &&
                    *p == 0)
                    return "cdefg";
            }
        }
    }
    return error;
$ print a cde cdef cdefgh|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if (equal(p, "gh"))
                    return "cdefgh";
            }
        }
    }
    return error;
$ print a cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("def", p)) {
            p += 3;
            if (*p == 0)
                return "cdef";
            if (*p ++ == 'g' &&
                *p == 0)
                return "cdefg";
        }
    }
    return error;
$ print ab|trie
    if (equal(p, "ab"))
        return "ab";
    return error;
$ print ab bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print ab bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "de"))
            return "cde";
    }
    return error;
$ print ab bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p ++ == 'x' &&
                *p == 0)
                return "bbx";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print ab c|trie
    switch (*p ++) {
    case 'a':
        if (*p ++ == 'b' &&
            *p == 0)
            return "ab";
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print abc bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (equal(p, "bc"))
            return "abc";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (equal(p, "cc"))
            return "ccc";
    }
    return error;
$ print abcd abde abef|trie
    if (prefix("ab", p)) {
        p += 2;
        switch (*p ++) {
        case 'c':
            if (*p ++ == 'd' &&
                *p == 0)
                return "abcd";
            return error;
        case 'd':
            if (*p ++ == 'e' &&
                *p == 0)
                return "abde";
            return error;
        case 'e':
            if (*p ++ == 'f' &&
                *p == 0)
                return "abef";
        }
    }
    return error;
$ print abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
        }
    }
    return error;
$ print ac ab|trie
    if (*p ++ == 'a') {
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            return error;
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print aef ae abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ae";
            if (*p ++ == 'f' &&
                *p == 0)
                return "aef";
        }
    }
    return error;
$ print cde cdef cdefgh|trie
    if (prefix("cde", p)) {
        p += 3;
        if (*p == 0)
            return "cde";
        if (*p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if (equal(p, "gh"))
                return "cdefgh";
        }
    }
    return error;
$ print cdef cdefg|trie
    if (prefix("cdef", p)) {
        p += 4;
        if (*p == 0)
            return "cdef";
        if (*p ++ == 'g' &&
            *p == 0)
            return "cdefg";
    }
    return error;
$ print cdex cdfy cdgz cdhw|trie
    if (prefix("cd", p)) {
        p += 2;
        switch (*p ++) {
        case 'e':
            if (*p ++ == 'x' &&
                *p == 0)
                return "cdex";
            return error;
        case 'f':
            if (*p ++ == 'y' &&
                *p == 0)
                return "cdfy";
            return error;
        case 'g':
            if (*p ++ == 'z' &&
                *p == 0)
                return "cdgz";
            return error;
        case 'h':
            if (*p ++ == 'w' &&
                *p == 0)
                return "cdhw";
        }
    }
    return error;
$ print ce cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        switch (*p ++) {
        case 'd':
            switch (*p ++) {
            case 'e':
                if (*p ++ == 'x' &&
                    *p == 0)
                    return "cdex";
                return error;
            case 'f':
                if (*p ++ == 'y' &&
                    *p == 0)
                    return "cdfy";
                return error;
            case 'g':
                if (*p ++ == 'z' &&
                    *p == 0)
                    return "cdgz";
                return error;
            case 'h':
                if (*p ++ == 'w' &&
                    *p == 0)
                    return "cdhw";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ce";
        }
    }
    return error;
$ print pot potato pottery tattoo tempo|trie
    switch (*p ++) {
    case 'p':
        if (prefix("ot", p)) {
            p += 2;
            if (*p == 0)
                return "pot";
            switch (*p ++) {
            case 'a':
                if (equal(p, "to"))
                    return "potato";
                return error;
            case 't':
                if (equal(p, "ery"))
                    return "pottery";
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (equal(p, "ttoo"))
                return "tattoo";
            return error;
        case 'e':
            if (equal(p, "mpo"))
                return "tempo";
        }
    }
    return error;
$

--[ gen-compact-c-code-path-function-base-array ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --path=function --attrs --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
.   // [1,'a']
.   // [0,"",'a',[0]]
.   if (*p ++ == 'a' &&
.   .   *p == 0)
.   .   return "a";
.   return error;
$ print a b|trie
.   // [2,'b']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   }
.   return error;
$ print a b c|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   .   return error;
.   // [0,"",'c',[0]]
.   case 'c':
.   .   if (*p == 0)
.   .   .   return "c";
.   }
.   return error;
$ print a ab abc|trie
.   // [1,'a']
.   // [0,"",'a',[1,'b']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"",'b',[1,'c']]
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   // [0,"",'c',[0]]
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "abc";
.   .   }
.   }
.   return error;
$ print a ab ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac ad|trie
.   // [1,'a']
.   // [0,"",'a',[3,'d']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "ad";
.   .   }
.   }
.   return error;
$ print a abd ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"b",'d',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p == 0)
.   .   .   .   return "abd";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac acd|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"",'d',[0]]
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p == 0)
.   .   .   .   return "acd";
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (equal(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"b",'b',[0]]
.   case 'b':
.   .   if (*p ++ == 'b' &&
.   .   .   *p == 0)
.   .   .   return "bb";
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (equal(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (equal(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print abc abd acde|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"cd",'e',[0]]
.   .   case 'c':
.   .   .   if (equal(p, "de"))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"d",'e',[0]]
.   .   .   if (equal(p, "de"))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde acfg|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[2,'f']]
.   .   case 'c':
.   .   .   switch (*p ++) {
.   .   .   // [0,"d",'e',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p ++ == 'e' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "acde";
.   .   .   .   return error;
.   .   .   // [0,"f",'g',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p ++ == 'g' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "acfg";
.   .   .   }
.   .   }
.   }
.   return error;
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'f']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cde";
.   .   .   return error;
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (equal(p, "zz"))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'g']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (equal(p, "zz"))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [0,"g",'e',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cge";
.   .   }
.   }
.   return error;
$ print a abcd abcdefg h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[1,'e']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   if (equal(p, "efg"))
.   .   .   .   return "abcdefg";
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (equal(p, "ijk"))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (equal(p, "fg"))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (equal(p, "yz"))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (equal(p, "ijk"))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (equal(p, "fg"))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (equal(p, "yz"))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[2,'l']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   switch (*p ++) {
.   .   // [0,"ij",'k',[0]]
.   .   case 'i':
.   .   .   if (equal(p, "jk"))
.   .   .   .   return "hijk";
.   .   .   return error;
.   .   // [0,"l",'m',[0]]
.   .   case 'l':
.   .   .   if (*p ++ == 'm' &&
.   .   .   .   *p == 0)
.   .   .   .   return "hlm";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-base-ternary ]-----------------------------

$ trie() { ../src/trie --gen=compact --output=c-code --path=function --attrs --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
.   // [1,'a']
.   // [0,"",'a',[0]]
.   if (*p ++ == 'a' &&
.   .   *p == 0)
.   .   return "a";
.   return error;
$ print a b|trie
.   // [2,'b']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   }
.   return error;
$ print a b c|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   .   return error;
.   // [0,"",'c',[0]]
.   case 'c':
.   .   if (*p == 0)
.   .   .   return "c";
.   }
.   return error;
$ print a ab abc|trie
.   // [1,'a']
.   // [0,"",'a',[1,'b']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"",'b',[1,'c']]
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   // [0,"",'c',[0]]
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "abc";
.   .   }
.   }
.   return error;
$ print a ab ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac ad|trie
.   // [1,'a']
.   // [0,"",'a',[3,'d']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "ad";
.   .   }
.   }
.   return error;
$ print a abd ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"b",'d',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p == 0)
.   .   .   .   return "abd";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac acd|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"",'d',[0]]
.   .   .   if (*p ++ == 'd' &&
.   .   .   .   *p == 0)
.   .   .   .   return "acd";
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (equal(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"b",'b',[0]]
.   case 'b':
.   .   if (*p ++ == 'b' &&
.   .   .   *p == 0)
.   .   .   return "bb";
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (equal(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (equal(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print abc abd acde|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"cd",'e',[0]]
.   .   case 'c':
.   .   .   if (equal(p, "de"))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"d",'e',[0]]
.   .   .   if (equal(p, "de"))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde acfg|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[2,'f']]
.   .   case 'c':
.   .   .   switch (*p ++) {
.   .   .   // [0,"d",'e',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p ++ == 'e' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "acde";
.   .   .   .   return error;
.   .   .   // [0,"f",'g',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p ++ == 'g' &&
.   .   .   .   .   *p == 0)
.   .   .   .   .   return "acfg";
.   .   .   }
.   .   }
.   }
.   return error;
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'f']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cde";
.   .   .   return error;
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (equal(p, "zz"))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'g']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if (*p ++ == 'z' &&
.   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (equal(p, "zz"))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [0,"g",'e',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cge";
.   .   }
.   }
.   return error;
$ print a abcd abcdefg h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[1,'e']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   if (equal(p, "efg"))
.   .   .   .   return "abcdefg";
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (equal(p, "ijk"))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (equal(p, "fg"))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (equal(p, "yz"))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (equal(p, "ijk"))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (equal(p, "fg"))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (equal(p, "yz"))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[2,'l']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   switch (*p ++) {
.   .   // [0,"ij",'k',[0]]
.   .   case 'i':
.   .   .   if (equal(p, "jk"))
.   .   .   .   return "hijk";
.   .   .   return error;
.   .   // [0,"l",'m',[0]]
.   .   case 'l':
.   .   .   if (*p ++ == 'm' &&
.   .   .   .   *p == 0)
.   .   .   .   return "hlm";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-alphabets-array ]--------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --path=function --trie=array < alphabets.txt
.   // [25,'z']
.   switch (*p ++) {
.   // [0,"",'a',[8,'z']]
.   case 'a':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "aa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "af";
.   .   .   return error;
.   .   // [0,"g",'q',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "agq";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "ak";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "am";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ar";
.   .   .   return error;
.   .   // [0,"",'s',[2,'t']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "as";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'a',[0]]
.   .   .   case 'a':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "asa";
.   .   .   .   return error;
.   .   .   // [0,"",'t',[0]]
.   .   .   case 't':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ast";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "az";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (equal(p, "_Cyrl"))
.   .   .   .   return "az_Cyrl";
.   .   }
.   .   return error;
.   // [0,"",'b',[9,'y']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "bas";
.   .   .   return error;
.   .   // [0,"",'e',[2,'z']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "be";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bem";
.   .   .   .   return error;
.   .   .   // [0,"",'z',[0]]
.   .   .   case 'z':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bez";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "bg";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "bm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "bn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "bo";
.   .   .   return error;
.   .   // [0,"",'r',[1,'x']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "br";
.   .   .   // [0,"",'x',[0]]
.   .   .   if (*p ++ == 'x' &&
.   .   .   .   *p == 0)
.   .   .   .   return "brx";
.   .   .   return error;
.   .   // [0,"",'s',[1,'_']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "bs";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (equal(p, "_Cyrl"))
.   .   .   .   return "bs_Cyrl";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "byn";
.   .   }
.   .   return error;
.   // [0,"",'c',[5,'y']]
.   case 'c':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ca";
.   .   .   return error;
.   .   // [0,"g",'g',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cgg";
.   .   .   return error;
.   .   // [0,"h",'r',[0]]
.   .   case 'h':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "chr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "cs";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "cy";
.   .   }
.   .   return error;
.   // [0,"",'d',[6,'z']]
.   case 'd':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'v']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "da";
.   .   .   // [0,"",'v',[0]]
.   .   .   if (*p ++ == 'v' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dav";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "de";
.   .   .   return error;
.   .   // [0,"j",'e',[0]]
.   .   case 'j':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dje";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dua";
.   .   .   return error;
.   .   // [0,"y",'o',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dyo";
.   .   .   return error;
.   .   // [0,"",'z',[0]]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "dz";
.   .   }
.   .   return error;
.   // [0,"",'e',[9,'w']]
.   case 'e':
.   .   switch (*p ++) {
.   .   // [0,"b",'u',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'u' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ebu";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ee";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "el";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "en";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "eo";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "es";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "et";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "eu";
.   .   .   return error;
.   .   // [0,"w",'o',[0]]
.   .   case 'w':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ewo";
.   .   }
.   .   return error;
.   // [0,"",'f',[7,'y']]
.   case 'f':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "fa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "ff";
.   .   .   return error;
.   .   // [0,"",'i',[1,'l']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "fi";
.   .   .   // [0,"",'l',[0]]
.   .   .   if (*p ++ == 'l' &&
.   .   .   .   *p == 0)
.   .   .   .   return "fil";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "fo";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "fr";
.   .   .   return error;
.   .   // [0,"u",'r',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "fur";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "fy";
.   .   }
.   .   return error;
.   // [0,"",'g',[6,'v']]
.   case 'g':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ga";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "gd";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "gl";
.   .   .   return error;
.   .   // [0,"s",'w',[0]]
.   .   case 's':
.   .   .   if (*p ++ == 'w' &&
.   .   .   .   *p == 0)
.   .   .   .   return "gsw";
.   .   .   return error;
.   .   // [0,"",'u',[1,'z']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "gu";
.   .   .   // [0,"",'z',[0]]
.   .   .   if (*p ++ == 'z' &&
.   .   .   .   *p == 0)
.   .   .   .   return "guz";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "gv";
.   .   }
.   .   return error;
.   // [0,"",'h',[6,'y']]
.   case 'h':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'w']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ha";
.   .   .   // [0,"",'w',[0]]
.   .   .   if (*p ++ == 'w' &&
.   .   .   .   *p == 0)
.   .   .   .   return "haw";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "he";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "hi";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "hr";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "hu";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "hy";
.   .   }
.   .   return error;
.   // [0,"",'i',[6,'t']]
.   case 'i':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ia";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "id";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ig";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ii";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "is";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "it";
.   .   }
.   .   return error;
.   // [0,"",'j',[3,'m']]
.   case 'j':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ja";
.   .   .   return error;
.   .   // [0,"g",'o',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "jgo";
.   .   .   return error;
.   .   // [0,"m",'c',[0]]
.   .   case 'm':
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "jmc";
.   .   }
.   .   return error;
.   // [0,"",'k',[13,'y']]
.   case 'k':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'m']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ka";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kab";
.   .   .   .   return error;
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kam";
.   .   .   }
.   .   .   return error;
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kde";
.   .   .   return error;
.   .   // [0,"e",'a',[0]]
.   .   case 'e':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kea";
.   .   .   return error;
.   .   // [0,"h",'q',[0]]
.   .   case 'h':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "khq";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ki";
.   .   .   return error;
.   .   // [0,"",'k',[1,'j']]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "kk";
.   .   .   // [0,"",'j',[0]]
.   .   .   if (*p ++ == 'j' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kkj";
.   .   .   return error;
.   .   // [0,"",'l',[1,'n']]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "kl";
.   .   .   // [0,"",'n',[0]]
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kln";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "km";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "kn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'k']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ko";
.   .   .   // [0,"",'k',[0]]
.   .   .   if (*p ++ == 'k' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kok";
.   .   .   return error;
.   .   // [0,"",'s',[3,'h']]
.   .   case 's':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksb";
.   .   .   .   return error;
.   .   .   // [0,"",'f',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksf";
.   .   .   .   return error;
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksh";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'w',[0]]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "kw";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "ky";
.   .   }
.   .   return error;
.   // [0,"",'l',[8,'v']]
.   case 'l':
.   .   switch (*p ++) {
.   .   // [0,"a",'g',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "lag";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "lg";
.   .   .   return error;
.   .   // [0,"k",'t',[0]]
.   .   case 'k':
.   .   .   if (*p ++ == 't' &&
.   .   .   .   *p == 0)
.   .   .   .   return "lkt";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "ln";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "lo";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "lt";
.   .   .   return error;
.   .   // [0,"",'u',[2,'y']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "lu";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luo";
.   .   .   .   return error;
.   .   .   // [0,"",'y',[0]]
.   .   .   case 'y':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luy";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "lv";
.   .   }
.   .   return error;
.   // [0,"",'m',[12,'y']]
.   case 'm':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mas";
.   .   .   return error;
.   .   // [0,"e",'r',[0]]
.   .   case 'e':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mer";
.   .   .   return error;
.   .   // [0,"f",'e',[0]]
.   .   case 'f':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mfe";
.   .   .   return error;
.   .   // [0,"",'g',[2,'o']]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "mg";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgh";
.   .   .   .   return error;
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgo";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "mk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "ml";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "mn";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "mr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ms";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "mt";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mua";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "my";
.   .   }
.   .   return error;
.   // [0,"",'n',[11,'y']]
.   case 'n':
.   .   switch (*p ++) {
.   .   // [0,"a",'q',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "naq";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "nb";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "nd";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ne";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "nl";
.   .   .   return error;
.   .   // [0,"m",'g',[0]]
.   .   case 'm':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nmg";
.   .   .   return error;
.   .   // [0,"",'n',[1,'h']]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "nn";
.   .   .   // [0,"",'h',[0]]
.   .   .   if (*p ++ == 'h' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nnh";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "nr";
.   .   .   return error;
.   .   // [0,"s",'o',[0]]
.   .   case 's':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nso";
.   .   .   return error;
.   .   // [0,"u",'s',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nus";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nyn";
.   .   }
.   .   return error;
.   // [0,"",'o',[3,'s']]
.   case 'o':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "om";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "or";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "os";
.   .   }
.   .   return error;
.   // [0,"",'p',[4,'t']]
.   case 'p':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'_']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "pa";
.   .   .   // [0,"_Ara",'b',[0]]
.   .   .   if (equal(p, "_Arab"))
.   .   .   .   return "pa_Arab";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "pl";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ps";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "pt";
.   .   }
.   .   return error;
.   // [0,"",'r',[5,'w']]
.   case 'r':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "rm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "rn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'f']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ro";
.   .   .   // [0,"",'f',[0]]
.   .   .   if (*p ++ == 'f' &&
.   .   .   .   *p == 0)
.   .   .   .   return "rof";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "ru";
.   .   .   return error;
.   .   // [0,"",'w',[1,'k']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "rw";
.   .   .   // [0,"",'k',[0]]
.   .   .   if (*p ++ == 'k' &&
.   .   .   .   *p == 0)
.   .   .   .   return "rwk";
.   .   }
.   .   return error;
.   // [0,"",'s',[16,'w']]
.   case 's':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'q']]
.   .   case 'a':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sah";
.   .   .   .   return error;
.   .   .   // [0,"",'q',[0]]
.   .   .   case 'q':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "saq";
.   .   .   }
.   .   .   return error;
.   .   // [0,"b",'p',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'p' &&
.   .   .   .   *p == 0)
.   .   .   .   return "sbp";
.   .   .   return error;
.   .   // [0,"",'e',[2,'s']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "se";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "seh";
.   .   .   .   return error;
.   .   .   // [0,"",'s',[0]]
.   .   .   case 's':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ses";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "sg";
.   .   .   return error;
.   .   // [0,"h",'i',[1,'_']]
.   .   case 'h':
.   .   .   if (*p ++ == 'i') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "shi";
.   .   .   .   // [1,"h_Lat",'n',[0]]
.   .   .   .   if (equal(p, "_Latn"))
.   .   .   .   .   return "shi_Latn";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "si";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "sk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "sl";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "sn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "so";
.   .   .   return error;
.   .   // [0,"",'q',[0]]
.   .   case 'q':
.   .   .   if (*p == 0)
.   .   .   .   return "sq";
.   .   .   return error;
.   .   // [0,"",'r',[1,'_']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "sr";
.   .   .   // [0,"_Lat",'n',[0]]
.   .   .   if (equal(p, "_Latn"))
.   .   .   .   return "sr_Latn";
.   .   .   return error;
.   .   // [0,"",'s',[1,'y']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ss";
.   .   .   // [0,"",'y',[0]]
.   .   .   if (*p ++ == 'y' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ssy";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "st";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "sv";
.   .   .   return error;
.   .   // [0,"",'w',[1,'c']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "sw";
.   .   .   // [0,"",'c',[0]]
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "swc";
.   .   }
.   .   return error;
.   // [0,"",'t',[11,'z']]
.   case 't':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ta";
.   .   .   return error;
.   .   // [0,"",'e',[1,'o']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "te";
.   .   .   // [0,"",'o',[0]]
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "teo";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "tg";
.   .   .   return error;
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "th";
.   .   .   return error;
.   .   // [0,"",'i',[2,'g']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ti";
.   .   .   switch (*p ++) {
.   .   .   // [0,"_E",'R',[0]]
.   .   .   case '_':
.   .   .   .   if (equal(p, "ER"))
.   .   .   .   .   return "ti_ER";
.   .   .   .   return error;
.   .   .   // [0,"",'g',[0]]
.   .   .   case 'g':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tig";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "tn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "to";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "tr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ts";
.   .   .   return error;
.   .   // [0,"w",'q',[0]]
.   .   case 'w':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "twq";
.   .   .   return error;
.   .   // [0,"z",'m',[0]]
.   .   case 'z':
.   .   .   if (*p ++ == 'm' &&
.   .   .   .   *p == 0)
.   .   .   .   return "tzm";
.   .   }
.   .   return error;
.   // [0,"",'u',[4,'z']]
.   case 'u':
.   .   switch (*p ++) {
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ug";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "uk";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ur";
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "uz";
.   .   .   // [0,"",'_',[2,'C']]
.   .   .   if (*p ++ == '_') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [0,"Ara",'b',[0]]
.   .   .   .   case 'A':
.   .   .   .   .   if (equal(p, "rab"))
.   .   .   .   .   .   return "uz_Arab";
.   .   .   .   .   return error;
.   .   .   .   // [0,"Cyr",'l',[0]]
.   .   .   .   case 'C':
.   .   .   .   .   if (equal(p, "yrl"))
.   .   .   .   .   .   return "uz_Cyrl";
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'v',[5,'u']]
.   case 'v':
.   .   switch (*p ++) {
.   .   // [0,"ai_Lat",'n',[0]]
.   .   case 'a':
.   .   .   if (equal(p, "i_Latn"))
.   .   .   .   return "vai_Latn";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ve";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "vi";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "vo";
.   .   .   return error;
.   .   // [0,"u",'n',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "vun";
.   .   }
.   .   return error;
.   // [0,"w",'a',[2,'l']]
.   case 'w':
.   .   if (*p ++ == 'a') {
.   .   .   switch (*p ++) {
.   .   .   // [1,"w",'e',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wae";
.   .   .   .   return error;
.   .   .   // [1,"w",'l',[0]]
.   .   .   case 'l':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wal";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'x',[2,'o']]
.   case 'x':
.   .   switch (*p ++) {
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "xh";
.   .   .   return error;
.   .   // [0,"o",'g',[0]]
.   .   case 'o':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "xog";
.   .   }
.   .   return error;
.   // [0,"",'y',[2,'o']]
.   case 'y':
.   .   switch (*p ++) {
.   .   // [0,"a",'v',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'v' &&
.   .   .   .   *p == 0)
.   .   .   .   return "yav";
.   .   .   return error;
.   .   // [0,"",'o',[1,'_']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "yo";
.   .   .   // [0,"_B",'J',[0]]
.   .   .   if (equal(p, "_BJ"))
.   .   .   .   return "yo_BJ";
.   .   }
.   .   return error;
.   // [0,"",'z',[3,'u']]
.   case 'z':
.   .   switch (*p ++) {
.   .   // [0,"g",'h',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'h' &&
.   .   .   .   *p == 0)
.   .   .   .   return "zgh";
.   .   .   return error;
.   .   // [0,"",'h',[1,'_']]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "zh";
.   .   .   // [0,"_Han",'t',[0]]
.   .   .   if (equal(p, "_Hant"))
.   .   .   .   return "zh_Hant";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "zu";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-alphabets-ternary ]------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --path=function --trie=ternary < alphabets.txt
.   // [25,'z']
.   switch (*p ++) {
.   // [0,"",'a',[8,'z']]
.   case 'a':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "aa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "af";
.   .   .   return error;
.   .   // [0,"g",'q',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "agq";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "ak";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "am";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ar";
.   .   .   return error;
.   .   // [0,"",'s',[2,'t']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "as";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'a',[0]]
.   .   .   case 'a':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "asa";
.   .   .   .   return error;
.   .   .   // [0,"",'t',[0]]
.   .   .   case 't':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ast";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "az";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (equal(p, "_Cyrl"))
.   .   .   .   return "az_Cyrl";
.   .   }
.   .   return error;
.   // [0,"",'b',[9,'y']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "bas";
.   .   .   return error;
.   .   // [0,"",'e',[2,'z']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "be";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bem";
.   .   .   .   return error;
.   .   .   // [0,"",'z',[0]]
.   .   .   case 'z':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bez";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "bg";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "bm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "bn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "bo";
.   .   .   return error;
.   .   // [0,"",'r',[1,'x']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "br";
.   .   .   // [0,"",'x',[0]]
.   .   .   if (*p ++ == 'x' &&
.   .   .   .   *p == 0)
.   .   .   .   return "brx";
.   .   .   return error;
.   .   // [0,"",'s',[1,'_']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "bs";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (equal(p, "_Cyrl"))
.   .   .   .   return "bs_Cyrl";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "byn";
.   .   }
.   .   return error;
.   // [0,"",'c',[5,'y']]
.   case 'c':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ca";
.   .   .   return error;
.   .   // [0,"g",'g',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "cgg";
.   .   .   return error;
.   .   // [0,"h",'r',[0]]
.   .   case 'h':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "chr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "cs";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "cy";
.   .   }
.   .   return error;
.   // [0,"",'d',[6,'z']]
.   case 'd':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'v']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "da";
.   .   .   // [0,"",'v',[0]]
.   .   .   if (*p ++ == 'v' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dav";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "de";
.   .   .   return error;
.   .   // [0,"j",'e',[0]]
.   .   case 'j':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dje";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dua";
.   .   .   return error;
.   .   // [0,"y",'o',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "dyo";
.   .   .   return error;
.   .   // [0,"",'z',[0]]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "dz";
.   .   }
.   .   return error;
.   // [0,"",'e',[9,'w']]
.   case 'e':
.   .   switch (*p ++) {
.   .   // [0,"b",'u',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'u' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ebu";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ee";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "el";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "en";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "eo";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "es";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "et";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "eu";
.   .   .   return error;
.   .   // [0,"w",'o',[0]]
.   .   case 'w':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ewo";
.   .   }
.   .   return error;
.   // [0,"",'f',[7,'y']]
.   case 'f':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "fa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "ff";
.   .   .   return error;
.   .   // [0,"",'i',[1,'l']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "fi";
.   .   .   // [0,"",'l',[0]]
.   .   .   if (*p ++ == 'l' &&
.   .   .   .   *p == 0)
.   .   .   .   return "fil";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "fo";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "fr";
.   .   .   return error;
.   .   // [0,"u",'r',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "fur";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "fy";
.   .   }
.   .   return error;
.   // [0,"",'g',[6,'v']]
.   case 'g':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ga";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "gd";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "gl";
.   .   .   return error;
.   .   // [0,"s",'w',[0]]
.   .   case 's':
.   .   .   if (*p ++ == 'w' &&
.   .   .   .   *p == 0)
.   .   .   .   return "gsw";
.   .   .   return error;
.   .   // [0,"",'u',[1,'z']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "gu";
.   .   .   // [0,"",'z',[0]]
.   .   .   if (*p ++ == 'z' &&
.   .   .   .   *p == 0)
.   .   .   .   return "guz";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "gv";
.   .   }
.   .   return error;
.   // [0,"",'h',[6,'y']]
.   case 'h':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'w']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ha";
.   .   .   // [0,"",'w',[0]]
.   .   .   if (*p ++ == 'w' &&
.   .   .   .   *p == 0)
.   .   .   .   return "haw";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "he";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "hi";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "hr";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "hu";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "hy";
.   .   }
.   .   return error;
.   // [0,"",'i',[6,'t']]
.   case 'i':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ia";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "id";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ig";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ii";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "is";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "it";
.   .   }
.   .   return error;
.   // [0,"",'j',[3,'m']]
.   case 'j':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ja";
.   .   .   return error;
.   .   // [0,"g",'o',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "jgo";
.   .   .   return error;
.   .   // [0,"m",'c',[0]]
.   .   case 'm':
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "jmc";
.   .   }
.   .   return error;
.   // [0,"",'k',[13,'y']]
.   case 'k':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'m']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ka";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kab";
.   .   .   .   return error;
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kam";
.   .   .   }
.   .   .   return error;
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kde";
.   .   .   return error;
.   .   // [0,"e",'a',[0]]
.   .   case 'e':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kea";
.   .   .   return error;
.   .   // [0,"h",'q',[0]]
.   .   case 'h':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "khq";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ki";
.   .   .   return error;
.   .   // [0,"",'k',[1,'j']]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "kk";
.   .   .   // [0,"",'j',[0]]
.   .   .   if (*p ++ == 'j' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kkj";
.   .   .   return error;
.   .   // [0,"",'l',[1,'n']]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "kl";
.   .   .   // [0,"",'n',[0]]
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kln";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "km";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "kn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'k']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ko";
.   .   .   // [0,"",'k',[0]]
.   .   .   if (*p ++ == 'k' &&
.   .   .   .   *p == 0)
.   .   .   .   return "kok";
.   .   .   return error;
.   .   // [0,"",'s',[3,'h']]
.   .   case 's':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksb";
.   .   .   .   return error;
.   .   .   // [0,"",'f',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksf";
.   .   .   .   return error;
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksh";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'w',[0]]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "kw";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "ky";
.   .   }
.   .   return error;
.   // [0,"",'l',[8,'v']]
.   case 'l':
.   .   switch (*p ++) {
.   .   // [0,"a",'g',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "lag";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "lg";
.   .   .   return error;
.   .   // [0,"k",'t',[0]]
.   .   case 'k':
.   .   .   if (*p ++ == 't' &&
.   .   .   .   *p == 0)
.   .   .   .   return "lkt";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "ln";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "lo";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "lt";
.   .   .   return error;
.   .   // [0,"",'u',[2,'y']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "lu";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luo";
.   .   .   .   return error;
.   .   .   // [0,"",'y',[0]]
.   .   .   case 'y':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luy";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "lv";
.   .   }
.   .   return error;
.   // [0,"",'m',[12,'y']]
.   case 'm':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mas";
.   .   .   return error;
.   .   // [0,"e",'r',[0]]
.   .   case 'e':
.   .   .   if (*p ++ == 'r' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mer";
.   .   .   return error;
.   .   // [0,"f",'e',[0]]
.   .   case 'f':
.   .   .   if (*p ++ == 'e' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mfe";
.   .   .   return error;
.   .   // [0,"",'g',[2,'o']]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "mg";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgh";
.   .   .   .   return error;
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgo";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "mk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "ml";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "mn";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "mr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ms";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "mt";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'a' &&
.   .   .   .   *p == 0)
.   .   .   .   return "mua";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "my";
.   .   }
.   .   return error;
.   // [0,"",'n',[11,'y']]
.   case 'n':
.   .   switch (*p ++) {
.   .   // [0,"a",'q',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "naq";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "nb";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "nd";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ne";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "nl";
.   .   .   return error;
.   .   // [0,"m",'g',[0]]
.   .   case 'm':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nmg";
.   .   .   return error;
.   .   // [0,"",'n',[1,'h']]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "nn";
.   .   .   // [0,"",'h',[0]]
.   .   .   if (*p ++ == 'h' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nnh";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "nr";
.   .   .   return error;
.   .   // [0,"s",'o',[0]]
.   .   case 's':
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nso";
.   .   .   return error;
.   .   // [0,"u",'s',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 's' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nus";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "nyn";
.   .   }
.   .   return error;
.   // [0,"",'o',[3,'s']]
.   case 'o':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "om";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "or";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "os";
.   .   }
.   .   return error;
.   // [0,"",'p',[4,'t']]
.   case 'p':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'_']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "pa";
.   .   .   // [0,"_Ara",'b',[0]]
.   .   .   if (equal(p, "_Arab"))
.   .   .   .   return "pa_Arab";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "pl";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ps";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "pt";
.   .   }
.   .   return error;
.   // [0,"",'r',[5,'w']]
.   case 'r':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "rm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "rn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'f']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ro";
.   .   .   // [0,"",'f',[0]]
.   .   .   if (*p ++ == 'f' &&
.   .   .   .   *p == 0)
.   .   .   .   return "rof";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "ru";
.   .   .   return error;
.   .   // [0,"",'w',[1,'k']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "rw";
.   .   .   // [0,"",'k',[0]]
.   .   .   if (*p ++ == 'k' &&
.   .   .   .   *p == 0)
.   .   .   .   return "rwk";
.   .   }
.   .   return error;
.   // [0,"",'s',[16,'w']]
.   case 's':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'q']]
.   .   case 'a':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sah";
.   .   .   .   return error;
.   .   .   // [0,"",'q',[0]]
.   .   .   case 'q':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "saq";
.   .   .   }
.   .   .   return error;
.   .   // [0,"b",'p',[0]]
.   .   case 'b':
.   .   .   if (*p ++ == 'p' &&
.   .   .   .   *p == 0)
.   .   .   .   return "sbp";
.   .   .   return error;
.   .   // [0,"",'e',[2,'s']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "se";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "seh";
.   .   .   .   return error;
.   .   .   // [0,"",'s',[0]]
.   .   .   case 's':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ses";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "sg";
.   .   .   return error;
.   .   // [0,"h",'i',[1,'_']]
.   .   case 'h':
.   .   .   if (*p ++ == 'i') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "shi";
.   .   .   .   // [1,"h_Lat",'n',[0]]
.   .   .   .   if (equal(p, "_Latn"))
.   .   .   .   .   return "shi_Latn";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "si";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "sk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "sl";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "sn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "so";
.   .   .   return error;
.   .   // [0,"",'q',[0]]
.   .   case 'q':
.   .   .   if (*p == 0)
.   .   .   .   return "sq";
.   .   .   return error;
.   .   // [0,"",'r',[1,'_']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "sr";
.   .   .   // [0,"_Lat",'n',[0]]
.   .   .   if (equal(p, "_Latn"))
.   .   .   .   return "sr_Latn";
.   .   .   return error;
.   .   // [0,"",'s',[1,'y']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ss";
.   .   .   // [0,"",'y',[0]]
.   .   .   if (*p ++ == 'y' &&
.   .   .   .   *p == 0)
.   .   .   .   return "ssy";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "st";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "sv";
.   .   .   return error;
.   .   // [0,"",'w',[1,'c']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "sw";
.   .   .   // [0,"",'c',[0]]
.   .   .   if (*p ++ == 'c' &&
.   .   .   .   *p == 0)
.   .   .   .   return "swc";
.   .   }
.   .   return error;
.   // [0,"",'t',[11,'z']]
.   case 't':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ta";
.   .   .   return error;
.   .   // [0,"",'e',[1,'o']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "te";
.   .   .   // [0,"",'o',[0]]
.   .   .   if (*p ++ == 'o' &&
.   .   .   .   *p == 0)
.   .   .   .   return "teo";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "tg";
.   .   .   return error;
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "th";
.   .   .   return error;
.   .   // [0,"",'i',[2,'g']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ti";
.   .   .   switch (*p ++) {
.   .   .   // [0,"_E",'R',[0]]
.   .   .   case '_':
.   .   .   .   if (equal(p, "ER"))
.   .   .   .   .   return "ti_ER";
.   .   .   .   return error;
.   .   .   // [0,"",'g',[0]]
.   .   .   case 'g':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tig";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "tn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "to";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "tr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ts";
.   .   .   return error;
.   .   // [0,"w",'q',[0]]
.   .   case 'w':
.   .   .   if (*p ++ == 'q' &&
.   .   .   .   *p == 0)
.   .   .   .   return "twq";
.   .   .   return error;
.   .   // [0,"z",'m',[0]]
.   .   case 'z':
.   .   .   if (*p ++ == 'm' &&
.   .   .   .   *p == 0)
.   .   .   .   return "tzm";
.   .   }
.   .   return error;
.   // [0,"",'u',[4,'z']]
.   case 'u':
.   .   switch (*p ++) {
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ug";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "uk";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ur";
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "uz";
.   .   .   // [0,"",'_',[2,'C']]
.   .   .   if (*p ++ == '_') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [0,"Ara",'b',[0]]
.   .   .   .   case 'A':
.   .   .   .   .   if (equal(p, "rab"))
.   .   .   .   .   .   return "uz_Arab";
.   .   .   .   .   return error;
.   .   .   .   // [0,"Cyr",'l',[0]]
.   .   .   .   case 'C':
.   .   .   .   .   if (equal(p, "yrl"))
.   .   .   .   .   .   return "uz_Cyrl";
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'v',[5,'u']]
.   case 'v':
.   .   switch (*p ++) {
.   .   // [0,"ai_Lat",'n',[0]]
.   .   case 'a':
.   .   .   if (equal(p, "i_Latn"))
.   .   .   .   return "vai_Latn";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ve";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "vi";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "vo";
.   .   .   return error;
.   .   // [0,"u",'n',[0]]
.   .   case 'u':
.   .   .   if (*p ++ == 'n' &&
.   .   .   .   *p == 0)
.   .   .   .   return "vun";
.   .   }
.   .   return error;
.   // [0,"w",'a',[2,'l']]
.   case 'w':
.   .   if (*p ++ == 'a') {
.   .   .   switch (*p ++) {
.   .   .   // [1,"w",'e',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wae";
.   .   .   .   return error;
.   .   .   // [1,"w",'l',[0]]
.   .   .   case 'l':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wal";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'x',[2,'o']]
.   case 'x':
.   .   switch (*p ++) {
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "xh";
.   .   .   return error;
.   .   // [0,"o",'g',[0]]
.   .   case 'o':
.   .   .   if (*p ++ == 'g' &&
.   .   .   .   *p == 0)
.   .   .   .   return "xog";
.   .   }
.   .   return error;
.   // [0,"",'y',[2,'o']]
.   case 'y':
.   .   switch (*p ++) {
.   .   // [0,"a",'v',[0]]
.   .   case 'a':
.   .   .   if (*p ++ == 'v' &&
.   .   .   .   *p == 0)
.   .   .   .   return "yav";
.   .   .   return error;
.   .   // [0,"",'o',[1,'_']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "yo";
.   .   .   // [0,"_B",'J',[0]]
.   .   .   if (equal(p, "_BJ"))
.   .   .   .   return "yo_BJ";
.   .   }
.   .   return error;
.   // [0,"",'z',[3,'u']]
.   case 'z':
.   .   switch (*p ++) {
.   .   // [0,"g",'h',[0]]
.   .   case 'g':
.   .   .   if (*p ++ == 'h' &&
.   .   .   .   *p == 0)
.   .   .   .   return "zgh";
.   .   .   return error;
.   .   // [0,"",'h',[1,'_']]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "zh";
.   .   .   // [0,"_Han",'t',[0]]
.   .   .   if (equal(p, "_Hant"))
.   .   .   .   return "zh_Hant";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "zu";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-filenames-array ]--------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --path=function --trie=array < filenames.txt
.   // [1,'c']
.   // [0,"c++py-tree-demo",'/',[3,'c']]
.   if (prefix("c++py-tree-demo/", p)) {
.   .   p += 16;
.   .   switch (*p ++) {
.   .   // [15,"c++py-tree-demo.src",'-',[2,'f']]
.   .   case '.':
.   .   .   if (prefix("src-", p)) {
.   .   .   .   p += 4;
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-demo.srcdir",'s',[0]]
.   .   .   .   case 'd':
.   .   .   .   .   if (equal(p, "irs"))
.   .   .   .   .   .   return "c++py-tree-demo/.src-dirs";
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-demo.srcfile",'s',[0]]
.   .   .   .   case 'f':
.   .   .   .   .   if (equal(p, "iles"))
.   .   .   .   .   .   return "c++py-tree-demo/.src-files";
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [15,"c++py-tree-demobin.patc",'h',[0]]
.   .   case 'b':
.   .   .   if (equal(p, "in.patch"))
.   .   .   .   return "c++py-tree-demo/bin.patch";
.   .   .   return error;
.   .   // [15,"c++py-tree-democ++p",'y',[2,'/']]
.   .   case 'c':
.   .   .   if (prefix("++py", p)) {
.   .   .   .   p += 4;
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-democ++p-tre",'e',[2,'.']]
.   .   .   .   case '-':
.   .   .   .   .   if (prefix("tree", p)) {
.   .   .   .   .   .   p += 4;
.   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'-',[3,'r']]
.   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-treauthor.tx",'t',[0]]
.   .   .   .   .   .   .   case 'a':
.   .   .   .   .   .   .   .   if (equal(p, "uthor.txt"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-author.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tredemo.tx",'t',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (equal(p, "emo.txt"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-demo.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trereadme",'.',[2,'t']]
.   .   .   .   .   .   .   case 'r':
.   .   .   .   .   .   .   .   if (prefix("eadme.", p)) {
.   .   .   .   .   .   .   .   .   p += 6;
.   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmepd",'f',[0]]
.   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   if (equal(p, "df"))
.   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.pdf";
.   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadme",'t',[2,'x']]
.   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmee",'x',[0]]
.   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.tex";
.   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmex",'t',[0]]
.   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.txt";
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   return error;
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'.',[2,'t']]
.   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trepd",'f',[0]]
.   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   if (equal(p, "df"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.pdf";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'t',[2,'x']]
.   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tree",'x',[0]]
.   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   if (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.tex";
.   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trex",'t',[0]]
.   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.txt";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-democ++p",'/',[4,'R']]
.   .   .   .   case '/':
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [19,"c++py-tree-democ++p.src",'-',[2,'f']]
.   .   .   .   .   case '.':
.   .   .   .   .   .   if (prefix("src-", p)) {
.   .   .   .   .   .   .   p += 4;
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcdir",'s',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (equal(p, "irs"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-dirs";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcfile",'s',[0]]
.   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   if (equal(p, "iles"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-files";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pAUTHO",'R',[0]]
.   .   .   .   .   case 'A':
.   .   .   .   .   .   if (equal(p, "UTHOR"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/AUTHOR";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pMakefil",'e',[0]]
.   .   .   .   .   case 'M':
.   .   .   .   .   .   if (equal(p, "akefile"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/Makefile";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pREADM",'E',[0]]
.   .   .   .   .   case 'R':
.   .   .   .   .   .   if (equal(p, "EADME"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/README";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-filenames-ternary ]------------------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --path=function --trie=ternary < filenames.txt
.   // [1,'c']
.   // [0,"c++py-tree-demo",'/',[3,'c']]
.   if (prefix("c++py-tree-demo/", p)) {
.   .   p += 16;
.   .   switch (*p ++) {
.   .   // [15,"c++py-tree-demo.src",'-',[2,'f']]
.   .   case '.':
.   .   .   if (prefix("src-", p)) {
.   .   .   .   p += 4;
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-demo.srcdir",'s',[0]]
.   .   .   .   case 'd':
.   .   .   .   .   if (equal(p, "irs"))
.   .   .   .   .   .   return "c++py-tree-demo/.src-dirs";
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-demo.srcfile",'s',[0]]
.   .   .   .   case 'f':
.   .   .   .   .   if (equal(p, "iles"))
.   .   .   .   .   .   return "c++py-tree-demo/.src-files";
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [15,"c++py-tree-demobin.patc",'h',[0]]
.   .   case 'b':
.   .   .   if (equal(p, "in.patch"))
.   .   .   .   return "c++py-tree-demo/bin.patch";
.   .   .   return error;
.   .   // [15,"c++py-tree-democ++p",'y',[2,'/']]
.   .   case 'c':
.   .   .   if (prefix("++py", p)) {
.   .   .   .   p += 4;
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-democ++p-tre",'e',[2,'.']]
.   .   .   .   case '-':
.   .   .   .   .   if (prefix("tree", p)) {
.   .   .   .   .   .   p += 4;
.   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'-',[3,'r']]
.   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-treauthor.tx",'t',[0]]
.   .   .   .   .   .   .   case 'a':
.   .   .   .   .   .   .   .   if (equal(p, "uthor.txt"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-author.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tredemo.tx",'t',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (equal(p, "emo.txt"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-demo.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trereadme",'.',[2,'t']]
.   .   .   .   .   .   .   case 'r':
.   .   .   .   .   .   .   .   if (prefix("eadme.", p)) {
.   .   .   .   .   .   .   .   .   p += 6;
.   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmepd",'f',[0]]
.   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   if (equal(p, "df"))
.   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.pdf";
.   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadme",'t',[2,'x']]
.   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmee",'x',[0]]
.   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.tex";
.   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmex",'t',[0]]
.   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.txt";
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   return error;
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'.',[2,'t']]
.   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trepd",'f',[0]]
.   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   if (equal(p, "df"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.pdf";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'t',[2,'x']]
.   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tree",'x',[0]]
.   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   if (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.tex";
.   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trex",'t',[0]]
.   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   if (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   *p == 0)
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.txt";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-democ++p",'/',[4,'R']]
.   .   .   .   case '/':
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [19,"c++py-tree-democ++p.src",'-',[2,'f']]
.   .   .   .   .   case '.':
.   .   .   .   .   .   if (prefix("src-", p)) {
.   .   .   .   .   .   .   p += 4;
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcdir",'s',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (equal(p, "irs"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-dirs";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcfile",'s',[0]]
.   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   if (equal(p, "iles"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-files";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pAUTHO",'R',[0]]
.   .   .   .   .   case 'A':
.   .   .   .   .   .   if (equal(p, "UTHOR"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/AUTHOR";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pMakefil",'e',[0]]
.   .   .   .   .   case 'M':
.   .   .   .   .   .   if (equal(p, "akefile"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/Makefile";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pREADM",'E',[0]]
.   .   .   .   .   case 'R':
.   .   .   .   .   .   if (equal(p, "EADME"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/README";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-unique-prefix-base0-array ]----------------

$ trie() { ../src/trie --gen=compact --output=c-code --path=function --unique-prefix --trie=array "$@"; }
$ print a|trie
    if ((*p == 0 || (*p ++ == 'a' &&
        (*p == 0))))
        return "a";
    return error;
$ print a ab|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
    }
    return error;
$ print a ab abc|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            if ((*p == 0 || (*p ++ == 'c' &&
                (*p == 0))))
                return "abc";
        }
    }
    return error;
$ print a b|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        if (*p == 0)
            return "b";
    }
    return error;
$ print a b abc bac abd|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
            }
        }
        return error;
    case 'b':
        if (*p == 0)
            return "b";
        if (prefix(p, "ac"))
            return "bac";
    }
    return error;
$ print a bb ba c|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print a bb ba cc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))
            return "cc";
    }
    return error;
$ print a bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print a bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "de"))
            return "cde";
    }
    return error;
$ print a bb ba cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "def"))
            return "cdef";
    }
    return error;
$ print a bb ba cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix("def", p)) {
            p += 3;
            if (*p == 0)
                return "cdef";
            if ((*p == 0 || (*p ++ == 'g' &&
                (*p == 0))))
                return "cdefg";
        }
    }
    return error;
$ print a bb bac cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 'c' &&
                (*p == 0))))
                return "bac";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "def"))
            return "cdef";
    }
    return error;
$ print a bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print a bbx bay ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 'y' &&
                (*p == 0))))
                return "bay";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print a cde cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "cdef";
        }
    }
    return error;
$ print a cde cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if ((*p == 0 || (*p ++ == 'g' &&
                    (*p == 0))))
                    return "cdefg";
            }
        }
    }
    return error;
$ print a cde cdef cdefgh|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if (prefix(p, "gh"))
                    return "cdefgh";
            }
        }
    }
    return error;
$ print a cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("def", p)) {
            p += 3;
            if (*p == 0)
                return "cdef";
            if ((*p == 0 || (*p ++ == 'g' &&
                (*p == 0))))
                return "cdefg";
        }
    }
    return error;
$ print ab|trie
    if (prefix(p, "ab"))
        return "ab";
    return error;
$ print ab bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print ab bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "de"))
            return "cde";
    }
    return error;
$ print ab bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print ab c|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print abc bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (prefix(p, "bc"))
            return "abc";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print abcd abde abef|trie
    if (prefix("ab", p)) {
        p += 2;
        switch (*p ++) {
        case 'c':
            if ((*p == 0 || (*p ++ == 'd' &&
                (*p == 0))))
                return "abcd";
            return error;
        case 'd':
            if ((*p == 0 || (*p ++ == 'e' &&
                (*p == 0))))
                return "abde";
            return error;
        case 'e':
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "abef";
        }
    }
    return error;
$ print abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
        }
    }
    return error;
$ print ac ab|trie
    if (*p ++ == 'a') {
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            return error;
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print aef ae abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ae";
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "aef";
        }
    }
    return error;
$ print cde cdef cdefgh|trie
    if (prefix("cde", p)) {
        p += 3;
        if (*p == 0)
            return "cde";
        if (*p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if (prefix(p, "gh"))
                return "cdefgh";
        }
    }
    return error;
$ print cdef cdefg|trie
    if (prefix("cdef", p)) {
        p += 4;
        if (*p == 0)
            return "cdef";
        if ((*p == 0 || (*p ++ == 'g' &&
            (*p == 0))))
            return "cdefg";
    }
    return error;
$ print cdex cdfy cdgz cdhw|trie
    if (prefix("cd", p)) {
        p += 2;
        switch (*p ++) {
        case 'e':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "cdex";
            return error;
        case 'f':
            if ((*p == 0 || (*p ++ == 'y' &&
                (*p == 0))))
                return "cdfy";
            return error;
        case 'g':
            if ((*p == 0 || (*p ++ == 'z' &&
                (*p == 0))))
                return "cdgz";
            return error;
        case 'h':
            if ((*p == 0 || (*p ++ == 'w' &&
                (*p == 0))))
                return "cdhw";
        }
    }
    return error;
$ print ce cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        switch (*p ++) {
        case 'd':
            switch (*p ++) {
            case 'e':
                if ((*p == 0 || (*p ++ == 'x' &&
                    (*p == 0))))
                    return "cdex";
                return error;
            case 'f':
                if ((*p == 0 || (*p ++ == 'y' &&
                    (*p == 0))))
                    return "cdfy";
                return error;
            case 'g':
                if ((*p == 0 || (*p ++ == 'z' &&
                    (*p == 0))))
                    return "cdgz";
                return error;
            case 'h':
                if ((*p == 0 || (*p ++ == 'w' &&
                    (*p == 0))))
                    return "cdhw";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ce";
        }
    }
    return error;
$ print pot potato pottery tattoo tempo|trie
    switch (*p ++) {
    case 'p':
        if (prefix("ot", p)) {
            p += 2;
            if (*p == 0)
                return "pot";
            switch (*p ++) {
            case 'a':
                if (prefix(p, "to"))
                    return "potato";
                return error;
            case 't':
                if (prefix(p, "ery"))
                    return "pottery";
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (prefix(p, "ttoo"))
                return "tattoo";
            return error;
        case 'e':
            if (prefix(p, "mpo"))
                return "tempo";
        }
    }
    return error;
$

--[ gen-compact-c-code-path-function-unique-prefix-base0-ternary ]--------------

$ trie() { ../src/trie --gen=compact --output=c-code --path=function --unique-prefix --trie=ternary "$@"; }
$ print a|trie
    if ((*p == 0 || (*p ++ == 'a' &&
        (*p == 0))))
        return "a";
    return error;
$ print a ab|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
    }
    return error;
$ print a ab abc|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            if ((*p == 0 || (*p ++ == 'c' &&
                (*p == 0))))
                return "abc";
        }
    }
    return error;
$ print a b|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        if (*p == 0)
            return "b";
    }
    return error;
$ print a b abc bac abd|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
            }
        }
        return error;
    case 'b':
        if (*p == 0)
            return "b";
        if (prefix(p, "ac"))
            return "bac";
    }
    return error;
$ print a bb ba c|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print a bb ba cc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if ((*p == 0 || (*p ++ == 'c' &&
            (*p == 0))))
            return "cc";
    }
    return error;
$ print a bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print a bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "de"))
            return "cde";
    }
    return error;
$ print a bb ba cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "def"))
            return "cdef";
    }
    return error;
$ print a bb ba cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix("def", p)) {
            p += 3;
            if (*p == 0)
                return "cdef";
            if ((*p == 0 || (*p ++ == 'g' &&
                (*p == 0))))
                return "cdefg";
        }
    }
    return error;
$ print a bb bac cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 'c' &&
                (*p == 0))))
                return "bac";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "def"))
            return "cdef";
    }
    return error;
$ print a bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print a bbx bay ccc|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 'y' &&
                (*p == 0))))
                return "bay";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print a cde cdef|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "cdef";
        }
    }
    return error;
$ print a cde cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if ((*p == 0 || (*p ++ == 'g' &&
                    (*p == 0))))
                    return "cdefg";
            }
        }
    }
    return error;
$ print a cde cdef cdefgh|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("de", p)) {
            p += 2;
            if (*p == 0)
                return "cde";
            if (*p ++ == 'f') {
                if (*p == 0)
                    return "cdef";
                if (prefix(p, "gh"))
                    return "cdefgh";
            }
        }
    }
    return error;
$ print a cdef cdefg|trie
    switch (*p ++) {
    case 'a':
        if (*p == 0)
            return "a";
        return error;
    case 'c':
        if (prefix("def", p)) {
            p += 3;
            if (*p == 0)
                return "cdef";
            if ((*p == 0 || (*p ++ == 'g' &&
                (*p == 0))))
                return "cdefg";
        }
    }
    return error;
$ print ab|trie
    if (prefix(p, "ab"))
        return "ab";
    return error;
$ print ab bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print ab bb ba cde|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "de"))
            return "cde";
    }
    return error;
$ print ab bbx ba ccc|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "bbx";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print ab c|trie
    switch (*p ++) {
    case 'a':
        if ((*p == 0 || (*p ++ == 'b' &&
            (*p == 0))))
            return "ab";
        return error;
    case 'c':
        if (*p == 0)
            return "c";
    }
    return error;
$ print abc bb ba ccc|trie
    switch (*p ++) {
    case 'a':
        if (prefix(p, "bc"))
            return "abc";
        return error;
    case 'b':
        switch (*p ++) {
        case 'a':
            if (*p == 0)
                return "ba";
            return error;
        case 'b':
            if (*p == 0)
                return "bb";
        }
        return error;
    case 'c':
        if (prefix(p, "cc"))
            return "ccc";
    }
    return error;
$ print abcd abde abef|trie
    if (prefix("ab", p)) {
        p += 2;
        switch (*p ++) {
        case 'c':
            if ((*p == 0 || (*p ++ == 'd' &&
                (*p == 0))))
                return "abcd";
            return error;
        case 'd':
            if ((*p == 0 || (*p ++ == 'e' &&
                (*p == 0))))
                return "abde";
            return error;
        case 'e':
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "abef";
        }
    }
    return error;
$ print abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        if (*p ++ == 'b') {
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
        }
    }
    return error;
$ print ac ab|trie
    if (*p ++ == 'a') {
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            return error;
        case 'c':
            if (*p == 0)
                return "ac";
        }
    }
    return error;
$ print aef ae abg a abc ab abd|trie
    if (*p ++ == 'a') {
        if (*p == 0)
            return "a";
        switch (*p ++) {
        case 'b':
            if (*p == 0)
                return "ab";
            switch (*p ++) {
            case 'c':
                if (*p == 0)
                    return "abc";
                return error;
            case 'd':
                if (*p == 0)
                    return "abd";
                return error;
            case 'g':
                if (*p == 0)
                    return "abg";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ae";
            if ((*p == 0 || (*p ++ == 'f' &&
                (*p == 0))))
                return "aef";
        }
    }
    return error;
$ print cde cdef cdefgh|trie
    if (prefix("cde", p)) {
        p += 3;
        if (*p == 0)
            return "cde";
        if (*p ++ == 'f') {
            if (*p == 0)
                return "cdef";
            if (prefix(p, "gh"))
                return "cdefgh";
        }
    }
    return error;
$ print cdef cdefg|trie
    if (prefix("cdef", p)) {
        p += 4;
        if (*p == 0)
            return "cdef";
        if ((*p == 0 || (*p ++ == 'g' &&
            (*p == 0))))
            return "cdefg";
    }
    return error;
$ print cdex cdfy cdgz cdhw|trie
    if (prefix("cd", p)) {
        p += 2;
        switch (*p ++) {
        case 'e':
            if ((*p == 0 || (*p ++ == 'x' &&
                (*p == 0))))
                return "cdex";
            return error;
        case 'f':
            if ((*p == 0 || (*p ++ == 'y' &&
                (*p == 0))))
                return "cdfy";
            return error;
        case 'g':
            if ((*p == 0 || (*p ++ == 'z' &&
                (*p == 0))))
                return "cdgz";
            return error;
        case 'h':
            if ((*p == 0 || (*p ++ == 'w' &&
                (*p == 0))))
                return "cdhw";
        }
    }
    return error;
$ print ce cdex cdfy cdgz cdhw|trie
    if (*p ++ == 'c') {
        switch (*p ++) {
        case 'd':
            switch (*p ++) {
            case 'e':
                if ((*p == 0 || (*p ++ == 'x' &&
                    (*p == 0))))
                    return "cdex";
                return error;
            case 'f':
                if ((*p == 0 || (*p ++ == 'y' &&
                    (*p == 0))))
                    return "cdfy";
                return error;
            case 'g':
                if ((*p == 0 || (*p ++ == 'z' &&
                    (*p == 0))))
                    return "cdgz";
                return error;
            case 'h':
                if ((*p == 0 || (*p ++ == 'w' &&
                    (*p == 0))))
                    return "cdhw";
            }
            return error;
        case 'e':
            if (*p == 0)
                return "ce";
        }
    }
    return error;
$ print pot potato pottery tattoo tempo|trie
    switch (*p ++) {
    case 'p':
        if (prefix("ot", p)) {
            p += 2;
            if (*p == 0)
                return "pot";
            switch (*p ++) {
            case 'a':
                if (prefix(p, "to"))
                    return "potato";
                return error;
            case 't':
                if (prefix(p, "ery"))
                    return "pottery";
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (prefix(p, "ttoo"))
                return "tattoo";
            return error;
        case 'e':
            if (prefix(p, "mpo"))
                return "tempo";
        }
    }
    return error;
$

--[ gen-compact-c-code-path-function-unique-prefix-base-array ]-----------------

$ trie() { ../src/trie --gen=compact --output=c-code --path=function --unique-prefix --attrs --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
.   // [1,'a']
.   // [0,"",'a',[0]]
.   if ((*p == 0 || (*p ++ == 'a' &&
.   .   (*p == 0))))
.   .   return "a";
.   return error;
$ print a b|trie
.   // [2,'b']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   }
.   return error;
$ print a b c|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   .   return error;
.   // [0,"",'c',[0]]
.   case 'c':
.   .   if (*p == 0)
.   .   .   return "c";
.   }
.   return error;
$ print a ab abc|trie
.   // [1,'a']
.   // [0,"",'a',[1,'b']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"",'b',[1,'c']]
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   // [0,"",'c',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "abc";
.   .   }
.   }
.   return error;
$ print a ab ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac ad|trie
.   // [1,'a']
.   // [0,"",'a',[3,'d']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "ad";
.   .   }
.   }
.   return error;
$ print a abd ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"b",'d',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "abd";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac acd|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"",'d',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "acd";
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (prefix(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"b",'b',[0]]
.   case 'b':
.   .   if ((*p == 0 || (*p ++ == 'b' &&
.   .   .   (*p == 0))))
.   .   .   return "bb";
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (prefix(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (prefix(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print abc abd acde|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"cd",'e',[0]]
.   .   case 'c':
.   .   .   if (prefix(p, "de"))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"d",'e',[0]]
.   .   .   if (prefix(p, "de"))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde acfg|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[2,'f']]
.   .   case 'c':
.   .   .   switch (*p ++) {
.   .   .   // [0,"d",'e',[0]]
.   .   .   case 'd':
.   .   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   (*p == 0))))
.   .   .   .   .   return "acde";
.   .   .   .   return error;
.   .   .   // [0,"f",'g',[0]]
.   .   .   case 'f':
.   .   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   .   (*p == 0))))
.   .   .   .   .   return "acfg";
.   .   .   }
.   .   }
.   }
.   return error;
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'f']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cde";
.   .   .   return error;
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (prefix(p, "zz"))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'g']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (prefix(p, "zz"))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [0,"g",'e',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cge";
.   .   }
.   }
.   return error;
$ print a abcd abcdefg h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[1,'e']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   if (prefix(p, "efg"))
.   .   .   .   return "abcdefg";
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (prefix(p, "ijk"))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (prefix(p, "fg"))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (prefix(p, "yz"))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (prefix(p, "ijk"))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (prefix(p, "fg"))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (prefix(p, "yz"))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[2,'l']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   switch (*p ++) {
.   .   // [0,"ij",'k',[0]]
.   .   case 'i':
.   .   .   if (prefix(p, "jk"))
.   .   .   .   return "hijk";
.   .   .   return error;
.   .   // [0,"l",'m',[0]]
.   .   case 'l':
.   .   .   if ((*p == 0 || (*p ++ == 'm' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "hlm";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-unique-prefix-base-ternary ]---------------

$ trie() { ../src/trie --gen=compact --output=c-code --path=function --unique-prefix --attrs --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
.   // [1,'a']
.   // [0,"",'a',[0]]
.   if ((*p == 0 || (*p ++ == 'a' &&
.   .   (*p == 0))))
.   .   return "a";
.   return error;
$ print a b|trie
.   // [2,'b']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   }
.   return error;
$ print a b c|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[0]]
.   case 'b':
.   .   if (*p == 0)
.   .   .   return "b";
.   .   return error;
.   // [0,"",'c',[0]]
.   case 'c':
.   .   if (*p == 0)
.   .   .   return "c";
.   }
.   return error;
$ print a ab abc|trie
.   // [1,'a']
.   // [0,"",'a',[1,'b']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"",'b',[1,'c']]
.   .   if (*p ++ == 'b') {
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   // [0,"",'c',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "abc";
.   .   }
.   }
.   return error;
$ print a ab ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac ad|trie
.   // [1,'a']
.   // [0,"",'a',[3,'d']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "ad";
.   .   }
.   }
.   return error;
$ print a abd ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"b",'d',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "abd";
.   .   .   return error;
.   .   // [0,"",'c',[0]]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   }
.   }
.   return error;
$ print a ab ac acd|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   if (*p == 0)
.   .   .   return "a";
.   .   switch (*p ++) {
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "ab";
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"",'d',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'd' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "acd";
.   .   }
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (prefix(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"b",'b',[0]]
.   case 'b':
.   .   if ((*p == 0 || (*p ++ == 'b' &&
.   .   .   (*p == 0))))
.   .   .   return "bb";
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (prefix(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print a bb ba ccc|trie
.   // [3,'c']
.   switch (*p ++) {
.   // [0,"",'a',[0]]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   return error;
.   // [0,"",'b',[2,'b']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ba";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "bb";
.   .   }
.   .   return error;
.   // [0,"cc",'c',[0]]
.   case 'c':
.   .   if (prefix(p, "cc"))
.   .   .   return "ccc";
.   }
.   return error;
$ print abc abd acde|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"cd",'e',[0]]
.   .   case 'c':
.   .   .   if (prefix(p, "de"))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde ac|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[1,'d']]
.   .   case 'c':
.   .   .   if (*p == 0)
.   .   .   .   return "ac";
.   .   .   // [0,"d",'e',[0]]
.   .   .   if (prefix(p, "de"))
.   .   .   .   return "acde";
.   .   }
.   }
.   return error;
$ print abc abd acde acfg|trie
.   // [1,'a']
.   // [0,"",'a',[2,'c']]
.   if (*p ++ == 'a') {
.   .   switch (*p ++) {
.   .   // [0,"",'b',[2,'d']]
.   .   case 'b':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'c',[0]]
.   .   .   case 'c':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abc";
.   .   .   .   return error;
.   .   .   // [0,"",'d',[0]]
.   .   .   case 'd':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "abd";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'c',[2,'f']]
.   .   case 'c':
.   .   .   switch (*p ++) {
.   .   .   // [0,"d",'e',[0]]
.   .   .   case 'd':
.   .   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   .   (*p == 0))))
.   .   .   .   .   return "acde";
.   .   .   .   return error;
.   .   .   // [0,"f",'g',[0]]
.   .   .   case 'f':
.   .   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   .   (*p == 0))))
.   .   .   .   .   return "acfg";
.   .   .   }
.   .   }
.   }
.   return error;
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'f']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cde";
.   .   .   return error;
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (prefix(p, "zz"))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
.   // [1,'c']
.   // [0,"",'c',[2,'g']]
.   if (*p ++ == 'c') {
.   .   switch (*p ++) {
.   .   // [0,"f",'g',[1,'x']]
.   .   case 'f':
.   .   .   if (*p ++ == 'g') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "cfg";
.   .   .   .   // [1,"f",'x',[2,'z']]
.   .   .   .   if (*p ++ == 'x') {
.   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   return "cfgx";
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [1,"f",'y',[1,'z']]
.   .   .   .   .   case 'y':
.   .   .   .   .   .   if (*p == 0)
.   .   .   .   .   .   .   return "cfgxy";
.   .   .   .   .   .   // [1,"f",'z',[0]]
.   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   return "cfgxyz";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [1,"fzz",'z',[0]]
.   .   .   .   .   case 'z':
.   .   .   .   .   .   if (prefix(p, "zz"))
.   .   .   .   .   .   .   return "cfgxzzz";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [0,"g",'e',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cge";
.   .   }
.   }
.   return error;
$ print a abcd abcdefg h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[1,'e']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   if (prefix(p, "efg"))
.   .   .   .   return "abcdefg";
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (prefix(p, "ijk"))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (prefix(p, "fg"))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (prefix(p, "yz"))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[1,'i']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   // [0,"ij",'k',[0]]
.   .   if (prefix(p, "ijk"))
.   .   .   return "hijk";
.   }
.   return error;
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
.   // [2,'h']
.   switch (*p ++) {
.   // [0,"",'a',[1,'b']]
.   case 'a':
.   .   if (*p == 0)
.   .   .   return "a";
.   .   // [0,"bc",'d',[2,'x']]
.   .   if (prefix("bcd", p)) {
.   .   .   p += 3;
.   .   .   if (*p == 0)
.   .   .   .   return "abcd";
.   .   .   switch (*p ++) {
.   .   .   // [2,"bcef",'g',[0]]
.   .   .   case 'e':
.   .   .   .   if (prefix(p, "fg"))
.   .   .   .   .   return "abcdefg";
.   .   .   .   return error;
.   .   .   // [2,"bcxy",'z',[0]]
.   .   .   case 'x':
.   .   .   .   if (prefix(p, "yz"))
.   .   .   .   .   return "abcdxyz";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'h',[2,'l']]
.   case 'h':
.   .   if (*p == 0)
.   .   .   return "h";
.   .   switch (*p ++) {
.   .   // [0,"ij",'k',[0]]
.   .   case 'i':
.   .   .   if (prefix(p, "jk"))
.   .   .   .   return "hijk";
.   .   .   return error;
.   .   // [0,"l",'m',[0]]
.   .   case 'l':
.   .   .   if ((*p == 0 || (*p ++ == 'm' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "hlm";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-unique-prefix-alphabets-array ]------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --path=function --unique-prefix --trie=array < alphabets.txt
.   // [25,'z']
.   switch (*p ++) {
.   // [0,"",'a',[8,'z']]
.   case 'a':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "aa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "af";
.   .   .   return error;
.   .   // [0,"g",'q',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "agq";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "ak";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "am";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ar";
.   .   .   return error;
.   .   // [0,"",'s',[2,'t']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "as";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'a',[0]]
.   .   .   case 'a':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "asa";
.   .   .   .   return error;
.   .   .   // [0,"",'t',[0]]
.   .   .   case 't':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ast";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "az";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (prefix(p, "_Cyrl"))
.   .   .   .   return "az_Cyrl";
.   .   }
.   .   return error;
.   // [0,"",'b',[9,'y']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "bas";
.   .   .   return error;
.   .   // [0,"",'e',[2,'z']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "be";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bem";
.   .   .   .   return error;
.   .   .   // [0,"",'z',[0]]
.   .   .   case 'z':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bez";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "bg";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "bm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "bn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "bo";
.   .   .   return error;
.   .   // [0,"",'r',[1,'x']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "br";
.   .   .   // [0,"",'x',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "brx";
.   .   .   return error;
.   .   // [0,"",'s',[1,'_']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "bs";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (prefix(p, "_Cyrl"))
.   .   .   .   return "bs_Cyrl";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "byn";
.   .   }
.   .   return error;
.   // [0,"",'c',[5,'y']]
.   case 'c':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ca";
.   .   .   return error;
.   .   // [0,"g",'g',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cgg";
.   .   .   return error;
.   .   // [0,"h",'r',[0]]
.   .   case 'h':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "chr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "cs";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "cy";
.   .   }
.   .   return error;
.   // [0,"",'d',[6,'z']]
.   case 'd':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'v']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "da";
.   .   .   // [0,"",'v',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'v' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dav";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "de";
.   .   .   return error;
.   .   // [0,"j",'e',[0]]
.   .   case 'j':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dje";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dua";
.   .   .   return error;
.   .   // [0,"y",'o',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dyo";
.   .   .   return error;
.   .   // [0,"",'z',[0]]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "dz";
.   .   }
.   .   return error;
.   // [0,"",'e',[9,'w']]
.   case 'e':
.   .   switch (*p ++) {
.   .   // [0,"b",'u',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'u' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ebu";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ee";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "el";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "en";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "eo";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "es";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "et";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "eu";
.   .   .   return error;
.   .   // [0,"w",'o',[0]]
.   .   case 'w':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ewo";
.   .   }
.   .   return error;
.   // [0,"",'f',[7,'y']]
.   case 'f':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "fa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "ff";
.   .   .   return error;
.   .   // [0,"",'i',[1,'l']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "fi";
.   .   .   // [0,"",'l',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'l' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "fil";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "fo";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "fr";
.   .   .   return error;
.   .   // [0,"u",'r',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "fur";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "fy";
.   .   }
.   .   return error;
.   // [0,"",'g',[6,'v']]
.   case 'g':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ga";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "gd";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "gl";
.   .   .   return error;
.   .   // [0,"s",'w',[0]]
.   .   case 's':
.   .   .   if ((*p == 0 || (*p ++ == 'w' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "gsw";
.   .   .   return error;
.   .   // [0,"",'u',[1,'z']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "gu";
.   .   .   // [0,"",'z',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "guz";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "gv";
.   .   }
.   .   return error;
.   // [0,"",'h',[6,'y']]
.   case 'h':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'w']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ha";
.   .   .   // [0,"",'w',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'w' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "haw";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "he";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "hi";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "hr";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "hu";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "hy";
.   .   }
.   .   return error;
.   // [0,"",'i',[6,'t']]
.   case 'i':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ia";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "id";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ig";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ii";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "is";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "it";
.   .   }
.   .   return error;
.   // [0,"",'j',[3,'m']]
.   case 'j':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ja";
.   .   .   return error;
.   .   // [0,"g",'o',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "jgo";
.   .   .   return error;
.   .   // [0,"m",'c',[0]]
.   .   case 'm':
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "jmc";
.   .   }
.   .   return error;
.   // [0,"",'k',[13,'y']]
.   case 'k':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'m']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ka";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kab";
.   .   .   .   return error;
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kam";
.   .   .   }
.   .   .   return error;
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kde";
.   .   .   return error;
.   .   // [0,"e",'a',[0]]
.   .   case 'e':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kea";
.   .   .   return error;
.   .   // [0,"h",'q',[0]]
.   .   case 'h':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "khq";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ki";
.   .   .   return error;
.   .   // [0,"",'k',[1,'j']]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "kk";
.   .   .   // [0,"",'j',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'j' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kkj";
.   .   .   return error;
.   .   // [0,"",'l',[1,'n']]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "kl";
.   .   .   // [0,"",'n',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kln";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "km";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "kn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'k']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ko";
.   .   .   // [0,"",'k',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'k' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kok";
.   .   .   return error;
.   .   // [0,"",'s',[3,'h']]
.   .   case 's':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksb";
.   .   .   .   return error;
.   .   .   // [0,"",'f',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksf";
.   .   .   .   return error;
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksh";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'w',[0]]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "kw";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "ky";
.   .   }
.   .   return error;
.   // [0,"",'l',[8,'v']]
.   case 'l':
.   .   switch (*p ++) {
.   .   // [0,"a",'g',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "lag";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "lg";
.   .   .   return error;
.   .   // [0,"k",'t',[0]]
.   .   case 'k':
.   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "lkt";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "ln";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "lo";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "lt";
.   .   .   return error;
.   .   // [0,"",'u',[2,'y']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "lu";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luo";
.   .   .   .   return error;
.   .   .   // [0,"",'y',[0]]
.   .   .   case 'y':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luy";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "lv";
.   .   }
.   .   return error;
.   // [0,"",'m',[12,'y']]
.   case 'm':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mas";
.   .   .   return error;
.   .   // [0,"e",'r',[0]]
.   .   case 'e':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mer";
.   .   .   return error;
.   .   // [0,"f",'e',[0]]
.   .   case 'f':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mfe";
.   .   .   return error;
.   .   // [0,"",'g',[2,'o']]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "mg";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgh";
.   .   .   .   return error;
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgo";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "mk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "ml";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "mn";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "mr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ms";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "mt";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mua";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "my";
.   .   }
.   .   return error;
.   // [0,"",'n',[11,'y']]
.   case 'n':
.   .   switch (*p ++) {
.   .   // [0,"a",'q',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "naq";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "nb";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "nd";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ne";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "nl";
.   .   .   return error;
.   .   // [0,"m",'g',[0]]
.   .   case 'm':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nmg";
.   .   .   return error;
.   .   // [0,"",'n',[1,'h']]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "nn";
.   .   .   // [0,"",'h',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'h' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nnh";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "nr";
.   .   .   return error;
.   .   // [0,"s",'o',[0]]
.   .   case 's':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nso";
.   .   .   return error;
.   .   // [0,"u",'s',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nus";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nyn";
.   .   }
.   .   return error;
.   // [0,"",'o',[3,'s']]
.   case 'o':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "om";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "or";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "os";
.   .   }
.   .   return error;
.   // [0,"",'p',[4,'t']]
.   case 'p':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'_']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "pa";
.   .   .   // [0,"_Ara",'b',[0]]
.   .   .   if (prefix(p, "_Arab"))
.   .   .   .   return "pa_Arab";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "pl";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ps";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "pt";
.   .   }
.   .   return error;
.   // [0,"",'r',[5,'w']]
.   case 'r':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "rm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "rn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'f']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ro";
.   .   .   // [0,"",'f',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'f' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "rof";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "ru";
.   .   .   return error;
.   .   // [0,"",'w',[1,'k']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "rw";
.   .   .   // [0,"",'k',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'k' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "rwk";
.   .   }
.   .   return error;
.   // [0,"",'s',[16,'w']]
.   case 's':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'q']]
.   .   case 'a':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sah";
.   .   .   .   return error;
.   .   .   // [0,"",'q',[0]]
.   .   .   case 'q':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "saq";
.   .   .   }
.   .   .   return error;
.   .   // [0,"b",'p',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'p' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "sbp";
.   .   .   return error;
.   .   // [0,"",'e',[2,'s']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "se";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "seh";
.   .   .   .   return error;
.   .   .   // [0,"",'s',[0]]
.   .   .   case 's':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ses";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "sg";
.   .   .   return error;
.   .   // [0,"h",'i',[1,'_']]
.   .   case 'h':
.   .   .   if (*p ++ == 'i') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "shi";
.   .   .   .   // [1,"h_Lat",'n',[0]]
.   .   .   .   if (prefix(p, "_Latn"))
.   .   .   .   .   return "shi_Latn";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "si";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "sk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "sl";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "sn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "so";
.   .   .   return error;
.   .   // [0,"",'q',[0]]
.   .   case 'q':
.   .   .   if (*p == 0)
.   .   .   .   return "sq";
.   .   .   return error;
.   .   // [0,"",'r',[1,'_']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "sr";
.   .   .   // [0,"_Lat",'n',[0]]
.   .   .   if (prefix(p, "_Latn"))
.   .   .   .   return "sr_Latn";
.   .   .   return error;
.   .   // [0,"",'s',[1,'y']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ss";
.   .   .   // [0,"",'y',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'y' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ssy";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "st";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "sv";
.   .   .   return error;
.   .   // [0,"",'w',[1,'c']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "sw";
.   .   .   // [0,"",'c',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "swc";
.   .   }
.   .   return error;
.   // [0,"",'t',[11,'z']]
.   case 't':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ta";
.   .   .   return error;
.   .   // [0,"",'e',[1,'o']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "te";
.   .   .   // [0,"",'o',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "teo";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "tg";
.   .   .   return error;
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "th";
.   .   .   return error;
.   .   // [0,"",'i',[2,'g']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ti";
.   .   .   switch (*p ++) {
.   .   .   // [0,"_E",'R',[0]]
.   .   .   case '_':
.   .   .   .   if (prefix(p, "ER"))
.   .   .   .   .   return "ti_ER";
.   .   .   .   return error;
.   .   .   // [0,"",'g',[0]]
.   .   .   case 'g':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tig";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "tn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "to";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "tr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ts";
.   .   .   return error;
.   .   // [0,"w",'q',[0]]
.   .   case 'w':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "twq";
.   .   .   return error;
.   .   // [0,"z",'m',[0]]
.   .   case 'z':
.   .   .   if ((*p == 0 || (*p ++ == 'm' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "tzm";
.   .   }
.   .   return error;
.   // [0,"",'u',[4,'z']]
.   case 'u':
.   .   switch (*p ++) {
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ug";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "uk";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ur";
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "uz";
.   .   .   // [0,"",'_',[2,'C']]
.   .   .   if (*p ++ == '_') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [0,"Ara",'b',[0]]
.   .   .   .   case 'A':
.   .   .   .   .   if (prefix(p, "rab"))
.   .   .   .   .   .   return "uz_Arab";
.   .   .   .   .   return error;
.   .   .   .   // [0,"Cyr",'l',[0]]
.   .   .   .   case 'C':
.   .   .   .   .   if (prefix(p, "yrl"))
.   .   .   .   .   .   return "uz_Cyrl";
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'v',[5,'u']]
.   case 'v':
.   .   switch (*p ++) {
.   .   // [0,"ai_Lat",'n',[0]]
.   .   case 'a':
.   .   .   if (prefix(p, "i_Latn"))
.   .   .   .   return "vai_Latn";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ve";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "vi";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "vo";
.   .   .   return error;
.   .   // [0,"u",'n',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "vun";
.   .   }
.   .   return error;
.   // [0,"w",'a',[2,'l']]
.   case 'w':
.   .   if (*p ++ == 'a') {
.   .   .   switch (*p ++) {
.   .   .   // [1,"w",'e',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wae";
.   .   .   .   return error;
.   .   .   // [1,"w",'l',[0]]
.   .   .   case 'l':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wal";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'x',[2,'o']]
.   case 'x':
.   .   switch (*p ++) {
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "xh";
.   .   .   return error;
.   .   // [0,"o",'g',[0]]
.   .   case 'o':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "xog";
.   .   }
.   .   return error;
.   // [0,"",'y',[2,'o']]
.   case 'y':
.   .   switch (*p ++) {
.   .   // [0,"a",'v',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'v' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "yav";
.   .   .   return error;
.   .   // [0,"",'o',[1,'_']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "yo";
.   .   .   // [0,"_B",'J',[0]]
.   .   .   if (prefix(p, "_BJ"))
.   .   .   .   return "yo_BJ";
.   .   }
.   .   return error;
.   // [0,"",'z',[3,'u']]
.   case 'z':
.   .   switch (*p ++) {
.   .   // [0,"g",'h',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'h' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "zgh";
.   .   .   return error;
.   .   // [0,"",'h',[1,'_']]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "zh";
.   .   .   // [0,"_Han",'t',[0]]
.   .   .   if (prefix(p, "_Hant"))
.   .   .   .   return "zh_Hant";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "zu";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-unique-prefix-alphabets-ternary ]----------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --path=function --unique-prefix --trie=ternary < alphabets.txt
.   // [25,'z']
.   switch (*p ++) {
.   // [0,"",'a',[8,'z']]
.   case 'a':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "aa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "af";
.   .   .   return error;
.   .   // [0,"g",'q',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "agq";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "ak";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "am";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ar";
.   .   .   return error;
.   .   // [0,"",'s',[2,'t']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "as";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'a',[0]]
.   .   .   case 'a':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "asa";
.   .   .   .   return error;
.   .   .   // [0,"",'t',[0]]
.   .   .   case 't':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ast";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "az";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (prefix(p, "_Cyrl"))
.   .   .   .   return "az_Cyrl";
.   .   }
.   .   return error;
.   // [0,"",'b',[9,'y']]
.   case 'b':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "bas";
.   .   .   return error;
.   .   // [0,"",'e',[2,'z']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "be";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bem";
.   .   .   .   return error;
.   .   .   // [0,"",'z',[0]]
.   .   .   case 'z':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "bez";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "bg";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "bm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "bn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "bo";
.   .   .   return error;
.   .   // [0,"",'r',[1,'x']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "br";
.   .   .   // [0,"",'x',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "brx";
.   .   .   return error;
.   .   // [0,"",'s',[1,'_']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "bs";
.   .   .   // [0,"_Cyr",'l',[0]]
.   .   .   if (prefix(p, "_Cyrl"))
.   .   .   .   return "bs_Cyrl";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "byn";
.   .   }
.   .   return error;
.   // [0,"",'c',[5,'y']]
.   case 'c':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ca";
.   .   .   return error;
.   .   // [0,"g",'g',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "cgg";
.   .   .   return error;
.   .   // [0,"h",'r',[0]]
.   .   case 'h':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "chr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "cs";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "cy";
.   .   }
.   .   return error;
.   // [0,"",'d',[6,'z']]
.   case 'd':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'v']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "da";
.   .   .   // [0,"",'v',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'v' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dav";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "de";
.   .   .   return error;
.   .   // [0,"j",'e',[0]]
.   .   case 'j':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dje";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dua";
.   .   .   return error;
.   .   // [0,"y",'o',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "dyo";
.   .   .   return error;
.   .   // [0,"",'z',[0]]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "dz";
.   .   }
.   .   return error;
.   // [0,"",'e',[9,'w']]
.   case 'e':
.   .   switch (*p ++) {
.   .   // [0,"b",'u',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'u' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ebu";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ee";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "el";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "en";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "eo";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "es";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "et";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "eu";
.   .   .   return error;
.   .   // [0,"w",'o',[0]]
.   .   case 'w':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ewo";
.   .   }
.   .   return error;
.   // [0,"",'f',[7,'y']]
.   case 'f':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "fa";
.   .   .   return error;
.   .   // [0,"",'f',[0]]
.   .   case 'f':
.   .   .   if (*p == 0)
.   .   .   .   return "ff";
.   .   .   return error;
.   .   // [0,"",'i',[1,'l']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "fi";
.   .   .   // [0,"",'l',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'l' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "fil";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "fo";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "fr";
.   .   .   return error;
.   .   // [0,"u",'r',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "fur";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "fy";
.   .   }
.   .   return error;
.   // [0,"",'g',[6,'v']]
.   case 'g':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ga";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "gd";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "gl";
.   .   .   return error;
.   .   // [0,"s",'w',[0]]
.   .   case 's':
.   .   .   if ((*p == 0 || (*p ++ == 'w' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "gsw";
.   .   .   return error;
.   .   // [0,"",'u',[1,'z']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "gu";
.   .   .   // [0,"",'z',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'z' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "guz";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "gv";
.   .   }
.   .   return error;
.   // [0,"",'h',[6,'y']]
.   case 'h':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'w']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ha";
.   .   .   // [0,"",'w',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'w' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "haw";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "he";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "hi";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "hr";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "hu";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "hy";
.   .   }
.   .   return error;
.   // [0,"",'i',[6,'t']]
.   case 'i':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ia";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "id";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ig";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ii";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "is";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "it";
.   .   }
.   .   return error;
.   // [0,"",'j',[3,'m']]
.   case 'j':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ja";
.   .   .   return error;
.   .   // [0,"g",'o',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "jgo";
.   .   .   return error;
.   .   // [0,"m",'c',[0]]
.   .   case 'm':
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "jmc";
.   .   }
.   .   return error;
.   // [0,"",'k',[13,'y']]
.   case 'k':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'m']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ka";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kab";
.   .   .   .   return error;
.   .   .   // [0,"",'m',[0]]
.   .   .   case 'm':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "kam";
.   .   .   }
.   .   .   return error;
.   .   // [0,"d",'e',[0]]
.   .   case 'd':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kde";
.   .   .   return error;
.   .   // [0,"e",'a',[0]]
.   .   case 'e':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kea";
.   .   .   return error;
.   .   // [0,"h",'q',[0]]
.   .   case 'h':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "khq";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ki";
.   .   .   return error;
.   .   // [0,"",'k',[1,'j']]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "kk";
.   .   .   // [0,"",'j',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'j' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kkj";
.   .   .   return error;
.   .   // [0,"",'l',[1,'n']]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "kl";
.   .   .   // [0,"",'n',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kln";
.   .   .   return error;
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "km";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "kn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'k']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ko";
.   .   .   // [0,"",'k',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'k' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "kok";
.   .   .   return error;
.   .   // [0,"",'s',[3,'h']]
.   .   case 's':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'b',[0]]
.   .   .   case 'b':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksb";
.   .   .   .   return error;
.   .   .   // [0,"",'f',[0]]
.   .   .   case 'f':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksf";
.   .   .   .   return error;
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ksh";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'w',[0]]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "kw";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "ky";
.   .   }
.   .   return error;
.   // [0,"",'l',[8,'v']]
.   case 'l':
.   .   switch (*p ++) {
.   .   // [0,"a",'g',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "lag";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "lg";
.   .   .   return error;
.   .   // [0,"k",'t',[0]]
.   .   case 'k':
.   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "lkt";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "ln";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "lo";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "lt";
.   .   .   return error;
.   .   // [0,"",'u',[2,'y']]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "lu";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luo";
.   .   .   .   return error;
.   .   .   // [0,"",'y',[0]]
.   .   .   case 'y':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "luy";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "lv";
.   .   }
.   .   return error;
.   // [0,"",'m',[12,'y']]
.   case 'm':
.   .   switch (*p ++) {
.   .   // [0,"a",'s',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mas";
.   .   .   return error;
.   .   // [0,"e",'r',[0]]
.   .   case 'e':
.   .   .   if ((*p == 0 || (*p ++ == 'r' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mer";
.   .   .   return error;
.   .   // [0,"f",'e',[0]]
.   .   case 'f':
.   .   .   if ((*p == 0 || (*p ++ == 'e' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mfe";
.   .   .   return error;
.   .   // [0,"",'g',[2,'o']]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "mg";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgh";
.   .   .   .   return error;
.   .   .   // [0,"",'o',[0]]
.   .   .   case 'o':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "mgo";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "mk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "ml";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "mn";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "mr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ms";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "mt";
.   .   .   return error;
.   .   // [0,"u",'a',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'a' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "mua";
.   .   .   return error;
.   .   // [0,"",'y',[0]]
.   .   case 'y':
.   .   .   if (*p == 0)
.   .   .   .   return "my";
.   .   }
.   .   return error;
.   // [0,"",'n',[11,'y']]
.   case 'n':
.   .   switch (*p ++) {
.   .   // [0,"a",'q',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "naq";
.   .   .   return error;
.   .   // [0,"",'b',[0]]
.   .   case 'b':
.   .   .   if (*p == 0)
.   .   .   .   return "nb";
.   .   .   return error;
.   .   // [0,"",'d',[0]]
.   .   case 'd':
.   .   .   if (*p == 0)
.   .   .   .   return "nd";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ne";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "nl";
.   .   .   return error;
.   .   // [0,"m",'g',[0]]
.   .   case 'm':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nmg";
.   .   .   return error;
.   .   // [0,"",'n',[1,'h']]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "nn";
.   .   .   // [0,"",'h',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'h' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nnh";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "nr";
.   .   .   return error;
.   .   // [0,"s",'o',[0]]
.   .   case 's':
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nso";
.   .   .   return error;
.   .   // [0,"u",'s',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 's' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nus";
.   .   .   return error;
.   .   // [0,"y",'n',[0]]
.   .   case 'y':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "nyn";
.   .   }
.   .   return error;
.   // [0,"",'o',[3,'s']]
.   case 'o':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "om";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "or";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "os";
.   .   }
.   .   return error;
.   // [0,"",'p',[4,'t']]
.   case 'p':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[1,'_']]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "pa";
.   .   .   // [0,"_Ara",'b',[0]]
.   .   .   if (prefix(p, "_Arab"))
.   .   .   .   return "pa_Arab";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "pl";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ps";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "pt";
.   .   }
.   .   return error;
.   // [0,"",'r',[5,'w']]
.   case 'r':
.   .   switch (*p ++) {
.   .   // [0,"",'m',[0]]
.   .   case 'm':
.   .   .   if (*p == 0)
.   .   .   .   return "rm";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "rn";
.   .   .   return error;
.   .   // [0,"",'o',[1,'f']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "ro";
.   .   .   // [0,"",'f',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'f' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "rof";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "ru";
.   .   .   return error;
.   .   // [0,"",'w',[1,'k']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "rw";
.   .   .   // [0,"",'k',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'k' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "rwk";
.   .   }
.   .   return error;
.   // [0,"",'s',[16,'w']]
.   case 's':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[2,'q']]
.   .   case 'a':
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "sah";
.   .   .   .   return error;
.   .   .   // [0,"",'q',[0]]
.   .   .   case 'q':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "saq";
.   .   .   }
.   .   .   return error;
.   .   // [0,"b",'p',[0]]
.   .   case 'b':
.   .   .   if ((*p == 0 || (*p ++ == 'p' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "sbp";
.   .   .   return error;
.   .   // [0,"",'e',[2,'s']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "se";
.   .   .   switch (*p ++) {
.   .   .   // [0,"",'h',[0]]
.   .   .   case 'h':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "seh";
.   .   .   .   return error;
.   .   .   // [0,"",'s',[0]]
.   .   .   case 's':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "ses";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "sg";
.   .   .   return error;
.   .   // [0,"h",'i',[1,'_']]
.   .   case 'h':
.   .   .   if (*p ++ == 'i') {
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "shi";
.   .   .   .   // [1,"h_Lat",'n',[0]]
.   .   .   .   if (prefix(p, "_Latn"))
.   .   .   .   .   return "shi_Latn";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "si";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "sk";
.   .   .   return error;
.   .   // [0,"",'l',[0]]
.   .   case 'l':
.   .   .   if (*p == 0)
.   .   .   .   return "sl";
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "sn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "so";
.   .   .   return error;
.   .   // [0,"",'q',[0]]
.   .   case 'q':
.   .   .   if (*p == 0)
.   .   .   .   return "sq";
.   .   .   return error;
.   .   // [0,"",'r',[1,'_']]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "sr";
.   .   .   // [0,"_Lat",'n',[0]]
.   .   .   if (prefix(p, "_Latn"))
.   .   .   .   return "sr_Latn";
.   .   .   return error;
.   .   // [0,"",'s',[1,'y']]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ss";
.   .   .   // [0,"",'y',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'y' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "ssy";
.   .   .   return error;
.   .   // [0,"",'t',[0]]
.   .   case 't':
.   .   .   if (*p == 0)
.   .   .   .   return "st";
.   .   .   return error;
.   .   // [0,"",'v',[0]]
.   .   case 'v':
.   .   .   if (*p == 0)
.   .   .   .   return "sv";
.   .   .   return error;
.   .   // [0,"",'w',[1,'c']]
.   .   case 'w':
.   .   .   if (*p == 0)
.   .   .   .   return "sw";
.   .   .   // [0,"",'c',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'c' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "swc";
.   .   }
.   .   return error;
.   // [0,"",'t',[11,'z']]
.   case 't':
.   .   switch (*p ++) {
.   .   // [0,"",'a',[0]]
.   .   case 'a':
.   .   .   if (*p == 0)
.   .   .   .   return "ta";
.   .   .   return error;
.   .   // [0,"",'e',[1,'o']]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "te";
.   .   .   // [0,"",'o',[0]]
.   .   .   if ((*p == 0 || (*p ++ == 'o' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "teo";
.   .   .   return error;
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "tg";
.   .   .   return error;
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "th";
.   .   .   return error;
.   .   // [0,"",'i',[2,'g']]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "ti";
.   .   .   switch (*p ++) {
.   .   .   // [0,"_E",'R',[0]]
.   .   .   case '_':
.   .   .   .   if (prefix(p, "ER"))
.   .   .   .   .   return "ti_ER";
.   .   .   .   return error;
.   .   .   // [0,"",'g',[0]]
.   .   .   case 'g':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "tig";
.   .   .   }
.   .   .   return error;
.   .   // [0,"",'n',[0]]
.   .   case 'n':
.   .   .   if (*p == 0)
.   .   .   .   return "tn";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "to";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "tr";
.   .   .   return error;
.   .   // [0,"",'s',[0]]
.   .   case 's':
.   .   .   if (*p == 0)
.   .   .   .   return "ts";
.   .   .   return error;
.   .   // [0,"w",'q',[0]]
.   .   case 'w':
.   .   .   if ((*p == 0 || (*p ++ == 'q' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "twq";
.   .   .   return error;
.   .   // [0,"z",'m',[0]]
.   .   case 'z':
.   .   .   if ((*p == 0 || (*p ++ == 'm' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "tzm";
.   .   }
.   .   return error;
.   // [0,"",'u',[4,'z']]
.   case 'u':
.   .   switch (*p ++) {
.   .   // [0,"",'g',[0]]
.   .   case 'g':
.   .   .   if (*p == 0)
.   .   .   .   return "ug";
.   .   .   return error;
.   .   // [0,"",'k',[0]]
.   .   case 'k':
.   .   .   if (*p == 0)
.   .   .   .   return "uk";
.   .   .   return error;
.   .   // [0,"",'r',[0]]
.   .   case 'r':
.   .   .   if (*p == 0)
.   .   .   .   return "ur";
.   .   .   return error;
.   .   // [0,"",'z',[1,'_']]
.   .   case 'z':
.   .   .   if (*p == 0)
.   .   .   .   return "uz";
.   .   .   // [0,"",'_',[2,'C']]
.   .   .   if (*p ++ == '_') {
.   .   .   .   switch (*p ++) {
.   .   .   .   // [0,"Ara",'b',[0]]
.   .   .   .   case 'A':
.   .   .   .   .   if (prefix(p, "rab"))
.   .   .   .   .   .   return "uz_Arab";
.   .   .   .   .   return error;
.   .   .   .   // [0,"Cyr",'l',[0]]
.   .   .   .   case 'C':
.   .   .   .   .   if (prefix(p, "yrl"))
.   .   .   .   .   .   return "uz_Cyrl";
.   .   .   .   }
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'v',[5,'u']]
.   case 'v':
.   .   switch (*p ++) {
.   .   // [0,"ai_Lat",'n',[0]]
.   .   case 'a':
.   .   .   if (prefix(p, "i_Latn"))
.   .   .   .   return "vai_Latn";
.   .   .   return error;
.   .   // [0,"",'e',[0]]
.   .   case 'e':
.   .   .   if (*p == 0)
.   .   .   .   return "ve";
.   .   .   return error;
.   .   // [0,"",'i',[0]]
.   .   case 'i':
.   .   .   if (*p == 0)
.   .   .   .   return "vi";
.   .   .   return error;
.   .   // [0,"",'o',[0]]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "vo";
.   .   .   return error;
.   .   // [0,"u",'n',[0]]
.   .   case 'u':
.   .   .   if ((*p == 0 || (*p ++ == 'n' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "vun";
.   .   }
.   .   return error;
.   // [0,"w",'a',[2,'l']]
.   case 'w':
.   .   if (*p ++ == 'a') {
.   .   .   switch (*p ++) {
.   .   .   // [1,"w",'e',[0]]
.   .   .   case 'e':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wae";
.   .   .   .   return error;
.   .   .   // [1,"w",'l',[0]]
.   .   .   case 'l':
.   .   .   .   if (*p == 0)
.   .   .   .   .   return "wal";
.   .   .   }
.   .   }
.   .   return error;
.   // [0,"",'x',[2,'o']]
.   case 'x':
.   .   switch (*p ++) {
.   .   // [0,"",'h',[0]]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "xh";
.   .   .   return error;
.   .   // [0,"o",'g',[0]]
.   .   case 'o':
.   .   .   if ((*p == 0 || (*p ++ == 'g' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "xog";
.   .   }
.   .   return error;
.   // [0,"",'y',[2,'o']]
.   case 'y':
.   .   switch (*p ++) {
.   .   // [0,"a",'v',[0]]
.   .   case 'a':
.   .   .   if ((*p == 0 || (*p ++ == 'v' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "yav";
.   .   .   return error;
.   .   // [0,"",'o',[1,'_']]
.   .   case 'o':
.   .   .   if (*p == 0)
.   .   .   .   return "yo";
.   .   .   // [0,"_B",'J',[0]]
.   .   .   if (prefix(p, "_BJ"))
.   .   .   .   return "yo_BJ";
.   .   }
.   .   return error;
.   // [0,"",'z',[3,'u']]
.   case 'z':
.   .   switch (*p ++) {
.   .   // [0,"g",'h',[0]]
.   .   case 'g':
.   .   .   if ((*p == 0 || (*p ++ == 'h' &&
.   .   .   .   (*p == 0))))
.   .   .   .   return "zgh";
.   .   .   return error;
.   .   // [0,"",'h',[1,'_']]
.   .   case 'h':
.   .   .   if (*p == 0)
.   .   .   .   return "zh";
.   .   .   // [0,"_Han",'t',[0]]
.   .   .   if (prefix(p, "_Hant"))
.   .   .   .   return "zh_Hant";
.   .   .   return error;
.   .   // [0,"",'u',[0]]
.   .   case 'u':
.   .   .   if (*p == 0)
.   .   .   .   return "zu";
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-unique-prefix-filenames-array ]------------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --path=function --unique-prefix --trie=array < filenames.txt
.   // [1,'c']
.   // [0,"c++py-tree-demo",'/',[3,'c']]
.   if (prefix("c++py-tree-demo/", p)) {
.   .   p += 16;
.   .   switch (*p ++) {
.   .   // [15,"c++py-tree-demo.src",'-',[2,'f']]
.   .   case '.':
.   .   .   if (prefix("src-", p)) {
.   .   .   .   p += 4;
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-demo.srcdir",'s',[0]]
.   .   .   .   case 'd':
.   .   .   .   .   if (prefix(p, "irs"))
.   .   .   .   .   .   return "c++py-tree-demo/.src-dirs";
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-demo.srcfile",'s',[0]]
.   .   .   .   case 'f':
.   .   .   .   .   if (prefix(p, "iles"))
.   .   .   .   .   .   return "c++py-tree-demo/.src-files";
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [15,"c++py-tree-demobin.patc",'h',[0]]
.   .   case 'b':
.   .   .   if (prefix(p, "in.patch"))
.   .   .   .   return "c++py-tree-demo/bin.patch";
.   .   .   return error;
.   .   // [15,"c++py-tree-democ++p",'y',[2,'/']]
.   .   case 'c':
.   .   .   if (prefix("++py", p)) {
.   .   .   .   p += 4;
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-democ++p-tre",'e',[2,'.']]
.   .   .   .   case '-':
.   .   .   .   .   if (prefix("tree", p)) {
.   .   .   .   .   .   p += 4;
.   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'-',[3,'r']]
.   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-treauthor.tx",'t',[0]]
.   .   .   .   .   .   .   case 'a':
.   .   .   .   .   .   .   .   if (prefix(p, "uthor.txt"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-author.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tredemo.tx",'t',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (prefix(p, "emo.txt"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-demo.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trereadme",'.',[2,'t']]
.   .   .   .   .   .   .   case 'r':
.   .   .   .   .   .   .   .   if (prefix("eadme.", p)) {
.   .   .   .   .   .   .   .   .   p += 6;
.   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmepd",'f',[0]]
.   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   if (prefix(p, "df"))
.   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.pdf";
.   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadme",'t',[2,'x']]
.   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmee",'x',[0]]
.   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.tex";
.   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmex",'t',[0]]
.   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.txt";
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   return error;
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'.',[2,'t']]
.   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trepd",'f',[0]]
.   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   if (prefix(p, "df"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.pdf";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'t',[2,'x']]
.   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tree",'x',[0]]
.   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.tex";
.   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trex",'t',[0]]
.   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.txt";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-democ++p",'/',[4,'R']]
.   .   .   .   case '/':
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [19,"c++py-tree-democ++p.src",'-',[2,'f']]
.   .   .   .   .   case '.':
.   .   .   .   .   .   if (prefix("src-", p)) {
.   .   .   .   .   .   .   p += 4;
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcdir",'s',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (prefix(p, "irs"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-dirs";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcfile",'s',[0]]
.   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   if (prefix(p, "iles"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-files";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pAUTHO",'R',[0]]
.   .   .   .   .   case 'A':
.   .   .   .   .   .   if (prefix(p, "UTHOR"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/AUTHOR";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pMakefil",'e',[0]]
.   .   .   .   .   case 'M':
.   .   .   .   .   .   if (prefix(p, "akefile"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/Makefile";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pREADM",'E',[0]]
.   .   .   .   .   case 'R':
.   .   .   .   .   .   if (prefix(p, "EADME"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/README";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-compact-c-code-path-function-unique-prefix-filenames-ternary ]----------

$ ../src/trie --attrs --dots --gen=compact --output=c-code --path=function --unique-prefix --trie=ternary < filenames.txt
.   // [1,'c']
.   // [0,"c++py-tree-demo",'/',[3,'c']]
.   if (prefix("c++py-tree-demo/", p)) {
.   .   p += 16;
.   .   switch (*p ++) {
.   .   // [15,"c++py-tree-demo.src",'-',[2,'f']]
.   .   case '.':
.   .   .   if (prefix("src-", p)) {
.   .   .   .   p += 4;
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-demo.srcdir",'s',[0]]
.   .   .   .   case 'd':
.   .   .   .   .   if (prefix(p, "irs"))
.   .   .   .   .   .   return "c++py-tree-demo/.src-dirs";
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-demo.srcfile",'s',[0]]
.   .   .   .   case 'f':
.   .   .   .   .   if (prefix(p, "iles"))
.   .   .   .   .   .   return "c++py-tree-demo/.src-files";
.   .   .   .   }
.   .   .   }
.   .   .   return error;
.   .   // [15,"c++py-tree-demobin.patc",'h',[0]]
.   .   case 'b':
.   .   .   if (prefix(p, "in.patch"))
.   .   .   .   return "c++py-tree-demo/bin.patch";
.   .   .   return error;
.   .   // [15,"c++py-tree-democ++p",'y',[2,'/']]
.   .   case 'c':
.   .   .   if (prefix("++py", p)) {
.   .   .   .   p += 4;
.   .   .   .   switch (*p ++) {
.   .   .   .   // [19,"c++py-tree-democ++p-tre",'e',[2,'.']]
.   .   .   .   case '-':
.   .   .   .   .   if (prefix("tree", p)) {
.   .   .   .   .   .   p += 4;
.   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'-',[3,'r']]
.   .   .   .   .   .   case '-':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-treauthor.tx",'t',[0]]
.   .   .   .   .   .   .   case 'a':
.   .   .   .   .   .   .   .   if (prefix(p, "uthor.txt"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-author.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tredemo.tx",'t',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (prefix(p, "emo.txt"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-demo.txt";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trereadme",'.',[2,'t']]
.   .   .   .   .   .   .   case 'r':
.   .   .   .   .   .   .   .   if (prefix("eadme.", p)) {
.   .   .   .   .   .   .   .   .   p += 6;
.   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmepd",'f',[0]]
.   .   .   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   .   .   if (prefix(p, "df"))
.   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.pdf";
.   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadme",'t',[2,'x']]
.   .   .   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmee",'x',[0]]
.   .   .   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.tex";
.   .   .   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   .   .   // [29,"c++py-tree-democ++p-trereadmex",'t',[0]]
.   .   .   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree-readme.txt";
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   .   return error;
.   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'.',[2,'t']]
.   .   .   .   .   .   case '.':
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trepd",'f',[0]]
.   .   .   .   .   .   .   case 'p':
.   .   .   .   .   .   .   .   if (prefix(p, "df"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.pdf";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tre",'t',[2,'x']]
.   .   .   .   .   .   .   case 't':
.   .   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-tree",'x',[0]]
.   .   .   .   .   .   .   .   case 'e':
.   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 'x' &&
.   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.tex";
.   .   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   .   // [23,"c++py-tree-democ++p-trex",'t',[0]]
.   .   .   .   .   .   .   .   case 'x':
.   .   .   .   .   .   .   .   .   if ((*p == 0 || (*p ++ == 't' &&
.   .   .   .   .   .   .   .   .   .   (*p == 0))))
.   .   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py-tree.txt";
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   return error;
.   .   .   .   // [19,"c++py-tree-democ++p",'/',[4,'R']]
.   .   .   .   case '/':
.   .   .   .   .   switch (*p ++) {
.   .   .   .   .   // [19,"c++py-tree-democ++p.src",'-',[2,'f']]
.   .   .   .   .   case '.':
.   .   .   .   .   .   if (prefix("src-", p)) {
.   .   .   .   .   .   .   p += 4;
.   .   .   .   .   .   .   switch (*p ++) {
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcdir",'s',[0]]
.   .   .   .   .   .   .   case 'd':
.   .   .   .   .   .   .   .   if (prefix(p, "irs"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-dirs";
.   .   .   .   .   .   .   .   return error;
.   .   .   .   .   .   .   // [23,"c++py-tree-democ++p.srcfile",'s',[0]]
.   .   .   .   .   .   .   case 'f':
.   .   .   .   .   .   .   .   if (prefix(p, "iles"))
.   .   .   .   .   .   .   .   .   return "c++py-tree-demo/c++py/.src-files";
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pAUTHO",'R',[0]]
.   .   .   .   .   case 'A':
.   .   .   .   .   .   if (prefix(p, "UTHOR"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/AUTHOR";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pMakefil",'e',[0]]
.   .   .   .   .   case 'M':
.   .   .   .   .   .   if (prefix(p, "akefile"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/Makefile";
.   .   .   .   .   .   return error;
.   .   .   .   .   // [19,"c++py-tree-democ++pREADM",'E',[0]]
.   .   .   .   .   case 'R':
.   .   .   .   .   .   if (prefix(p, "EADME"))
.   .   .   .   .   .   .   return "c++py-tree-demo/c++py/README";
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   return error;
$

--[ gen-wide-trie-base0-array ]-------------------------------------------------

$ trie() { ../src/trie --gen=wide --output=trie --trie=array "$@"; }
$ print a|trie
{
    'a': "a"
}
$ print a ab|trie
{
    'a': "a" {
        'b': "ab"
    }
}
$ print a ab abc|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc"
        }
    }
}
$ print a b|trie
{
    'a': "a"
    'b': "b"
}
$ print a b abc bac abd|trie
{
    'a': "a" {
        'b' {
            'c': "abc"
            'd': "abd"
        }
    }
    'b': "b" {
        'a' {
            'c': "bac"
        }
    }
}
$ print a bb ba c|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c': "c"
}
$ print a bb ba cc|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c': "cc"
    }
}
$ print a bb ba ccc|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print a bb ba cde|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e': "cde"
        }
    }
}
$ print a bb ba cdef|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e' {
                'f': "cdef"
            }
        }
    }
}
$ print a bb ba cdef cdefg|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e' {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print a bb bac cdef|trie
{
    'a': "a"
    'b' {
        'a' {
            'c': "bac"
        }
        'b': "bb"
    }
    'c' {
        'd' {
            'e' {
                'f': "cdef"
            }
        }
    }
}
$ print a bbx ba ccc|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b' {
            'x': "bbx"
        }
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print a bbx bay ccc|trie
{
    'a': "a"
    'b' {
        'a' {
            'y': "bay"
        }
        'b' {
            'x': "bbx"
        }
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print a cde cdef|trie
{
    'a': "a"
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef"
            }
        }
    }
}
$ print a cde cdef cdefg|trie
{
    'a': "a"
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print a cde cdef cdefgh|trie
{
    'a': "a"
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef" {
                    'g' {
                        'h': "cdefgh"
                    }
                }
            }
        }
    }
}
$ print a cdef cdefg|trie
{
    'a': "a"
    'c' {
        'd' {
            'e' {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print ab|trie
{
    'a' {
        'b': "ab"
    }
}
$ print ab bb ba ccc|trie
{
    'a' {
        'b': "ab"
    }
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print ab bb ba cde|trie
{
    'a' {
        'b': "ab"
    }
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e': "cde"
        }
    }
}
$ print ab bbx ba ccc|trie
{
    'a' {
        'b': "ab"
    }
    'b' {
        'a': "ba"
        'b' {
            'x': "bbx"
        }
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print ab c|trie
{
    'a' {
        'b': "ab"
    }
    'c': "c"
}
$ print abc bb ba ccc|trie
{
    'a' {
        'b' {
            'c': "abc"
        }
    }
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print abcd abde abef|trie
{
    'a' {
        'b' {
            'c' {
                'd': "abcd"
            }
            'd' {
                'e': "abde"
            }
            'e' {
                'f': "abef"
            }
        }
    }
}
$ print abg a abc ab abd|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc"
            'd': "abd"
            'g': "abg"
        }
    }
}
$ print ac ab|trie
{
    'a' {
        'b': "ab"
        'c': "ac"
    }
}
$ print aef ae abg a abc ab abd|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc"
            'd': "abd"
            'g': "abg"
        }
        'e': "ae" {
            'f': "aef"
        }
    }
}
$ print cde cdef cdefgh|trie
{
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef" {
                    'g' {
                        'h': "cdefgh"
                    }
                }
            }
        }
    }
}
$ print cdef cdefg|trie
{
    'c' {
        'd' {
            'e' {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print cdex cdfy cdgz cdhw|trie
{
    'c' {
        'd' {
            'e' {
                'x': "cdex"
            }
            'f' {
                'y': "cdfy"
            }
            'g' {
                'z': "cdgz"
            }
            'h' {
                'w': "cdhw"
            }
        }
    }
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    'c' {
        'd' {
            'e' {
                'x': "cdex"
            }
            'f' {
                'y': "cdfy"
            }
            'g' {
                'z': "cdgz"
            }
            'h' {
                'w': "cdhw"
            }
        }
        'e': "ce"
    }
}
$ print pot potato pottery tattoo tempo|trie
{
    'p' {
        'o' {
            't': "pot" {
                'a' {
                    't' {
                        'o': "potato"
                    }
                }
                't' {
                    'e' {
                        'r' {
                            'y': "pottery"
                        }
                    }
                }
            }
        }
    }
    't' {
        'a' {
            't' {
                't' {
                    'o' {
                        'o': "tattoo"
                    }
                }
            }
        }
        'e' {
            'm' {
                'p' {
                    'o': "tempo"
                }
            }
        }
    }
}
$

--[ gen-wide-trie-base0-ternary ]-----------------------------------------------

$ trie() { ../src/trie --gen=wide --output=trie --trie=ternary "$@"; }
$ print a|trie
{
    'a': "a"
}
$ print a ab|trie
{
    'a': "a" {
        'b': "ab"
    }
}
$ print a ab abc|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc"
        }
    }
}
$ print a b|trie
{
    'a': "a"
    'b': "b"
}
$ print a b abc bac abd|trie
{
    'a': "a" {
        'b' {
            'c': "abc"
            'd': "abd"
        }
    }
    'b': "b" {
        'a' {
            'c': "bac"
        }
    }
}
$ print a bb ba c|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c': "c"
}
$ print a bb ba cc|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c': "cc"
    }
}
$ print a bb ba ccc|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print a bb ba cde|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e': "cde"
        }
    }
}
$ print a bb ba cdef|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e' {
                'f': "cdef"
            }
        }
    }
}
$ print a bb ba cdef cdefg|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e' {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print a bb bac cdef|trie
{
    'a': "a"
    'b' {
        'a' {
            'c': "bac"
        }
        'b': "bb"
    }
    'c' {
        'd' {
            'e' {
                'f': "cdef"
            }
        }
    }
}
$ print a bbx ba ccc|trie
{
    'a': "a"
    'b' {
        'a': "ba"
        'b' {
            'x': "bbx"
        }
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print a bbx bay ccc|trie
{
    'a': "a"
    'b' {
        'a' {
            'y': "bay"
        }
        'b' {
            'x': "bbx"
        }
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print a cde cdef|trie
{
    'a': "a"
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef"
            }
        }
    }
}
$ print a cde cdef cdefg|trie
{
    'a': "a"
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print a cde cdef cdefgh|trie
{
    'a': "a"
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef" {
                    'g' {
                        'h': "cdefgh"
                    }
                }
            }
        }
    }
}
$ print a cdef cdefg|trie
{
    'a': "a"
    'c' {
        'd' {
            'e' {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print ab|trie
{
    'a' {
        'b': "ab"
    }
}
$ print ab bb ba ccc|trie
{
    'a' {
        'b': "ab"
    }
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print ab bb ba cde|trie
{
    'a' {
        'b': "ab"
    }
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'd' {
            'e': "cde"
        }
    }
}
$ print ab bbx ba ccc|trie
{
    'a' {
        'b': "ab"
    }
    'b' {
        'a': "ba"
        'b' {
            'x': "bbx"
        }
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print ab c|trie
{
    'a' {
        'b': "ab"
    }
    'c': "c"
}
$ print abc bb ba ccc|trie
{
    'a' {
        'b' {
            'c': "abc"
        }
    }
    'b' {
        'a': "ba"
        'b': "bb"
    }
    'c' {
        'c' {
            'c': "ccc"
        }
    }
}
$ print abcd abde abef|trie
{
    'a' {
        'b' {
            'c' {
                'd': "abcd"
            }
            'd' {
                'e': "abde"
            }
            'e' {
                'f': "abef"
            }
        }
    }
}
$ print abg a abc ab abd|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc"
            'd': "abd"
            'g': "abg"
        }
    }
}
$ print ac ab|trie
{
    'a' {
        'b': "ab"
        'c': "ac"
    }
}
$ print aef ae abg a abc ab abd|trie
{
    'a': "a" {
        'b': "ab" {
            'c': "abc"
            'd': "abd"
            'g': "abg"
        }
        'e': "ae" {
            'f': "aef"
        }
    }
}
$ print cde cdef cdefgh|trie
{
    'c' {
        'd' {
            'e': "cde" {
                'f': "cdef" {
                    'g' {
                        'h': "cdefgh"
                    }
                }
            }
        }
    }
}
$ print cdef cdefg|trie
{
    'c' {
        'd' {
            'e' {
                'f': "cdef" {
                    'g': "cdefg"
                }
            }
        }
    }
}
$ print cdex cdfy cdgz cdhw|trie
{
    'c' {
        'd' {
            'e' {
                'x': "cdex"
            }
            'f' {
                'y': "cdfy"
            }
            'g' {
                'z': "cdgz"
            }
            'h' {
                'w': "cdhw"
            }
        }
    }
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    'c' {
        'd' {
            'e' {
                'x': "cdex"
            }
            'f' {
                'y': "cdfy"
            }
            'g' {
                'z': "cdgz"
            }
            'h' {
                'w': "cdhw"
            }
        }
        'e': "ce"
    }
}
$ print pot potato pottery tattoo tempo|trie
{
    'p' {
        'o' {
            't': "pot" {
                'a' {
                    't' {
                        'o': "potato"
                    }
                }
                't' {
                    'e' {
                        'r' {
                            'y': "pottery"
                        }
                    }
                }
            }
        }
    }
    't' {
        'a' {
            't' {
                't' {
                    'o' {
                        'o': "tattoo"
                    }
                }
            }
        }
        'e' {
            'm' {
                'p' {
                    'o': "tempo"
                }
            }
        }
    }
}
$

--[ gen-wide-trie-base ]--------------------------------------------------------

$ trie() { ../src/trie --gen=wide --output=trie --attrs --no-dots "$@"; }
$ print a ab abc abd ac|trie
[1,'a'] {
    'a': "a" [2,'c'] {
        'b': "ab" [2,'d'] {
            'c': "abc"
            'd': "abd"
        }
        'c': "ac"
    }
}
$ print a ab abc abd ac|trie -t int
[1,'a'] {
    'a': 1 [2,'c'] {
        'b': 2 [2,'d'] {
            'c': 3
            'd': 4
        }
        'c': 5
    }
}
$ print a ab abc abd ac|trie -t float
[1,'a'] {
    'a': 1.0 [2,'c'] {
        'b': 2.0 [2,'d'] {
            'c': 3.0
            'd': 4.0
        }
        'c': 5.0
    }
}
$

--[ gen-wide-trie-base-array ]--------------------------------------------------

$ trie() { ../src/trie --gen=wide --output=trie --attrs --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
[1,'a'] {
.   'a': "a"
}
$ print a b|trie
[2,'b'] {
.   'a': "a"
.   'b': "b"
}
$ print a b c|trie
[3,'c'] {
.   'a': "a"
.   'b': "b"
.   'c': "c"
}
$ print a ab abc|trie
[1,'a'] {
.   'a': "a" [1,'b'] {
.   .   'b': "ab" [1,'c'] {
.   .   .   'c': "abc"
.   .   }
.   }
}
$ print a ab ac|trie
[1,'a'] {
.   'a': "a" [2,'c'] {
.   .   'b': "ab"
.   .   'c': "ac"
.   }
}
$ print a ab ac ad|trie
[1,'a'] {
.   'a': "a" [3,'d'] {
.   .   'b': "ab"
.   .   'c': "ac"
.   .   'd': "ad"
.   }
}
$ print a abd ac|trie
[1,'a'] {
.   'a': "a" [2,'c'] {
.   .   'b' [1,'d'] {
.   .   .   'd': "abd"
.   .   }
.   .   'c': "ac"
.   }
}
$ print a ab ac acd|trie
[1,'a'] {
.   'a': "a" [2,'c'] {
.   .   'b': "ab"
.   .   'c': "ac" [1,'d'] {
.   .   .   'd': "acd"
.   .   }
.   }
}
$ print a bb ba ccc|trie
[3,'c'] {
.   'a': "a"
.   'b' [2,'b'] {
.   .   'a': "ba"
.   .   'b': "bb"
.   }
.   'c' [1,'c'] {
.   .   'c' [1,'c'] {
.   .   .   'c': "ccc"
.   .   }
.   }
}
$ print a bb ccc|trie
[3,'c'] {
.   'a': "a"
.   'b' [1,'b'] {
.   .   'b': "bb"
.   }
.   'c' [1,'c'] {
.   .   'c' [1,'c'] {
.   .   .   'c': "ccc"
.   .   }
.   }
}
$ print a bb ba ccc|trie
[3,'c'] {
.   'a': "a"
.   'b' [2,'b'] {
.   .   'a': "ba"
.   .   'b': "bb"
.   }
.   'c' [1,'c'] {
.   .   'c' [1,'c'] {
.   .   .   'c': "ccc"
.   .   }
.   }
}
$ print abc abd acde|trie
[1,'a'] {
.   'a' [2,'c'] {
.   .   'b' [2,'d'] {
.   .   .   'c': "abc"
.   .   .   'd': "abd"
.   .   }
.   .   'c' [1,'d'] {
.   .   .   'd' [1,'e'] {
.   .   .   .   'e': "acde"
.   .   .   }
.   .   }
.   }
}
$ print abc abd acde ac|trie
[1,'a'] {
.   'a' [2,'c'] {
.   .   'b' [2,'d'] {
.   .   .   'c': "abc"
.   .   .   'd': "abd"
.   .   }
.   .   'c': "ac" [1,'d'] {
.   .   .   'd' [1,'e'] {
.   .   .   .   'e': "acde"
.   .   .   }
.   .   }
.   }
}
$ print abc abd acde acfg|trie
[1,'a'] {
.   'a' [2,'c'] {
.   .   'b' [2,'d'] {
.   .   .   'c': "abc"
.   .   .   'd': "abd"
.   .   }
.   .   'c' [2,'f'] {
.   .   .   'd' [1,'e'] {
.   .   .   .   'e': "acde"
.   .   .   }
.   .   .   'f' [1,'g'] {
.   .   .   .   'g': "acfg"
.   .   .   }
.   .   }
.   }
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c'] {
.   'c' [2,'f'] {
.   .   'd' [1,'e'] {
.   .   .   'e': "cde"
.   .   }
.   .   'f' [1,'g'] {
.   .   .   'g': "cfg" [1,'x'] {
.   .   .   .   'x': "cfgx" [2,'z'] {
.   .   .   .   .   'y': "cfgxy" [1,'z'] {
.   .   .   .   .   .   'z': "cfgxyz"
.   .   .   .   .   }
.   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   .   'z': "cfgxzzz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c'] {
.   'c' [2,'g'] {
.   .   'f' [1,'g'] {
.   .   .   'g': "cfg" [1,'x'] {
.   .   .   .   'x': "cfgx" [2,'z'] {
.   .   .   .   .   'y': "cfgxy" [1,'z'] {
.   .   .   .   .   .   'z': "cfgxyz"
.   .   .   .   .   }
.   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   .   'z': "cfgxzzz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'g' [1,'e'] {
.   .   .   'e': "cge"
.   .   }
.   }
}
$ print a abcd abcdefg h hijk|trie
[2,'h'] {
.   'a': "a" [1,'b'] {
.   .   'b' [1,'c'] {
.   .   .   'c' [1,'d'] {
.   .   .   .   'd': "abcd" [1,'e'] {
.   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   'f' [1,'g'] {
.   .   .   .   .   .   .   'g': "abcdefg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'h': "h" [1,'i'] {
.   .   'i' [1,'j'] {
.   .   .   'j' [1,'k'] {
.   .   .   .   'k': "hijk"
.   .   .   }
.   .   }
.   }
}
$ print a abcd abcdefg abcdxyz h hijk|trie
[2,'h'] {
.   'a': "a" [1,'b'] {
.   .   'b' [1,'c'] {
.   .   .   'c' [1,'d'] {
.   .   .   .   'd': "abcd" [2,'x'] {
.   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   'f' [1,'g'] {
.   .   .   .   .   .   .   'g': "abcdefg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   'x' [1,'y'] {
.   .   .   .   .   .   'y' [1,'z'] {
.   .   .   .   .   .   .   'z': "abcdxyz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'h': "h" [1,'i'] {
.   .   'i' [1,'j'] {
.   .   .   'j' [1,'k'] {
.   .   .   .   'k': "hijk"
.   .   .   }
.   .   }
.   }
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
[2,'h'] {
.   'a': "a" [1,'b'] {
.   .   'b' [1,'c'] {
.   .   .   'c' [1,'d'] {
.   .   .   .   'd': "abcd" [2,'x'] {
.   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   'f' [1,'g'] {
.   .   .   .   .   .   .   'g': "abcdefg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   'x' [1,'y'] {
.   .   .   .   .   .   'y' [1,'z'] {
.   .   .   .   .   .   .   'z': "abcdxyz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'h': "h" [2,'l'] {
.   .   'i' [1,'j'] {
.   .   .   'j' [1,'k'] {
.   .   .   .   'k': "hijk"
.   .   .   }
.   .   }
.   .   'l' [1,'m'] {
.   .   .   'm': "hlm"
.   .   }
.   }
}
$

--[ gen-wide-trie-base-ternary ]------------------------------------------------

$ trie() { ../src/trie --gen=wide --output=trie --attrs --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
[1,'a'] {
.   'a': "a"
}
$ print a b|trie
[2,'b'] {
.   'a': "a"
.   'b': "b"
}
$ print a b c|trie
[3,'c'] {
.   'a': "a"
.   'b': "b"
.   'c': "c"
}
$ print a ab abc|trie
[1,'a'] {
.   'a': "a" [1,'b'] {
.   .   'b': "ab" [1,'c'] {
.   .   .   'c': "abc"
.   .   }
.   }
}
$ print a ab ac|trie
[1,'a'] {
.   'a': "a" [2,'c'] {
.   .   'b': "ab"
.   .   'c': "ac"
.   }
}
$ print a ab ac ad|trie
[1,'a'] {
.   'a': "a" [3,'d'] {
.   .   'b': "ab"
.   .   'c': "ac"
.   .   'd': "ad"
.   }
}
$ print a abd ac|trie
[1,'a'] {
.   'a': "a" [2,'c'] {
.   .   'b' [1,'d'] {
.   .   .   'd': "abd"
.   .   }
.   .   'c': "ac"
.   }
}
$ print a ab ac acd|trie
[1,'a'] {
.   'a': "a" [2,'c'] {
.   .   'b': "ab"
.   .   'c': "ac" [1,'d'] {
.   .   .   'd': "acd"
.   .   }
.   }
}
$ print a bb ba ccc|trie
[3,'c'] {
.   'a': "a"
.   'b' [2,'b'] {
.   .   'a': "ba"
.   .   'b': "bb"
.   }
.   'c' [1,'c'] {
.   .   'c' [1,'c'] {
.   .   .   'c': "ccc"
.   .   }
.   }
}
$ print a bb ccc|trie
[3,'c'] {
.   'a': "a"
.   'b' [1,'b'] {
.   .   'b': "bb"
.   }
.   'c' [1,'c'] {
.   .   'c' [1,'c'] {
.   .   .   'c': "ccc"
.   .   }
.   }
}
$ print a bb ba ccc|trie
[3,'c'] {
.   'a': "a"
.   'b' [2,'b'] {
.   .   'a': "ba"
.   .   'b': "bb"
.   }
.   'c' [1,'c'] {
.   .   'c' [1,'c'] {
.   .   .   'c': "ccc"
.   .   }
.   }
}
$ print abc abd acde|trie
[1,'a'] {
.   'a' [2,'c'] {
.   .   'b' [2,'d'] {
.   .   .   'c': "abc"
.   .   .   'd': "abd"
.   .   }
.   .   'c' [1,'d'] {
.   .   .   'd' [1,'e'] {
.   .   .   .   'e': "acde"
.   .   .   }
.   .   }
.   }
}
$ print abc abd acde ac|trie
[1,'a'] {
.   'a' [2,'c'] {
.   .   'b' [2,'d'] {
.   .   .   'c': "abc"
.   .   .   'd': "abd"
.   .   }
.   .   'c': "ac" [1,'d'] {
.   .   .   'd' [1,'e'] {
.   .   .   .   'e': "acde"
.   .   .   }
.   .   }
.   }
}
$ print abc abd acde acfg|trie
[1,'a'] {
.   'a' [2,'c'] {
.   .   'b' [2,'d'] {
.   .   .   'c': "abc"
.   .   .   'd': "abd"
.   .   }
.   .   'c' [2,'f'] {
.   .   .   'd' [1,'e'] {
.   .   .   .   'e': "acde"
.   .   .   }
.   .   .   'f' [1,'g'] {
.   .   .   .   'g': "acfg"
.   .   .   }
.   .   }
.   }
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c'] {
.   'c' [2,'f'] {
.   .   'd' [1,'e'] {
.   .   .   'e': "cde"
.   .   }
.   .   'f' [1,'g'] {
.   .   .   'g': "cfg" [1,'x'] {
.   .   .   .   'x': "cfgx" [2,'z'] {
.   .   .   .   .   'y': "cfgxy" [1,'z'] {
.   .   .   .   .   .   'z': "cfgxyz"
.   .   .   .   .   }
.   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   .   'z': "cfgxzzz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c'] {
.   'c' [2,'g'] {
.   .   'f' [1,'g'] {
.   .   .   'g': "cfg" [1,'x'] {
.   .   .   .   'x': "cfgx" [2,'z'] {
.   .   .   .   .   'y': "cfgxy" [1,'z'] {
.   .   .   .   .   .   'z': "cfgxyz"
.   .   .   .   .   }
.   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   'z' [1,'z'] {
.   .   .   .   .   .   .   'z': "cfgxzzz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'g' [1,'e'] {
.   .   .   'e': "cge"
.   .   }
.   }
}
$ print a abcd abcdefg h hijk|trie
[2,'h'] {
.   'a': "a" [1,'b'] {
.   .   'b' [1,'c'] {
.   .   .   'c' [1,'d'] {
.   .   .   .   'd': "abcd" [1,'e'] {
.   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   'f' [1,'g'] {
.   .   .   .   .   .   .   'g': "abcdefg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'h': "h" [1,'i'] {
.   .   'i' [1,'j'] {
.   .   .   'j' [1,'k'] {
.   .   .   .   'k': "hijk"
.   .   .   }
.   .   }
.   }
}
$ print a abcd abcdefg abcdxyz h hijk|trie
[2,'h'] {
.   'a': "a" [1,'b'] {
.   .   'b' [1,'c'] {
.   .   .   'c' [1,'d'] {
.   .   .   .   'd': "abcd" [2,'x'] {
.   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   'f' [1,'g'] {
.   .   .   .   .   .   .   'g': "abcdefg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   'x' [1,'y'] {
.   .   .   .   .   .   'y' [1,'z'] {
.   .   .   .   .   .   .   'z': "abcdxyz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'h': "h" [1,'i'] {
.   .   'i' [1,'j'] {
.   .   .   'j' [1,'k'] {
.   .   .   .   'k': "hijk"
.   .   .   }
.   .   }
.   }
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
[2,'h'] {
.   'a': "a" [1,'b'] {
.   .   'b' [1,'c'] {
.   .   .   'c' [1,'d'] {
.   .   .   .   'd': "abcd" [2,'x'] {
.   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   'f' [1,'g'] {
.   .   .   .   .   .   .   'g': "abcdefg"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   .   'x' [1,'y'] {
.   .   .   .   .   .   'y' [1,'z'] {
.   .   .   .   .   .   .   'z': "abcdxyz"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'h': "h" [2,'l'] {
.   .   'i' [1,'j'] {
.   .   .   'j' [1,'k'] {
.   .   .   .   'k': "hijk"
.   .   .   }
.   .   }
.   .   'l' [1,'m'] {
.   .   .   'm': "hlm"
.   .   }
.   }
}
$

--[ gen-wide-trie-alphabets-array ]---------------------------------------------

$ ../src/trie --attrs --dots --gen=wide --output=trie --trie=array < alphabets.txt
[25,'z'] {
.   'a' [8,'z'] {
.   .   'a': "aa"
.   .   'f': "af"
.   .   'g' [1,'q'] {
.   .   .   'q': "agq"
.   .   }
.   .   'k': "ak"
.   .   'm': "am"
.   .   'r': "ar"
.   .   's': "as" [2,'t'] {
.   .   .   'a': "asa"
.   .   .   't': "ast"
.   .   }
.   .   'z': "az" [1,'_'] {
.   .   .   '_' [1,'C'] {
.   .   .   .   'C' [1,'y'] {
.   .   .   .   .   'y' [1,'r'] {
.   .   .   .   .   .   'r' [1,'l'] {
.   .   .   .   .   .   .   'l': "az_Cyrl"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'b' [9,'y'] {
.   .   'a' [1,'s'] {
.   .   .   's': "bas"
.   .   }
.   .   'e': "be" [2,'z'] {
.   .   .   'm': "bem"
.   .   .   'z': "bez"
.   .   }
.   .   'g': "bg"
.   .   'm': "bm"
.   .   'n': "bn"
.   .   'o': "bo"
.   .   'r': "br" [1,'x'] {
.   .   .   'x': "brx"
.   .   }
.   .   's': "bs" [1,'_'] {
.   .   .   '_' [1,'C'] {
.   .   .   .   'C' [1,'y'] {
.   .   .   .   .   'y' [1,'r'] {
.   .   .   .   .   .   'r' [1,'l'] {
.   .   .   .   .   .   .   'l': "bs_Cyrl"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'y' [1,'n'] {
.   .   .   'n': "byn"
.   .   }
.   }
.   'c' [5,'y'] {
.   .   'a': "ca"
.   .   'g' [1,'g'] {
.   .   .   'g': "cgg"
.   .   }
.   .   'h' [1,'r'] {
.   .   .   'r': "chr"
.   .   }
.   .   's': "cs"
.   .   'y': "cy"
.   }
.   'd' [6,'z'] {
.   .   'a': "da" [1,'v'] {
.   .   .   'v': "dav"
.   .   }
.   .   'e': "de"
.   .   'j' [1,'e'] {
.   .   .   'e': "dje"
.   .   }
.   .   'u' [1,'a'] {
.   .   .   'a': "dua"
.   .   }
.   .   'y' [1,'o'] {
.   .   .   'o': "dyo"
.   .   }
.   .   'z': "dz"
.   }
.   'e' [9,'w'] {
.   .   'b' [1,'u'] {
.   .   .   'u': "ebu"
.   .   }
.   .   'e': "ee"
.   .   'l': "el"
.   .   'n': "en"
.   .   'o': "eo"
.   .   's': "es"
.   .   't': "et"
.   .   'u': "eu"
.   .   'w' [1,'o'] {
.   .   .   'o': "ewo"
.   .   }
.   }
.   'f' [7,'y'] {
.   .   'a': "fa"
.   .   'f': "ff"
.   .   'i': "fi" [1,'l'] {
.   .   .   'l': "fil"
.   .   }
.   .   'o': "fo"
.   .   'r': "fr"
.   .   'u' [1,'r'] {
.   .   .   'r': "fur"
.   .   }
.   .   'y': "fy"
.   }
.   'g' [6,'v'] {
.   .   'a': "ga"
.   .   'd': "gd"
.   .   'l': "gl"
.   .   's' [1,'w'] {
.   .   .   'w': "gsw"
.   .   }
.   .   'u': "gu" [1,'z'] {
.   .   .   'z': "guz"
.   .   }
.   .   'v': "gv"
.   }
.   'h' [6,'y'] {
.   .   'a': "ha" [1,'w'] {
.   .   .   'w': "haw"
.   .   }
.   .   'e': "he"
.   .   'i': "hi"
.   .   'r': "hr"
.   .   'u': "hu"
.   .   'y': "hy"
.   }
.   'i' [6,'t'] {
.   .   'a': "ia"
.   .   'd': "id"
.   .   'g': "ig"
.   .   'i': "ii"
.   .   's': "is"
.   .   't': "it"
.   }
.   'j' [3,'m'] {
.   .   'a': "ja"
.   .   'g' [1,'o'] {
.   .   .   'o': "jgo"
.   .   }
.   .   'm' [1,'c'] {
.   .   .   'c': "jmc"
.   .   }
.   }
.   'k' [13,'y'] {
.   .   'a': "ka" [2,'m'] {
.   .   .   'b': "kab"
.   .   .   'm': "kam"
.   .   }
.   .   'd' [1,'e'] {
.   .   .   'e': "kde"
.   .   }
.   .   'e' [1,'a'] {
.   .   .   'a': "kea"
.   .   }
.   .   'h' [1,'q'] {
.   .   .   'q': "khq"
.   .   }
.   .   'i': "ki"
.   .   'k': "kk" [1,'j'] {
.   .   .   'j': "kkj"
.   .   }
.   .   'l': "kl" [1,'n'] {
.   .   .   'n': "kln"
.   .   }
.   .   'm': "km"
.   .   'n': "kn"
.   .   'o': "ko" [1,'k'] {
.   .   .   'k': "kok"
.   .   }
.   .   's' [3,'h'] {
.   .   .   'b': "ksb"
.   .   .   'f': "ksf"
.   .   .   'h': "ksh"
.   .   }
.   .   'w': "kw"
.   .   'y': "ky"
.   }
.   'l' [8,'v'] {
.   .   'a' [1,'g'] {
.   .   .   'g': "lag"
.   .   }
.   .   'g': "lg"
.   .   'k' [1,'t'] {
.   .   .   't': "lkt"
.   .   }
.   .   'n': "ln"
.   .   'o': "lo"
.   .   't': "lt"
.   .   'u': "lu" [2,'y'] {
.   .   .   'o': "luo"
.   .   .   'y': "luy"
.   .   }
.   .   'v': "lv"
.   }
.   'm' [12,'y'] {
.   .   'a' [1,'s'] {
.   .   .   's': "mas"
.   .   }
.   .   'e' [1,'r'] {
.   .   .   'r': "mer"
.   .   }
.   .   'f' [1,'e'] {
.   .   .   'e': "mfe"
.   .   }
.   .   'g': "mg" [2,'o'] {
.   .   .   'h': "mgh"
.   .   .   'o': "mgo"
.   .   }
.   .   'k': "mk"
.   .   'l': "ml"
.   .   'n': "mn"
.   .   'r': "mr"
.   .   's': "ms"
.   .   't': "mt"
.   .   'u' [1,'a'] {
.   .   .   'a': "mua"
.   .   }
.   .   'y': "my"
.   }
.   'n' [11,'y'] {
.   .   'a' [1,'q'] {
.   .   .   'q': "naq"
.   .   }
.   .   'b': "nb"
.   .   'd': "nd"
.   .   'e': "ne"
.   .   'l': "nl"
.   .   'm' [1,'g'] {
.   .   .   'g': "nmg"
.   .   }
.   .   'n': "nn" [1,'h'] {
.   .   .   'h': "nnh"
.   .   }
.   .   'r': "nr"
.   .   's' [1,'o'] {
.   .   .   'o': "nso"
.   .   }
.   .   'u' [1,'s'] {
.   .   .   's': "nus"
.   .   }
.   .   'y' [1,'n'] {
.   .   .   'n': "nyn"
.   .   }
.   }
.   'o' [3,'s'] {
.   .   'm': "om"
.   .   'r': "or"
.   .   's': "os"
.   }
.   'p' [4,'t'] {
.   .   'a': "pa" [1,'_'] {
.   .   .   '_' [1,'A'] {
.   .   .   .   'A' [1,'r'] {
.   .   .   .   .   'r' [1,'a'] {
.   .   .   .   .   .   'a' [1,'b'] {
.   .   .   .   .   .   .   'b': "pa_Arab"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'l': "pl"
.   .   's': "ps"
.   .   't': "pt"
.   }
.   'r' [5,'w'] {
.   .   'm': "rm"
.   .   'n': "rn"
.   .   'o': "ro" [1,'f'] {
.   .   .   'f': "rof"
.   .   }
.   .   'u': "ru"
.   .   'w': "rw" [1,'k'] {
.   .   .   'k': "rwk"
.   .   }
.   }
.   's' [16,'w'] {
.   .   'a' [2,'q'] {
.   .   .   'h': "sah"
.   .   .   'q': "saq"
.   .   }
.   .   'b' [1,'p'] {
.   .   .   'p': "sbp"
.   .   }
.   .   'e': "se" [2,'s'] {
.   .   .   'h': "seh"
.   .   .   's': "ses"
.   .   }
.   .   'g': "sg"
.   .   'h' [1,'i'] {
.   .   .   'i': "shi" [1,'_'] {
.   .   .   .   '_' [1,'L'] {
.   .   .   .   .   'L' [1,'a'] {
.   .   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   .   't' [1,'n'] {
.   .   .   .   .   .   .   .   'n': "shi_Latn"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'i': "si"
.   .   'k': "sk"
.   .   'l': "sl"
.   .   'n': "sn"
.   .   'o': "so"
.   .   'q': "sq"
.   .   'r': "sr" [1,'_'] {
.   .   .   '_' [1,'L'] {
.   .   .   .   'L' [1,'a'] {
.   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   't' [1,'n'] {
.   .   .   .   .   .   .   'n': "sr_Latn"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   's': "ss" [1,'y'] {
.   .   .   'y': "ssy"
.   .   }
.   .   't': "st"
.   .   'v': "sv"
.   .   'w': "sw" [1,'c'] {
.   .   .   'c': "swc"
.   .   }
.   }
.   't' [11,'z'] {
.   .   'a': "ta"
.   .   'e': "te" [1,'o'] {
.   .   .   'o': "teo"
.   .   }
.   .   'g': "tg"
.   .   'h': "th"
.   .   'i': "ti" [2,'g'] {
.   .   .   '_' [1,'E'] {
.   .   .   .   'E' [1,'R'] {
.   .   .   .   .   'R': "ti_ER"
.   .   .   .   }
.   .   .   }
.   .   .   'g': "tig"
.   .   }
.   .   'n': "tn"
.   .   'o': "to"
.   .   'r': "tr"
.   .   's': "ts"
.   .   'w' [1,'q'] {
.   .   .   'q': "twq"
.   .   }
.   .   'z' [1,'m'] {
.   .   .   'm': "tzm"
.   .   }
.   }
.   'u' [4,'z'] {
.   .   'g': "ug"
.   .   'k': "uk"
.   .   'r': "ur"
.   .   'z': "uz" [1,'_'] {
.   .   .   '_' [2,'C'] {
.   .   .   .   'A' [1,'r'] {
.   .   .   .   .   'r' [1,'a'] {
.   .   .   .   .   .   'a' [1,'b'] {
.   .   .   .   .   .   .   'b': "uz_Arab"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   'C' [1,'y'] {
.   .   .   .   .   'y' [1,'r'] {
.   .   .   .   .   .   'r' [1,'l'] {
.   .   .   .   .   .   .   'l': "uz_Cyrl"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'v' [5,'u'] {
.   .   'a' [1,'i'] {
.   .   .   'i' [1,'_'] {
.   .   .   .   '_' [1,'L'] {
.   .   .   .   .   'L' [1,'a'] {
.   .   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   .   't' [1,'n'] {
.   .   .   .   .   .   .   .   'n': "vai_Latn"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'e': "ve"
.   .   'i': "vi"
.   .   'o': "vo"
.   .   'u' [1,'n'] {
.   .   .   'n': "vun"
.   .   }
.   }
.   'w' [1,'a'] {
.   .   'a' [2,'l'] {
.   .   .   'e': "wae"
.   .   .   'l': "wal"
.   .   }
.   }
.   'x' [2,'o'] {
.   .   'h': "xh"
.   .   'o' [1,'g'] {
.   .   .   'g': "xog"
.   .   }
.   }
.   'y' [2,'o'] {
.   .   'a' [1,'v'] {
.   .   .   'v': "yav"
.   .   }
.   .   'o': "yo" [1,'_'] {
.   .   .   '_' [1,'B'] {
.   .   .   .   'B' [1,'J'] {
.   .   .   .   .   'J': "yo_BJ"
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'z' [3,'u'] {
.   .   'g' [1,'h'] {
.   .   .   'h': "zgh"
.   .   }
.   .   'h': "zh" [1,'_'] {
.   .   .   '_' [1,'H'] {
.   .   .   .   'H' [1,'a'] {
.   .   .   .   .   'a' [1,'n'] {
.   .   .   .   .   .   'n' [1,'t'] {
.   .   .   .   .   .   .   't': "zh_Hant"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'u': "zu"
.   }
}
$

--[ gen-wide-trie-alphabets-ternary ]-------------------------------------------

$ ../src/trie --attrs --dots --gen=wide --output=trie --trie=ternary < alphabets.txt
[25,'z'] {
.   'a' [8,'z'] {
.   .   'a': "aa"
.   .   'f': "af"
.   .   'g' [1,'q'] {
.   .   .   'q': "agq"
.   .   }
.   .   'k': "ak"
.   .   'm': "am"
.   .   'r': "ar"
.   .   's': "as" [2,'t'] {
.   .   .   'a': "asa"
.   .   .   't': "ast"
.   .   }
.   .   'z': "az" [1,'_'] {
.   .   .   '_' [1,'C'] {
.   .   .   .   'C' [1,'y'] {
.   .   .   .   .   'y' [1,'r'] {
.   .   .   .   .   .   'r' [1,'l'] {
.   .   .   .   .   .   .   'l': "az_Cyrl"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'b' [9,'y'] {
.   .   'a' [1,'s'] {
.   .   .   's': "bas"
.   .   }
.   .   'e': "be" [2,'z'] {
.   .   .   'm': "bem"
.   .   .   'z': "bez"
.   .   }
.   .   'g': "bg"
.   .   'm': "bm"
.   .   'n': "bn"
.   .   'o': "bo"
.   .   'r': "br" [1,'x'] {
.   .   .   'x': "brx"
.   .   }
.   .   's': "bs" [1,'_'] {
.   .   .   '_' [1,'C'] {
.   .   .   .   'C' [1,'y'] {
.   .   .   .   .   'y' [1,'r'] {
.   .   .   .   .   .   'r' [1,'l'] {
.   .   .   .   .   .   .   'l': "bs_Cyrl"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'y' [1,'n'] {
.   .   .   'n': "byn"
.   .   }
.   }
.   'c' [5,'y'] {
.   .   'a': "ca"
.   .   'g' [1,'g'] {
.   .   .   'g': "cgg"
.   .   }
.   .   'h' [1,'r'] {
.   .   .   'r': "chr"
.   .   }
.   .   's': "cs"
.   .   'y': "cy"
.   }
.   'd' [6,'z'] {
.   .   'a': "da" [1,'v'] {
.   .   .   'v': "dav"
.   .   }
.   .   'e': "de"
.   .   'j' [1,'e'] {
.   .   .   'e': "dje"
.   .   }
.   .   'u' [1,'a'] {
.   .   .   'a': "dua"
.   .   }
.   .   'y' [1,'o'] {
.   .   .   'o': "dyo"
.   .   }
.   .   'z': "dz"
.   }
.   'e' [9,'w'] {
.   .   'b' [1,'u'] {
.   .   .   'u': "ebu"
.   .   }
.   .   'e': "ee"
.   .   'l': "el"
.   .   'n': "en"
.   .   'o': "eo"
.   .   's': "es"
.   .   't': "et"
.   .   'u': "eu"
.   .   'w' [1,'o'] {
.   .   .   'o': "ewo"
.   .   }
.   }
.   'f' [7,'y'] {
.   .   'a': "fa"
.   .   'f': "ff"
.   .   'i': "fi" [1,'l'] {
.   .   .   'l': "fil"
.   .   }
.   .   'o': "fo"
.   .   'r': "fr"
.   .   'u' [1,'r'] {
.   .   .   'r': "fur"
.   .   }
.   .   'y': "fy"
.   }
.   'g' [6,'v'] {
.   .   'a': "ga"
.   .   'd': "gd"
.   .   'l': "gl"
.   .   's' [1,'w'] {
.   .   .   'w': "gsw"
.   .   }
.   .   'u': "gu" [1,'z'] {
.   .   .   'z': "guz"
.   .   }
.   .   'v': "gv"
.   }
.   'h' [6,'y'] {
.   .   'a': "ha" [1,'w'] {
.   .   .   'w': "haw"
.   .   }
.   .   'e': "he"
.   .   'i': "hi"
.   .   'r': "hr"
.   .   'u': "hu"
.   .   'y': "hy"
.   }
.   'i' [6,'t'] {
.   .   'a': "ia"
.   .   'd': "id"
.   .   'g': "ig"
.   .   'i': "ii"
.   .   's': "is"
.   .   't': "it"
.   }
.   'j' [3,'m'] {
.   .   'a': "ja"
.   .   'g' [1,'o'] {
.   .   .   'o': "jgo"
.   .   }
.   .   'm' [1,'c'] {
.   .   .   'c': "jmc"
.   .   }
.   }
.   'k' [13,'y'] {
.   .   'a': "ka" [2,'m'] {
.   .   .   'b': "kab"
.   .   .   'm': "kam"
.   .   }
.   .   'd' [1,'e'] {
.   .   .   'e': "kde"
.   .   }
.   .   'e' [1,'a'] {
.   .   .   'a': "kea"
.   .   }
.   .   'h' [1,'q'] {
.   .   .   'q': "khq"
.   .   }
.   .   'i': "ki"
.   .   'k': "kk" [1,'j'] {
.   .   .   'j': "kkj"
.   .   }
.   .   'l': "kl" [1,'n'] {
.   .   .   'n': "kln"
.   .   }
.   .   'm': "km"
.   .   'n': "kn"
.   .   'o': "ko" [1,'k'] {
.   .   .   'k': "kok"
.   .   }
.   .   's' [3,'h'] {
.   .   .   'b': "ksb"
.   .   .   'f': "ksf"
.   .   .   'h': "ksh"
.   .   }
.   .   'w': "kw"
.   .   'y': "ky"
.   }
.   'l' [8,'v'] {
.   .   'a' [1,'g'] {
.   .   .   'g': "lag"
.   .   }
.   .   'g': "lg"
.   .   'k' [1,'t'] {
.   .   .   't': "lkt"
.   .   }
.   .   'n': "ln"
.   .   'o': "lo"
.   .   't': "lt"
.   .   'u': "lu" [2,'y'] {
.   .   .   'o': "luo"
.   .   .   'y': "luy"
.   .   }
.   .   'v': "lv"
.   }
.   'm' [12,'y'] {
.   .   'a' [1,'s'] {
.   .   .   's': "mas"
.   .   }
.   .   'e' [1,'r'] {
.   .   .   'r': "mer"
.   .   }
.   .   'f' [1,'e'] {
.   .   .   'e': "mfe"
.   .   }
.   .   'g': "mg" [2,'o'] {
.   .   .   'h': "mgh"
.   .   .   'o': "mgo"
.   .   }
.   .   'k': "mk"
.   .   'l': "ml"
.   .   'n': "mn"
.   .   'r': "mr"
.   .   's': "ms"
.   .   't': "mt"
.   .   'u' [1,'a'] {
.   .   .   'a': "mua"
.   .   }
.   .   'y': "my"
.   }
.   'n' [11,'y'] {
.   .   'a' [1,'q'] {
.   .   .   'q': "naq"
.   .   }
.   .   'b': "nb"
.   .   'd': "nd"
.   .   'e': "ne"
.   .   'l': "nl"
.   .   'm' [1,'g'] {
.   .   .   'g': "nmg"
.   .   }
.   .   'n': "nn" [1,'h'] {
.   .   .   'h': "nnh"
.   .   }
.   .   'r': "nr"
.   .   's' [1,'o'] {
.   .   .   'o': "nso"
.   .   }
.   .   'u' [1,'s'] {
.   .   .   's': "nus"
.   .   }
.   .   'y' [1,'n'] {
.   .   .   'n': "nyn"
.   .   }
.   }
.   'o' [3,'s'] {
.   .   'm': "om"
.   .   'r': "or"
.   .   's': "os"
.   }
.   'p' [4,'t'] {
.   .   'a': "pa" [1,'_'] {
.   .   .   '_' [1,'A'] {
.   .   .   .   'A' [1,'r'] {
.   .   .   .   .   'r' [1,'a'] {
.   .   .   .   .   .   'a' [1,'b'] {
.   .   .   .   .   .   .   'b': "pa_Arab"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'l': "pl"
.   .   's': "ps"
.   .   't': "pt"
.   }
.   'r' [5,'w'] {
.   .   'm': "rm"
.   .   'n': "rn"
.   .   'o': "ro" [1,'f'] {
.   .   .   'f': "rof"
.   .   }
.   .   'u': "ru"
.   .   'w': "rw" [1,'k'] {
.   .   .   'k': "rwk"
.   .   }
.   }
.   's' [16,'w'] {
.   .   'a' [2,'q'] {
.   .   .   'h': "sah"
.   .   .   'q': "saq"
.   .   }
.   .   'b' [1,'p'] {
.   .   .   'p': "sbp"
.   .   }
.   .   'e': "se" [2,'s'] {
.   .   .   'h': "seh"
.   .   .   's': "ses"
.   .   }
.   .   'g': "sg"
.   .   'h' [1,'i'] {
.   .   .   'i': "shi" [1,'_'] {
.   .   .   .   '_' [1,'L'] {
.   .   .   .   .   'L' [1,'a'] {
.   .   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   .   't' [1,'n'] {
.   .   .   .   .   .   .   .   'n': "shi_Latn"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'i': "si"
.   .   'k': "sk"
.   .   'l': "sl"
.   .   'n': "sn"
.   .   'o': "so"
.   .   'q': "sq"
.   .   'r': "sr" [1,'_'] {
.   .   .   '_' [1,'L'] {
.   .   .   .   'L' [1,'a'] {
.   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   't' [1,'n'] {
.   .   .   .   .   .   .   'n': "sr_Latn"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   's': "ss" [1,'y'] {
.   .   .   'y': "ssy"
.   .   }
.   .   't': "st"
.   .   'v': "sv"
.   .   'w': "sw" [1,'c'] {
.   .   .   'c': "swc"
.   .   }
.   }
.   't' [11,'z'] {
.   .   'a': "ta"
.   .   'e': "te" [1,'o'] {
.   .   .   'o': "teo"
.   .   }
.   .   'g': "tg"
.   .   'h': "th"
.   .   'i': "ti" [2,'g'] {
.   .   .   '_' [1,'E'] {
.   .   .   .   'E' [1,'R'] {
.   .   .   .   .   'R': "ti_ER"
.   .   .   .   }
.   .   .   }
.   .   .   'g': "tig"
.   .   }
.   .   'n': "tn"
.   .   'o': "to"
.   .   'r': "tr"
.   .   's': "ts"
.   .   'w' [1,'q'] {
.   .   .   'q': "twq"
.   .   }
.   .   'z' [1,'m'] {
.   .   .   'm': "tzm"
.   .   }
.   }
.   'u' [4,'z'] {
.   .   'g': "ug"
.   .   'k': "uk"
.   .   'r': "ur"
.   .   'z': "uz" [1,'_'] {
.   .   .   '_' [2,'C'] {
.   .   .   .   'A' [1,'r'] {
.   .   .   .   .   'r' [1,'a'] {
.   .   .   .   .   .   'a' [1,'b'] {
.   .   .   .   .   .   .   'b': "uz_Arab"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   'C' [1,'y'] {
.   .   .   .   .   'y' [1,'r'] {
.   .   .   .   .   .   'r' [1,'l'] {
.   .   .   .   .   .   .   'l': "uz_Cyrl"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'v' [5,'u'] {
.   .   'a' [1,'i'] {
.   .   .   'i' [1,'_'] {
.   .   .   .   '_' [1,'L'] {
.   .   .   .   .   'L' [1,'a'] {
.   .   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   .   't' [1,'n'] {
.   .   .   .   .   .   .   .   'n': "vai_Latn"
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'e': "ve"
.   .   'i': "vi"
.   .   'o': "vo"
.   .   'u' [1,'n'] {
.   .   .   'n': "vun"
.   .   }
.   }
.   'w' [1,'a'] {
.   .   'a' [2,'l'] {
.   .   .   'e': "wae"
.   .   .   'l': "wal"
.   .   }
.   }
.   'x' [2,'o'] {
.   .   'h': "xh"
.   .   'o' [1,'g'] {
.   .   .   'g': "xog"
.   .   }
.   }
.   'y' [2,'o'] {
.   .   'a' [1,'v'] {
.   .   .   'v': "yav"
.   .   }
.   .   'o': "yo" [1,'_'] {
.   .   .   '_' [1,'B'] {
.   .   .   .   'B' [1,'J'] {
.   .   .   .   .   'J': "yo_BJ"
.   .   .   .   }
.   .   .   }
.   .   }
.   }
.   'z' [3,'u'] {
.   .   'g' [1,'h'] {
.   .   .   'h': "zgh"
.   .   }
.   .   'h': "zh" [1,'_'] {
.   .   .   '_' [1,'H'] {
.   .   .   .   'H' [1,'a'] {
.   .   .   .   .   'a' [1,'n'] {
.   .   .   .   .   .   'n' [1,'t'] {
.   .   .   .   .   .   .   't': "zh_Hant"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   .   'u': "zu"
.   }
}
$

--[ gen-wide-trie-filenames-array ]---------------------------------------------

$ ../src/trie --attrs --dots --gen=wide --output=trie --trie=array < filenames.txt
[1,'c'] {
.   'c' [1,'+'] {
.   .   '+' [1,'+'] {
.   .   .   '+' [1,'p'] {
.   .   .   .   'p' [1,'y'] {
.   .   .   .   .   'y' [1,'-'] {
.   .   .   .   .   .   '-' [1,'t'] {
.   .   .   .   .   .   .   't' [1,'r'] {
.   .   .   .   .   .   .   .   'r' [1,'e'] {
.   .   .   .   .   .   .   .   .   'e' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   'e' [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   '-' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   'm' [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'o' [1,'/'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '/' [3,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [2,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/.src-dirs"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'l' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/.src-files"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'b' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'n' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'p'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'h': "c++py-tree-demo/bin.patch"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'+'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '+' [1,'+'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '+' [1,'p'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'y' [2,'/'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [2,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [3,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'u'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'u' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'h' [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'o' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree-author.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'm' [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'o' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree-demo.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'm' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [2,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f': "c++py-tree-demo/c++py-tree-readme.pdf"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [2,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x': "c++py-tree-demo/c++py-tree-readme.tex"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree-readme.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [2,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f': "c++py-tree-demo/c++py-tree.pdf"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [2,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x': "c++py-tree-demo/c++py-tree.tex"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '/' [4,'R'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [2,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/c++py/.src-dirs"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'l' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/c++py/.src-files"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'A' [1,'U'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'U' [1,'T'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'T' [1,'H'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'H' [1,'O'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'O' [1,'R'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'R': "c++py-tree-demo/c++py/AUTHOR"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'M' [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'k'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'k' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'l' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e': "c++py-tree-demo/c++py/Makefile"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'R' [1,'E'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'E' [1,'A'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'A' [1,'D'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'D' [1,'M'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'M' [1,'E'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'E': "c++py-tree-demo/c++py/README"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$

--[ gen-wide-trie-filenames-ternary ]-------------------------------------------

$ ../src/trie --attrs --dots --gen=wide --output=trie --trie=ternary < filenames.txt
[1,'c'] {
.   'c' [1,'+'] {
.   .   '+' [1,'+'] {
.   .   .   '+' [1,'p'] {
.   .   .   .   'p' [1,'y'] {
.   .   .   .   .   'y' [1,'-'] {
.   .   .   .   .   .   '-' [1,'t'] {
.   .   .   .   .   .   .   't' [1,'r'] {
.   .   .   .   .   .   .   .   'r' [1,'e'] {
.   .   .   .   .   .   .   .   .   'e' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   'e' [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   '-' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   'm' [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'o' [1,'/'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '/' [3,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [2,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/.src-dirs"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'l' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/.src-files"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'b' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'n'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'n' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'p'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'h': "c++py-tree-demo/bin.patch"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'+'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '+' [1,'+'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '+' [1,'p'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'y'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'y' [2,'/'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [2,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [3,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'u'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'u' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'h'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'h' [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'o' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree-author.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'm' [1,'o'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'o' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree-demo.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'m'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'm' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'.'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [2,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f': "c++py-tree-demo/c++py-tree-readme.pdf"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [2,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x': "c++py-tree-demo/c++py-tree-readme.tex"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree-readme.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [2,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'p' [1,'d'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f': "c++py-tree-demo/c++py-tree.pdf"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't' [2,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'x'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x': "c++py-tree-demo/c++py-tree.tex"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'x' [1,'t'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   't': "c++py-tree-demo/c++py-tree.txt"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '/' [4,'R'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '.' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'c'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'c' [1,'-'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   '-' [2,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'd' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'r'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'r' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/c++py/.src-dirs"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'l' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'s'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   's': "c++py-tree-demo/c++py/.src-files"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'A' [1,'U'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'U' [1,'T'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'T' [1,'H'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'H' [1,'O'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'O' [1,'R'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'R': "c++py-tree-demo/c++py/AUTHOR"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'M' [1,'a'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'a' [1,'k'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'k' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e' [1,'f'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'f' [1,'i'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'i' [1,'l'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'l' [1,'e'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'e': "c++py-tree-demo/c++py/Makefile"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'R' [1,'E'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'E' [1,'A'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'A' [1,'D'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'D' [1,'M'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'M' [1,'E'] {
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   'E': "c++py-tree-demo/c++py/README"
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   .   }
.   .   .   .   .   .   .   }
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   }
.   }
}
$

--[ gen-compact-trie-base0-array ]----------------------------------------------

$ trie() { ../src/trie --gen=compact --output=trie --trie=array "$@"; }
$ print a|trie
{
    "a": "a"
}
$ print a ab|trie
{
    "a": "a" {
        "b": "ab"
    }
}
$ print a ab abc|trie
{
    "a": "a" {
        "b": "ab" {
            "c": "abc"
        }
    }
}
$ print a b|trie
{
    "a": "a"
    "b": "b"
}
$ print a b abc bac abd|trie
{
    "a": "a" {
        "b" {
            "c": "abc"
            "d": "abd"
        }
    }
    "b": "b" {
        "ac": "bac"
    }
}
$ print a bb ba c|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "c": "c"
}
$ print a bb ba cc|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "cc": "cc"
}
$ print a bb ba ccc|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "ccc": "ccc"
}
$ print a bb ba cde|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "cde": "cde"
}
$ print a bb ba cdef|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "cdef": "cdef"
}
$ print a bb ba cdef cdefg|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "cdef": "cdef" {
        "g": "cdefg"
    }
}
$ print a bb bac cdef|trie
{
    "a": "a"
    "b" {
        "ac": "bac"
        "b": "bb"
    }
    "cdef": "cdef"
}
$ print a bbx ba ccc|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "bx": "bbx"
    }
    "ccc": "ccc"
}
$ print a bbx bay ccc|trie
{
    "a": "a"
    "b" {
        "ay": "bay"
        "bx": "bbx"
    }
    "ccc": "ccc"
}
$ print a cde cdef|trie
{
    "a": "a"
    "cde": "cde" {
        "f": "cdef"
    }
}
$ print a cde cdef cdefg|trie
{
    "a": "a"
    "cde": "cde" {
        "f": "cdef" {
            "g": "cdefg"
        }
    }
}
$ print a cde cdef cdefgh|trie
{
    "a": "a"
    "cde": "cde" {
        "f": "cdef" {
            "gh": "cdefgh"
        }
    }
}
$ print a cdef cdefg|trie
{
    "a": "a"
    "cdef": "cdef" {
        "g": "cdefg"
    }
}
$ print ab|trie
{
    "ab": "ab"
}
$ print ab bb ba ccc|trie
{
    "ab": "ab"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "ccc": "ccc"
}
$ print ab bb ba cde|trie
{
    "ab": "ab"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "cde": "cde"
}
$ print ab bbx ba ccc|trie
{
    "ab": "ab"
    "b" {
        "a": "ba"
        "bx": "bbx"
    }
    "ccc": "ccc"
}
$ print ab c|trie
{
    "ab": "ab"
    "c": "c"
}
$ print abc bb ba ccc|trie
{
    "abc": "abc"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "ccc": "ccc"
}
$ print abcd abde abef|trie
{
    "ab" {
        "cd": "abcd"
        "de": "abde"
        "ef": "abef"
    }
}
$ print abg a abc ab abd|trie
{
    "a": "a" {
        "b": "ab" {
            "c": "abc"
            "d": "abd"
            "g": "abg"
        }
    }
}
$ print ac ab|trie
{
    "a" {
        "b": "ab"
        "c": "ac"
    }
}
$ print aef ae abg a abc ab abd|trie
{
    "a": "a" {
        "b": "ab" {
            "c": "abc"
            "d": "abd"
            "g": "abg"
        }
        "e": "ae" {
            "f": "aef"
        }
    }
}
$ print cde cdef cdefgh|trie
{
    "cde": "cde" {
        "f": "cdef" {
            "gh": "cdefgh"
        }
    }
}
$ print cdef cdefg|trie
{
    "cdef": "cdef" {
        "g": "cdefg"
    }
}
$ print cdex cdfy cdgz cdhw|trie
{
    "cd" {
        "ex": "cdex"
        "fy": "cdfy"
        "gz": "cdgz"
        "hw": "cdhw"
    }
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    "c" {
        "d" {
            "ex": "cdex"
            "fy": "cdfy"
            "gz": "cdgz"
            "hw": "cdhw"
        }
        "e": "ce"
    }
}
$ print pot potato pottery tattoo tempo|trie
{
    "pot": "pot" {
        "ato": "potato"
        "tery": "pottery"
    }
    "t" {
        "attoo": "tattoo"
        "empo": "tempo"
    }
}
$

--[ gen-compact-trie-base0-ternary ]--------------------------------------------

$ trie() { ../src/trie --gen=compact --output=trie --trie=ternary "$@"; }
$ print a|trie
{
    "a": "a"
}
$ print a ab|trie
{
    "a": "a" {
        "b": "ab"
    }
}
$ print a ab abc|trie
{
    "a": "a" {
        "b": "ab" {
            "c": "abc"
        }
    }
}
$ print a b|trie
{
    "a": "a"
    "b": "b"
}
$ print a b abc bac abd|trie
{
    "a": "a" {
        "b" {
            "c": "abc"
            "d": "abd"
        }
    }
    "b": "b" {
        "ac": "bac"
    }
}
$ print a bb ba c|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "c": "c"
}
$ print a bb ba cc|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "cc": "cc"
}
$ print a bb ba ccc|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "ccc": "ccc"
}
$ print a bb ba cde|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "cde": "cde"
}
$ print a bb ba cdef|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "cdef": "cdef"
}
$ print a bb ba cdef cdefg|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "cdef": "cdef" {
        "g": "cdefg"
    }
}
$ print a bb bac cdef|trie
{
    "a": "a"
    "b" {
        "ac": "bac"
        "b": "bb"
    }
    "cdef": "cdef"
}
$ print a bbx ba ccc|trie
{
    "a": "a"
    "b" {
        "a": "ba"
        "bx": "bbx"
    }
    "ccc": "ccc"
}
$ print a bbx bay ccc|trie
{
    "a": "a"
    "b" {
        "ay": "bay"
        "bx": "bbx"
    }
    "ccc": "ccc"
}
$ print a cde cdef|trie
{
    "a": "a"
    "cde": "cde" {
        "f": "cdef"
    }
}
$ print a cde cdef cdefg|trie
{
    "a": "a"
    "cde": "cde" {
        "f": "cdef" {
            "g": "cdefg"
        }
    }
}
$ print a cde cdef cdefgh|trie
{
    "a": "a"
    "cde": "cde" {
        "f": "cdef" {
            "gh": "cdefgh"
        }
    }
}
$ print a cdef cdefg|trie
{
    "a": "a"
    "cdef": "cdef" {
        "g": "cdefg"
    }
}
$ print ab|trie
{
    "ab": "ab"
}
$ print ab bb ba ccc|trie
{
    "ab": "ab"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "ccc": "ccc"
}
$ print ab bb ba cde|trie
{
    "ab": "ab"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "cde": "cde"
}
$ print ab bbx ba ccc|trie
{
    "ab": "ab"
    "b" {
        "a": "ba"
        "bx": "bbx"
    }
    "ccc": "ccc"
}
$ print ab c|trie
{
    "ab": "ab"
    "c": "c"
}
$ print abc bb ba ccc|trie
{
    "abc": "abc"
    "b" {
        "a": "ba"
        "b": "bb"
    }
    "ccc": "ccc"
}
$ print abcd abde abef|trie
{
    "ab" {
        "cd": "abcd"
        "de": "abde"
        "ef": "abef"
    }
}
$ print abg a abc ab abd|trie
{
    "a": "a" {
        "b": "ab" {
            "c": "abc"
            "d": "abd"
            "g": "abg"
        }
    }
}
$ print ac ab|trie
{
    "a" {
        "b": "ab"
        "c": "ac"
    }
}
$ print aef ae abg a abc ab abd|trie
{
    "a": "a" {
        "b": "ab" {
            "c": "abc"
            "d": "abd"
            "g": "abg"
        }
        "e": "ae" {
            "f": "aef"
        }
    }
}
$ print cde cdef cdefgh|trie
{
    "cde": "cde" {
        "f": "cdef" {
            "gh": "cdefgh"
        }
    }
}
$ print cdef cdefg|trie
{
    "cdef": "cdef" {
        "g": "cdefg"
    }
}
$ print cdex cdfy cdgz cdhw|trie
{
    "cd" {
        "ex": "cdex"
        "fy": "cdfy"
        "gz": "cdgz"
        "hw": "cdhw"
    }
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    "c" {
        "d" {
            "ex": "cdex"
            "fy": "cdfy"
            "gz": "cdgz"
            "hw": "cdhw"
        }
        "e": "ce"
    }
}
$ print pot potato pottery tattoo tempo|trie
{
    "pot": "pot" {
        "ato": "potato"
        "tery": "pottery"
    }
    "t" {
        "attoo": "tattoo"
        "empo": "tempo"
    }
}
$

--[ gen-compact-trie-base ]-----------------------------------------------------

$ trie() { ../src/trie --gen=compact --output=trie --attrs --no-dots "$@"; }
$ print a ab abc abd ac|trie
[1,'a'] {
    "a" [0,"",'a',[2,'c']]: "a" {
        "b" [0,"",'b',[2,'d']]: "ab" {
            "c" [0,"",'c',[0]]: "abc"
            "d" [0,"",'d',[0]]: "abd"
        }
        "c" [0,"",'c',[0]]: "ac"
    }
}
$ print a ab abc abd ac|trie -t int
[1,'a'] {
    "a" [0,"",'a',[2,'c']]: 1 {
        "b" [0,"",'b',[2,'d']]: 2 {
            "c" [0,"",'c',[0]]: 3
            "d" [0,"",'d',[0]]: 4
        }
        "c" [0,"",'c',[0]]: 5
    }
}
$ print a ab abc abd ac|trie -t float
[1,'a'] {
    "a" [0,"",'a',[2,'c']]: 1.0 {
        "b" [0,"",'b',[2,'d']]: 2.0 {
            "c" [0,"",'c',[0]]: 3.0
            "d" [0,"",'d',[0]]: 4.0
        }
        "c" [0,"",'c',[0]]: 5.0
    }
}
$

--[ gen-compact-trie-base-array ]-----------------------------------------------

$ trie() { ../src/trie --gen=compact --output=trie --attrs --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
[1,'a'] {
.   "a" [0,"",'a',[0]]: "a"
}
$ print a b|trie
[2,'b'] {
.   "a" [0,"",'a',[0]]: "a"
.   "b" [0,"",'b',[0]]: "b"
}
$ print a b c|trie
[3,'c'] {
.   "a" [0,"",'a',[0]]: "a"
.   "b" [0,"",'b',[0]]: "b"
.   "c" [0,"",'c',[0]]: "c"
}
$ print a ab abc|trie
[1,'a'] {
.   "a" [0,"",'a',[1,'b']]: "a" {
.   .   "b" [0,"",'b',[1,'c']]: "ab" {
.   .   .   "c" [0,"",'c',[0]]: "abc"
.   .   }
.   }
}
$ print a ab ac|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']]: "a" {
.   .   "b" [0,"",'b',[0]]: "ab"
.   .   "c" [0,"",'c',[0]]: "ac"
.   }
}
$ print a ab ac ad|trie
[1,'a'] {
.   "a" [0,"",'a',[3,'d']]: "a" {
.   .   "b" [0,"",'b',[0]]: "ab"
.   .   "c" [0,"",'c',[0]]: "ac"
.   .   "d" [0,"",'d',[0]]: "ad"
.   }
}
$ print a abd ac|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']]: "a" {
.   .   "bd" [0,"b",'d',[0]]: "abd"
.   .   "c" [0,"",'c',[0]]: "ac"
.   }
}
$ print a ab ac acd|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']]: "a" {
.   .   "b" [0,"",'b',[0]]: "ab"
.   .   "c" [0,"",'c',[1,'d']]: "ac" {
.   .   .   "d" [0,"",'d',[0]]: "acd"
.   .   }
.   }
}
$ print a bb ba ccc|trie
[3,'c'] {
.   "a" [0,"",'a',[0]]: "a"
.   "b" [0,"",'b',[2,'b']] {
.   .   "a" [0,"",'a',[0]]: "ba"
.   .   "b" [0,"",'b',[0]]: "bb"
.   }
.   "ccc" [0,"cc",'c',[0]]: "ccc"
}
$ print a bb ccc|trie
[3,'c'] {
.   "a" [0,"",'a',[0]]: "a"
.   "bb" [0,"b",'b',[0]]: "bb"
.   "ccc" [0,"cc",'c',[0]]: "ccc"
}
$ print a bb ba ccc|trie
[3,'c'] {
.   "a" [0,"",'a',[0]]: "a"
.   "b" [0,"",'b',[2,'b']] {
.   .   "a" [0,"",'a',[0]]: "ba"
.   .   "b" [0,"",'b',[0]]: "bb"
.   }
.   "ccc" [0,"cc",'c',[0]]: "ccc"
}
$ print abc abd acde|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']] {
.   .   "b" [0,"",'b',[2,'d']] {
.   .   .   "c" [0,"",'c',[0]]: "abc"
.   .   .   "d" [0,"",'d',[0]]: "abd"
.   .   }
.   .   "cde" [0,"cd",'e',[0]]: "acde"
.   }
}
$ print abc abd acde ac|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']] {
.   .   "b" [0,"",'b',[2,'d']] {
.   .   .   "c" [0,"",'c',[0]]: "abc"
.   .   .   "d" [0,"",'d',[0]]: "abd"
.   .   }
.   .   "c" [0,"",'c',[1,'d']]: "ac" {
.   .   .   "de" [0,"d",'e',[0]]: "acde"
.   .   }
.   }
}
$ print abc abd acde acfg|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']] {
.   .   "b" [0,"",'b',[2,'d']] {
.   .   .   "c" [0,"",'c',[0]]: "abc"
.   .   .   "d" [0,"",'d',[0]]: "abd"
.   .   }
.   .   "c" [0,"",'c',[2,'f']] {
.   .   .   "de" [0,"d",'e',[0]]: "acde"
.   .   .   "fg" [0,"f",'g',[0]]: "acfg"
.   .   }
.   }
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c'] {
.   "c" [0,"",'c',[2,'f']] {
.   .   "de" [0,"d",'e',[0]]: "cde"
.   .   "fg" [0,"f",'g',[1,'x']]: "cfg" {
.   .   .   "x" [1,"f",'x',[2,'z']]: "cfgx" {
.   .   .   .   "y" [1,"f",'y',[1,'z']]: "cfgxy" {
.   .   .   .   .   "z" [1,"f",'z',[0]]: "cfgxyz"
.   .   .   .   }
.   .   .   .   "zzz" [1,"fzz",'z',[0]]: "cfgxzzz"
.   .   .   }
.   .   }
.   }
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c'] {
.   "c" [0,"",'c',[2,'g']] {
.   .   "fg" [0,"f",'g',[1,'x']]: "cfg" {
.   .   .   "x" [1,"f",'x',[2,'z']]: "cfgx" {
.   .   .   .   "y" [1,"f",'y',[1,'z']]: "cfgxy" {
.   .   .   .   .   "z" [1,"f",'z',[0]]: "cfgxyz"
.   .   .   .   }
.   .   .   .   "zzz" [1,"fzz",'z',[0]]: "cfgxzzz"
.   .   .   }
.   .   }
.   .   "ge" [0,"g",'e',[0]]: "cge"
.   }
}
$ print a abcd abcdefg h hijk|trie
[2,'h'] {
.   "a" [0,"",'a',[1,'b']]: "a" {
.   .   "bcd" [0,"bc",'d',[1,'e']]: "abcd" {
.   .   .   "efg" [2,"bcef",'g',[0]]: "abcdefg"
.   .   }
.   }
.   "h" [0,"",'h',[1,'i']]: "h" {
.   .   "ijk" [0,"ij",'k',[0]]: "hijk"
.   }
}
$ print a abcd abcdefg abcdxyz h hijk|trie
[2,'h'] {
.   "a" [0,"",'a',[1,'b']]: "a" {
.   .   "bcd" [0,"bc",'d',[2,'x']]: "abcd" {
.   .   .   "efg" [2,"bcef",'g',[0]]: "abcdefg"
.   .   .   "xyz" [2,"bcxy",'z',[0]]: "abcdxyz"
.   .   }
.   }
.   "h" [0,"",'h',[1,'i']]: "h" {
.   .   "ijk" [0,"ij",'k',[0]]: "hijk"
.   }
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
[2,'h'] {
.   "a" [0,"",'a',[1,'b']]: "a" {
.   .   "bcd" [0,"bc",'d',[2,'x']]: "abcd" {
.   .   .   "efg" [2,"bcef",'g',[0]]: "abcdefg"
.   .   .   "xyz" [2,"bcxy",'z',[0]]: "abcdxyz"
.   .   }
.   }
.   "h" [0,"",'h',[2,'l']]: "h" {
.   .   "ijk" [0,"ij",'k',[0]]: "hijk"
.   .   "lm" [0,"l",'m',[0]]: "hlm"
.   }
}
$

--[ gen-compact-trie-base-ternary ]---------------------------------------------

$ trie() { ../src/trie --gen=compact --output=trie --attrs --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
[1,'a'] {
.   "a" [0,"",'a',[0]]: "a"
}
$ print a b|trie
[2,'b'] {
.   "a" [0,"",'a',[0]]: "a"
.   "b" [0,"",'b',[0]]: "b"
}
$ print a b c|trie
[3,'c'] {
.   "a" [0,"",'a',[0]]: "a"
.   "b" [0,"",'b',[0]]: "b"
.   "c" [0,"",'c',[0]]: "c"
}
$ print a ab abc|trie
[1,'a'] {
.   "a" [0,"",'a',[1,'b']]: "a" {
.   .   "b" [0,"",'b',[1,'c']]: "ab" {
.   .   .   "c" [0,"",'c',[0]]: "abc"
.   .   }
.   }
}
$ print a ab ac|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']]: "a" {
.   .   "b" [0,"",'b',[0]]: "ab"
.   .   "c" [0,"",'c',[0]]: "ac"
.   }
}
$ print a ab ac ad|trie
[1,'a'] {
.   "a" [0,"",'a',[3,'d']]: "a" {
.   .   "b" [0,"",'b',[0]]: "ab"
.   .   "c" [0,"",'c',[0]]: "ac"
.   .   "d" [0,"",'d',[0]]: "ad"
.   }
}
$ print a abd ac|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']]: "a" {
.   .   "bd" [0,"b",'d',[0]]: "abd"
.   .   "c" [0,"",'c',[0]]: "ac"
.   }
}
$ print a ab ac acd|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']]: "a" {
.   .   "b" [0,"",'b',[0]]: "ab"
.   .   "c" [0,"",'c',[1,'d']]: "ac" {
.   .   .   "d" [0,"",'d',[0]]: "acd"
.   .   }
.   }
}
$ print a bb ba ccc|trie
[3,'c'] {
.   "a" [0,"",'a',[0]]: "a"
.   "b" [0,"",'b',[2,'b']] {
.   .   "a" [0,"",'a',[0]]: "ba"
.   .   "b" [0,"",'b',[0]]: "bb"
.   }
.   "ccc" [0,"cc",'c',[0]]: "ccc"
}
$ print a bb ccc|trie
[3,'c'] {
.   "a" [0,"",'a',[0]]: "a"
.   "bb" [0,"b",'b',[0]]: "bb"
.   "ccc" [0,"cc",'c',[0]]: "ccc"
}
$ print a bb ba ccc|trie
[3,'c'] {
.   "a" [0,"",'a',[0]]: "a"
.   "b" [0,"",'b',[2,'b']] {
.   .   "a" [0,"",'a',[0]]: "ba"
.   .   "b" [0,"",'b',[0]]: "bb"
.   }
.   "ccc" [0,"cc",'c',[0]]: "ccc"
}
$ print abc abd acde|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']] {
.   .   "b" [0,"",'b',[2,'d']] {
.   .   .   "c" [0,"",'c',[0]]: "abc"
.   .   .   "d" [0,"",'d',[0]]: "abd"
.   .   }
.   .   "cde" [0,"cd",'e',[0]]: "acde"
.   }
}
$ print abc abd acde ac|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']] {
.   .   "b" [0,"",'b',[2,'d']] {
.   .   .   "c" [0,"",'c',[0]]: "abc"
.   .   .   "d" [0,"",'d',[0]]: "abd"
.   .   }
.   .   "c" [0,"",'c',[1,'d']]: "ac" {
.   .   .   "de" [0,"d",'e',[0]]: "acde"
.   .   }
.   }
}
$ print abc abd acde acfg|trie
[1,'a'] {
.   "a" [0,"",'a',[2,'c']] {
.   .   "b" [0,"",'b',[2,'d']] {
.   .   .   "c" [0,"",'c',[0]]: "abc"
.   .   .   "d" [0,"",'d',[0]]: "abd"
.   .   }
.   .   "c" [0,"",'c',[2,'f']] {
.   .   .   "de" [0,"d",'e',[0]]: "acde"
.   .   .   "fg" [0,"f",'g',[0]]: "acfg"
.   .   }
.   }
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c'] {
.   "c" [0,"",'c',[2,'f']] {
.   .   "de" [0,"d",'e',[0]]: "cde"
.   .   "fg" [0,"f",'g',[1,'x']]: "cfg" {
.   .   .   "x" [1,"f",'x',[2,'z']]: "cfgx" {
.   .   .   .   "y" [1,"f",'y',[1,'z']]: "cfgxy" {
.   .   .   .   .   "z" [1,"f",'z',[0]]: "cfgxyz"
.   .   .   .   }
.   .   .   .   "zzz" [1,"fzz",'z',[0]]: "cfgxzzz"
.   .   .   }
.   .   }
.   }
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
[1,'c'] {
.   "c" [0,"",'c',[2,'g']] {
.   .   "fg" [0,"f",'g',[1,'x']]: "cfg" {
.   .   .   "x" [1,"f",'x',[2,'z']]: "cfgx" {
.   .   .   .   "y" [1,"f",'y',[1,'z']]: "cfgxy" {
.   .   .   .   .   "z" [1,"f",'z',[0]]: "cfgxyz"
.   .   .   .   }
.   .   .   .   "zzz" [1,"fzz",'z',[0]]: "cfgxzzz"
.   .   .   }
.   .   }
.   .   "ge" [0,"g",'e',[0]]: "cge"
.   }
}
$ print a abcd abcdefg h hijk|trie
[2,'h'] {
.   "a" [0,"",'a',[1,'b']]: "a" {
.   .   "bcd" [0,"bc",'d',[1,'e']]: "abcd" {
.   .   .   "efg" [2,"bcef",'g',[0]]: "abcdefg"
.   .   }
.   }
.   "h" [0,"",'h',[1,'i']]: "h" {
.   .   "ijk" [0,"ij",'k',[0]]: "hijk"
.   }
}
$ print a abcd abcdefg abcdxyz h hijk|trie
[2,'h'] {
.   "a" [0,"",'a',[1,'b']]: "a" {
.   .   "bcd" [0,"bc",'d',[2,'x']]: "abcd" {
.   .   .   "efg" [2,"bcef",'g',[0]]: "abcdefg"
.   .   .   "xyz" [2,"bcxy",'z',[0]]: "abcdxyz"
.   .   }
.   }
.   "h" [0,"",'h',[1,'i']]: "h" {
.   .   "ijk" [0,"ij",'k',[0]]: "hijk"
.   }
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
[2,'h'] {
.   "a" [0,"",'a',[1,'b']]: "a" {
.   .   "bcd" [0,"bc",'d',[2,'x']]: "abcd" {
.   .   .   "efg" [2,"bcef",'g',[0]]: "abcdefg"
.   .   .   "xyz" [2,"bcxy",'z',[0]]: "abcdxyz"
.   .   }
.   }
.   "h" [0,"",'h',[2,'l']]: "h" {
.   .   "ijk" [0,"ij",'k',[0]]: "hijk"
.   .   "lm" [0,"l",'m',[0]]: "hlm"
.   }
}
$

--[ gen-compact-trie-alphabets-array ]------------------------------------------

$ ../src/trie --attrs --dots --gen=compact --output=trie --trie=array < alphabets.txt
[25,'z'] {
.   "a" [0,"",'a',[8,'z']] {
.   .   "a" [0,"",'a',[0]]: "aa"
.   .   "f" [0,"",'f',[0]]: "af"
.   .   "gq" [0,"g",'q',[0]]: "agq"
.   .   "k" [0,"",'k',[0]]: "ak"
.   .   "m" [0,"",'m',[0]]: "am"
.   .   "r" [0,"",'r',[0]]: "ar"
.   .   "s" [0,"",'s',[2,'t']]: "as" {
.   .   .   "a" [0,"",'a',[0]]: "asa"
.   .   .   "t" [0,"",'t',[0]]: "ast"
.   .   }
.   .   "z" [0,"",'z',[1,'_']]: "az" {
.   .   .   "_Cyrl" [0,"_Cyr",'l',[0]]: "az_Cyrl"
.   .   }
.   }
.   "b" [0,"",'b',[9,'y']] {
.   .   "as" [0,"a",'s',[0]]: "bas"
.   .   "e" [0,"",'e',[2,'z']]: "be" {
.   .   .   "m" [0,"",'m',[0]]: "bem"
.   .   .   "z" [0,"",'z',[0]]: "bez"
.   .   }
.   .   "g" [0,"",'g',[0]]: "bg"
.   .   "m" [0,"",'m',[0]]: "bm"
.   .   "n" [0,"",'n',[0]]: "bn"
.   .   "o" [0,"",'o',[0]]: "bo"
.   .   "r" [0,"",'r',[1,'x']]: "br" {
.   .   .   "x" [0,"",'x',[0]]: "brx"
.   .   }
.   .   "s" [0,"",'s',[1,'_']]: "bs" {
.   .   .   "_Cyrl" [0,"_Cyr",'l',[0]]: "bs_Cyrl"
.   .   }
.   .   "yn" [0,"y",'n',[0]]: "byn"
.   }
.   "c" [0,"",'c',[5,'y']] {
.   .   "a" [0,"",'a',[0]]: "ca"
.   .   "gg" [0,"g",'g',[0]]: "cgg"
.   .   "hr" [0,"h",'r',[0]]: "chr"
.   .   "s" [0,"",'s',[0]]: "cs"
.   .   "y" [0,"",'y',[0]]: "cy"
.   }
.   "d" [0,"",'d',[6,'z']] {
.   .   "a" [0,"",'a',[1,'v']]: "da" {
.   .   .   "v" [0,"",'v',[0]]: "dav"
.   .   }
.   .   "e" [0,"",'e',[0]]: "de"
.   .   "je" [0,"j",'e',[0]]: "dje"
.   .   "ua" [0,"u",'a',[0]]: "dua"
.   .   "yo" [0,"y",'o',[0]]: "dyo"
.   .   "z" [0,"",'z',[0]]: "dz"
.   }
.   "e" [0,"",'e',[9,'w']] {
.   .   "bu" [0,"b",'u',[0]]: "ebu"
.   .   "e" [0,"",'e',[0]]: "ee"
.   .   "l" [0,"",'l',[0]]: "el"
.   .   "n" [0,"",'n',[0]]: "en"
.   .   "o" [0,"",'o',[0]]: "eo"
.   .   "s" [0,"",'s',[0]]: "es"
.   .   "t" [0,"",'t',[0]]: "et"
.   .   "u" [0,"",'u',[0]]: "eu"
.   .   "wo" [0,"w",'o',[0]]: "ewo"
.   }
.   "f" [0,"",'f',[7,'y']] {
.   .   "a" [0,"",'a',[0]]: "fa"
.   .   "f" [0,"",'f',[0]]: "ff"
.   .   "i" [0,"",'i',[1,'l']]: "fi" {
.   .   .   "l" [0,"",'l',[0]]: "fil"
.   .   }
.   .   "o" [0,"",'o',[0]]: "fo"
.   .   "r" [0,"",'r',[0]]: "fr"
.   .   "ur" [0,"u",'r',[0]]: "fur"
.   .   "y" [0,"",'y',[0]]: "fy"
.   }
.   "g" [0,"",'g',[6,'v']] {
.   .   "a" [0,"",'a',[0]]: "ga"
.   .   "d" [0,"",'d',[0]]: "gd"
.   .   "l" [0,"",'l',[0]]: "gl"
.   .   "sw" [0,"s",'w',[0]]: "gsw"
.   .   "u" [0,"",'u',[1,'z']]: "gu" {
.   .   .   "z" [0,"",'z',[0]]: "guz"
.   .   }
.   .   "v" [0,"",'v',[0]]: "gv"
.   }
.   "h" [0,"",'h',[6,'y']] {
.   .   "a" [0,"",'a',[1,'w']]: "ha" {
.   .   .   "w" [0,"",'w',[0]]: "haw"
.   .   }
.   .   "e" [0,"",'e',[0]]: "he"
.   .   "i" [0,"",'i',[0]]: "hi"
.   .   "r" [0,"",'r',[0]]: "hr"
.   .   "u" [0,"",'u',[0]]: "hu"
.   .   "y" [0,"",'y',[0]]: "hy"
.   }
.   "i" [0,"",'i',[6,'t']] {
.   .   "a" [0,"",'a',[0]]: "ia"
.   .   "d" [0,"",'d',[0]]: "id"
.   .   "g" [0,"",'g',[0]]: "ig"
.   .   "i" [0,"",'i',[0]]: "ii"
.   .   "s" [0,"",'s',[0]]: "is"
.   .   "t" [0,"",'t',[0]]: "it"
.   }
.   "j" [0,"",'j',[3,'m']] {
.   .   "a" [0,"",'a',[0]]: "ja"
.   .   "go" [0,"g",'o',[0]]: "jgo"
.   .   "mc" [0,"m",'c',[0]]: "jmc"
.   }
.   "k" [0,"",'k',[13,'y']] {
.   .   "a" [0,"",'a',[2,'m']]: "ka" {
.   .   .   "b" [0,"",'b',[0]]: "kab"
.   .   .   "m" [0,"",'m',[0]]: "kam"
.   .   }
.   .   "de" [0,"d",'e',[0]]: "kde"
.   .   "ea" [0,"e",'a',[0]]: "kea"
.   .   "hq" [0,"h",'q',[0]]: "khq"
.   .   "i" [0,"",'i',[0]]: "ki"
.   .   "k" [0,"",'k',[1,'j']]: "kk" {
.   .   .   "j" [0,"",'j',[0]]: "kkj"
.   .   }
.   .   "l" [0,"",'l',[1,'n']]: "kl" {
.   .   .   "n" [0,"",'n',[0]]: "kln"
.   .   }
.   .   "m" [0,"",'m',[0]]: "km"
.   .   "n" [0,"",'n',[0]]: "kn"
.   .   "o" [0,"",'o',[1,'k']]: "ko" {
.   .   .   "k" [0,"",'k',[0]]: "kok"
.   .   }
.   .   "s" [0,"",'s',[3,'h']] {
.   .   .   "b" [0,"",'b',[0]]: "ksb"
.   .   .   "f" [0,"",'f',[0]]: "ksf"
.   .   .   "h" [0,"",'h',[0]]: "ksh"
.   .   }
.   .   "w" [0,"",'w',[0]]: "kw"
.   .   "y" [0,"",'y',[0]]: "ky"
.   }
.   "l" [0,"",'l',[8,'v']] {
.   .   "ag" [0,"a",'g',[0]]: "lag"
.   .   "g" [0,"",'g',[0]]: "lg"
.   .   "kt" [0,"k",'t',[0]]: "lkt"
.   .   "n" [0,"",'n',[0]]: "ln"
.   .   "o" [0,"",'o',[0]]: "lo"
.   .   "t" [0,"",'t',[0]]: "lt"
.   .   "u" [0,"",'u',[2,'y']]: "lu" {
.   .   .   "o" [0,"",'o',[0]]: "luo"
.   .   .   "y" [0,"",'y',[0]]: "luy"
.   .   }
.   .   "v" [0,"",'v',[0]]: "lv"
.   }
.   "m" [0,"",'m',[12,'y']] {
.   .   "as" [0,"a",'s',[0]]: "mas"
.   .   "er" [0,"e",'r',[0]]: "mer"
.   .   "fe" [0,"f",'e',[0]]: "mfe"
.   .   "g" [0,"",'g',[2,'o']]: "mg" {
.   .   .   "h" [0,"",'h',[0]]: "mgh"
.   .   .   "o" [0,"",'o',[0]]: "mgo"
.   .   }
.   .   "k" [0,"",'k',[0]]: "mk"
.   .   "l" [0,"",'l',[0]]: "ml"
.   .   "n" [0,"",'n',[0]]: "mn"
.   .   "r" [0,"",'r',[0]]: "mr"
.   .   "s" [0,"",'s',[0]]: "ms"
.   .   "t" [0,"",'t',[0]]: "mt"
.   .   "ua" [0,"u",'a',[0]]: "mua"
.   .   "y" [0,"",'y',[0]]: "my"
.   }
.   "n" [0,"",'n',[11,'y']] {
.   .   "aq" [0,"a",'q',[0]]: "naq"
.   .   "b" [0,"",'b',[0]]: "nb"
.   .   "d" [0,"",'d',[0]]: "nd"
.   .   "e" [0,"",'e',[0]]: "ne"
.   .   "l" [0,"",'l',[0]]: "nl"
.   .   "mg" [0,"m",'g',[0]]: "nmg"
.   .   "n" [0,"",'n',[1,'h']]: "nn" {
.   .   .   "h" [0,"",'h',[0]]: "nnh"
.   .   }
.   .   "r" [0,"",'r',[0]]: "nr"
.   .   "so" [0,"s",'o',[0]]: "nso"
.   .   "us" [0,"u",'s',[0]]: "nus"
.   .   "yn" [0,"y",'n',[0]]: "nyn"
.   }
.   "o" [0,"",'o',[3,'s']] {
.   .   "m" [0,"",'m',[0]]: "om"
.   .   "r" [0,"",'r',[0]]: "or"
.   .   "s" [0,"",'s',[0]]: "os"
.   }
.   "p" [0,"",'p',[4,'t']] {
.   .   "a" [0,"",'a',[1,'_']]: "pa" {
.   .   .   "_Arab" [0,"_Ara",'b',[0]]: "pa_Arab"
.   .   }
.   .   "l" [0,"",'l',[0]]: "pl"
.   .   "s" [0,"",'s',[0]]: "ps"
.   .   "t" [0,"",'t',[0]]: "pt"
.   }
.   "r" [0,"",'r',[5,'w']] {
.   .   "m" [0,"",'m',[0]]: "rm"
.   .   "n" [0,"",'n',[0]]: "rn"
.   .   "o" [0,"",'o',[1,'f']]: "ro" {
.   .   .   "f" [0,"",'f',[0]]: "rof"
.   .   }
.   .   "u" [0,"",'u',[0]]: "ru"
.   .   "w" [0,"",'w',[1,'k']]: "rw" {
.   .   .   "k" [0,"",'k',[0]]: "rwk"
.   .   }
.   }
.   "s" [0,"",'s',[16,'w']] {
.   .   "a" [0,"",'a',[2,'q']] {
.   .   .   "h" [0,"",'h',[0]]: "sah"
.   .   .   "q" [0,"",'q',[0]]: "saq"
.   .   }
.   .   "bp" [0,"b",'p',[0]]: "sbp"
.   .   "e" [0,"",'e',[2,'s']]: "se" {
.   .   .   "h" [0,"",'h',[0]]: "seh"
.   .   .   "s" [0,"",'s',[0]]: "ses"
.   .   }
.   .   "g" [0,"",'g',[0]]: "sg"
.   .   "hi" [0,"h",'i',[1,'_']]: "shi" {
.   .   .   "_Latn" [1,"h_Lat",'n',[0]]: "shi_Latn"
.   .   }
.   .   "i" [0,"",'i',[0]]: "si"
.   .   "k" [0,"",'k',[0]]: "sk"
.   .   "l" [0,"",'l',[0]]: "sl"
.   .   "n" [0,"",'n',[0]]: "sn"
.   .   "o" [0,"",'o',[0]]: "so"
.   .   "q" [0,"",'q',[0]]: "sq"
.   .   "r" [0,"",'r',[1,'_']]: "sr" {
.   .   .   "_Latn" [0,"_Lat",'n',[0]]: "sr_Latn"
.   .   }
.   .   "s" [0,"",'s',[1,'y']]: "ss" {
.   .   .   "y" [0,"",'y',[0]]: "ssy"
.   .   }
.   .   "t" [0,"",'t',[0]]: "st"
.   .   "v" [0,"",'v',[0]]: "sv"
.   .   "w" [0,"",'w',[1,'c']]: "sw" {
.   .   .   "c" [0,"",'c',[0]]: "swc"
.   .   }
.   }
.   "t" [0,"",'t',[11,'z']] {
.   .   "a" [0,"",'a',[0]]: "ta"
.   .   "e" [0,"",'e',[1,'o']]: "te" {
.   .   .   "o" [0,"",'o',[0]]: "teo"
.   .   }
.   .   "g" [0,"",'g',[0]]: "tg"
.   .   "h" [0,"",'h',[0]]: "th"
.   .   "i" [0,"",'i',[2,'g']]: "ti" {
.   .   .   "_ER" [0,"_E",'R',[0]]: "ti_ER"
.   .   .   "g" [0,"",'g',[0]]: "tig"
.   .   }
.   .   "n" [0,"",'n',[0]]: "tn"
.   .   "o" [0,"",'o',[0]]: "to"
.   .   "r" [0,"",'r',[0]]: "tr"
.   .   "s" [0,"",'s',[0]]: "ts"
.   .   "wq" [0,"w",'q',[0]]: "twq"
.   .   "zm" [0,"z",'m',[0]]: "tzm"
.   }
.   "u" [0,"",'u',[4,'z']] {
.   .   "g" [0,"",'g',[0]]: "ug"
.   .   "k" [0,"",'k',[0]]: "uk"
.   .   "r" [0,"",'r',[0]]: "ur"
.   .   "z" [0,"",'z',[1,'_']]: "uz" {
.   .   .   "_" [0,"",'_',[2,'C']] {
.   .   .   .   "Arab" [0,"Ara",'b',[0]]: "uz_Arab"
.   .   .   .   "Cyrl" [0,"Cyr",'l',[0]]: "uz_Cyrl"
.   .   .   }
.   .   }
.   }
.   "v" [0,"",'v',[5,'u']] {
.   .   "ai_Latn" [0,"ai_Lat",'n',[0]]: "vai_Latn"
.   .   "e" [0,"",'e',[0]]: "ve"
.   .   "i" [0,"",'i',[0]]: "vi"
.   .   "o" [0,"",'o',[0]]: "vo"
.   .   "un" [0,"u",'n',[0]]: "vun"
.   }
.   "wa" [0,"w",'a',[2,'l']] {
.   .   "e" [1,"w",'e',[0]]: "wae"
.   .   "l" [1,"w",'l',[0]]: "wal"
.   }
.   "x" [0,"",'x',[2,'o']] {
.   .   "h" [0,"",'h',[0]]: "xh"
.   .   "og" [0,"o",'g',[0]]: "xog"
.   }
.   "y" [0,"",'y',[2,'o']] {
.   .   "av" [0,"a",'v',[0]]: "yav"
.   .   "o" [0,"",'o',[1,'_']]: "yo" {
.   .   .   "_BJ" [0,"_B",'J',[0]]: "yo_BJ"
.   .   }
.   }
.   "z" [0,"",'z',[3,'u']] {
.   .   "gh" [0,"g",'h',[0]]: "zgh"
.   .   "h" [0,"",'h',[1,'_']]: "zh" {
.   .   .   "_Hant" [0,"_Han",'t',[0]]: "zh_Hant"
.   .   }
.   .   "u" [0,"",'u',[0]]: "zu"
.   }
}
$

--[ gen-compact-trie-alphabets-ternary ]----------------------------------------

$ ../src/trie --attrs --dots --gen=compact --output=trie --trie=ternary < alphabets.txt
[25,'z'] {
.   "a" [0,"",'a',[8,'z']] {
.   .   "a" [0,"",'a',[0]]: "aa"
.   .   "f" [0,"",'f',[0]]: "af"
.   .   "gq" [0,"g",'q',[0]]: "agq"
.   .   "k" [0,"",'k',[0]]: "ak"
.   .   "m" [0,"",'m',[0]]: "am"
.   .   "r" [0,"",'r',[0]]: "ar"
.   .   "s" [0,"",'s',[2,'t']]: "as" {
.   .   .   "a" [0,"",'a',[0]]: "asa"
.   .   .   "t" [0,"",'t',[0]]: "ast"
.   .   }
.   .   "z" [0,"",'z',[1,'_']]: "az" {
.   .   .   "_Cyrl" [0,"_Cyr",'l',[0]]: "az_Cyrl"
.   .   }
.   }
.   "b" [0,"",'b',[9,'y']] {
.   .   "as" [0,"a",'s',[0]]: "bas"
.   .   "e" [0,"",'e',[2,'z']]: "be" {
.   .   .   "m" [0,"",'m',[0]]: "bem"
.   .   .   "z" [0,"",'z',[0]]: "bez"
.   .   }
.   .   "g" [0,"",'g',[0]]: "bg"
.   .   "m" [0,"",'m',[0]]: "bm"
.   .   "n" [0,"",'n',[0]]: "bn"
.   .   "o" [0,"",'o',[0]]: "bo"
.   .   "r" [0,"",'r',[1,'x']]: "br" {
.   .   .   "x" [0,"",'x',[0]]: "brx"
.   .   }
.   .   "s" [0,"",'s',[1,'_']]: "bs" {
.   .   .   "_Cyrl" [0,"_Cyr",'l',[0]]: "bs_Cyrl"
.   .   }
.   .   "yn" [0,"y",'n',[0]]: "byn"
.   }
.   "c" [0,"",'c',[5,'y']] {
.   .   "a" [0,"",'a',[0]]: "ca"
.   .   "gg" [0,"g",'g',[0]]: "cgg"
.   .   "hr" [0,"h",'r',[0]]: "chr"
.   .   "s" [0,"",'s',[0]]: "cs"
.   .   "y" [0,"",'y',[0]]: "cy"
.   }
.   "d" [0,"",'d',[6,'z']] {
.   .   "a" [0,"",'a',[1,'v']]: "da" {
.   .   .   "v" [0,"",'v',[0]]: "dav"
.   .   }
.   .   "e" [0,"",'e',[0]]: "de"
.   .   "je" [0,"j",'e',[0]]: "dje"
.   .   "ua" [0,"u",'a',[0]]: "dua"
.   .   "yo" [0,"y",'o',[0]]: "dyo"
.   .   "z" [0,"",'z',[0]]: "dz"
.   }
.   "e" [0,"",'e',[9,'w']] {
.   .   "bu" [0,"b",'u',[0]]: "ebu"
.   .   "e" [0,"",'e',[0]]: "ee"
.   .   "l" [0,"",'l',[0]]: "el"
.   .   "n" [0,"",'n',[0]]: "en"
.   .   "o" [0,"",'o',[0]]: "eo"
.   .   "s" [0,"",'s',[0]]: "es"
.   .   "t" [0,"",'t',[0]]: "et"
.   .   "u" [0,"",'u',[0]]: "eu"
.   .   "wo" [0,"w",'o',[0]]: "ewo"
.   }
.   "f" [0,"",'f',[7,'y']] {
.   .   "a" [0,"",'a',[0]]: "fa"
.   .   "f" [0,"",'f',[0]]: "ff"
.   .   "i" [0,"",'i',[1,'l']]: "fi" {
.   .   .   "l" [0,"",'l',[0]]: "fil"
.   .   }
.   .   "o" [0,"",'o',[0]]: "fo"
.   .   "r" [0,"",'r',[0]]: "fr"
.   .   "ur" [0,"u",'r',[0]]: "fur"
.   .   "y" [0,"",'y',[0]]: "fy"
.   }
.   "g" [0,"",'g',[6,'v']] {
.   .   "a" [0,"",'a',[0]]: "ga"
.   .   "d" [0,"",'d',[0]]: "gd"
.   .   "l" [0,"",'l',[0]]: "gl"
.   .   "sw" [0,"s",'w',[0]]: "gsw"
.   .   "u" [0,"",'u',[1,'z']]: "gu" {
.   .   .   "z" [0,"",'z',[0]]: "guz"
.   .   }
.   .   "v" [0,"",'v',[0]]: "gv"
.   }
.   "h" [0,"",'h',[6,'y']] {
.   .   "a" [0,"",'a',[1,'w']]: "ha" {
.   .   .   "w" [0,"",'w',[0]]: "haw"
.   .   }
.   .   "e" [0,"",'e',[0]]: "he"
.   .   "i" [0,"",'i',[0]]: "hi"
.   .   "r" [0,"",'r',[0]]: "hr"
.   .   "u" [0,"",'u',[0]]: "hu"
.   .   "y" [0,"",'y',[0]]: "hy"
.   }
.   "i" [0,"",'i',[6,'t']] {
.   .   "a" [0,"",'a',[0]]: "ia"
.   .   "d" [0,"",'d',[0]]: "id"
.   .   "g" [0,"",'g',[0]]: "ig"
.   .   "i" [0,"",'i',[0]]: "ii"
.   .   "s" [0,"",'s',[0]]: "is"
.   .   "t" [0,"",'t',[0]]: "it"
.   }
.   "j" [0,"",'j',[3,'m']] {
.   .   "a" [0,"",'a',[0]]: "ja"
.   .   "go" [0,"g",'o',[0]]: "jgo"
.   .   "mc" [0,"m",'c',[0]]: "jmc"
.   }
.   "k" [0,"",'k',[13,'y']] {
.   .   "a" [0,"",'a',[2,'m']]: "ka" {
.   .   .   "b" [0,"",'b',[0]]: "kab"
.   .   .   "m" [0,"",'m',[0]]: "kam"
.   .   }
.   .   "de" [0,"d",'e',[0]]: "kde"
.   .   "ea" [0,"e",'a',[0]]: "kea"
.   .   "hq" [0,"h",'q',[0]]: "khq"
.   .   "i" [0,"",'i',[0]]: "ki"
.   .   "k" [0,"",'k',[1,'j']]: "kk" {
.   .   .   "j" [0,"",'j',[0]]: "kkj"
.   .   }
.   .   "l" [0,"",'l',[1,'n']]: "kl" {
.   .   .   "n" [0,"",'n',[0]]: "kln"
.   .   }
.   .   "m" [0,"",'m',[0]]: "km"
.   .   "n" [0,"",'n',[0]]: "kn"
.   .   "o" [0,"",'o',[1,'k']]: "ko" {
.   .   .   "k" [0,"",'k',[0]]: "kok"
.   .   }
.   .   "s" [0,"",'s',[3,'h']] {
.   .   .   "b" [0,"",'b',[0]]: "ksb"
.   .   .   "f" [0,"",'f',[0]]: "ksf"
.   .   .   "h" [0,"",'h',[0]]: "ksh"
.   .   }
.   .   "w" [0,"",'w',[0]]: "kw"
.   .   "y" [0,"",'y',[0]]: "ky"
.   }
.   "l" [0,"",'l',[8,'v']] {
.   .   "ag" [0,"a",'g',[0]]: "lag"
.   .   "g" [0,"",'g',[0]]: "lg"
.   .   "kt" [0,"k",'t',[0]]: "lkt"
.   .   "n" [0,"",'n',[0]]: "ln"
.   .   "o" [0,"",'o',[0]]: "lo"
.   .   "t" [0,"",'t',[0]]: "lt"
.   .   "u" [0,"",'u',[2,'y']]: "lu" {
.   .   .   "o" [0,"",'o',[0]]: "luo"
.   .   .   "y" [0,"",'y',[0]]: "luy"
.   .   }
.   .   "v" [0,"",'v',[0]]: "lv"
.   }
.   "m" [0,"",'m',[12,'y']] {
.   .   "as" [0,"a",'s',[0]]: "mas"
.   .   "er" [0,"e",'r',[0]]: "mer"
.   .   "fe" [0,"f",'e',[0]]: "mfe"
.   .   "g" [0,"",'g',[2,'o']]: "mg" {
.   .   .   "h" [0,"",'h',[0]]: "mgh"
.   .   .   "o" [0,"",'o',[0]]: "mgo"
.   .   }
.   .   "k" [0,"",'k',[0]]: "mk"
.   .   "l" [0,"",'l',[0]]: "ml"
.   .   "n" [0,"",'n',[0]]: "mn"
.   .   "r" [0,"",'r',[0]]: "mr"
.   .   "s" [0,"",'s',[0]]: "ms"
.   .   "t" [0,"",'t',[0]]: "mt"
.   .   "ua" [0,"u",'a',[0]]: "mua"
.   .   "y" [0,"",'y',[0]]: "my"
.   }
.   "n" [0,"",'n',[11,'y']] {
.   .   "aq" [0,"a",'q',[0]]: "naq"
.   .   "b" [0,"",'b',[0]]: "nb"
.   .   "d" [0,"",'d',[0]]: "nd"
.   .   "e" [0,"",'e',[0]]: "ne"
.   .   "l" [0,"",'l',[0]]: "nl"
.   .   "mg" [0,"m",'g',[0]]: "nmg"
.   .   "n" [0,"",'n',[1,'h']]: "nn" {
.   .   .   "h" [0,"",'h',[0]]: "nnh"
.   .   }
.   .   "r" [0,"",'r',[0]]: "nr"
.   .   "so" [0,"s",'o',[0]]: "nso"
.   .   "us" [0,"u",'s',[0]]: "nus"
.   .   "yn" [0,"y",'n',[0]]: "nyn"
.   }
.   "o" [0,"",'o',[3,'s']] {
.   .   "m" [0,"",'m',[0]]: "om"
.   .   "r" [0,"",'r',[0]]: "or"
.   .   "s" [0,"",'s',[0]]: "os"
.   }
.   "p" [0,"",'p',[4,'t']] {
.   .   "a" [0,"",'a',[1,'_']]: "pa" {
.   .   .   "_Arab" [0,"_Ara",'b',[0]]: "pa_Arab"
.   .   }
.   .   "l" [0,"",'l',[0]]: "pl"
.   .   "s" [0,"",'s',[0]]: "ps"
.   .   "t" [0,"",'t',[0]]: "pt"
.   }
.   "r" [0,"",'r',[5,'w']] {
.   .   "m" [0,"",'m',[0]]: "rm"
.   .   "n" [0,"",'n',[0]]: "rn"
.   .   "o" [0,"",'o',[1,'f']]: "ro" {
.   .   .   "f" [0,"",'f',[0]]: "rof"
.   .   }
.   .   "u" [0,"",'u',[0]]: "ru"
.   .   "w" [0,"",'w',[1,'k']]: "rw" {
.   .   .   "k" [0,"",'k',[0]]: "rwk"
.   .   }
.   }
.   "s" [0,"",'s',[16,'w']] {
.   .   "a" [0,"",'a',[2,'q']] {
.   .   .   "h" [0,"",'h',[0]]: "sah"
.   .   .   "q" [0,"",'q',[0]]: "saq"
.   .   }
.   .   "bp" [0,"b",'p',[0]]: "sbp"
.   .   "e" [0,"",'e',[2,'s']]: "se" {
.   .   .   "h" [0,"",'h',[0]]: "seh"
.   .   .   "s" [0,"",'s',[0]]: "ses"
.   .   }
.   .   "g" [0,"",'g',[0]]: "sg"
.   .   "hi" [0,"h",'i',[1,'_']]: "shi" {
.   .   .   "_Latn" [1,"h_Lat",'n',[0]]: "shi_Latn"
.   .   }
.   .   "i" [0,"",'i',[0]]: "si"
.   .   "k" [0,"",'k',[0]]: "sk"
.   .   "l" [0,"",'l',[0]]: "sl"
.   .   "n" [0,"",'n',[0]]: "sn"
.   .   "o" [0,"",'o',[0]]: "so"
.   .   "q" [0,"",'q',[0]]: "sq"
.   .   "r" [0,"",'r',[1,'_']]: "sr" {
.   .   .   "_Latn" [0,"_Lat",'n',[0]]: "sr_Latn"
.   .   }
.   .   "s" [0,"",'s',[1,'y']]: "ss" {
.   .   .   "y" [0,"",'y',[0]]: "ssy"
.   .   }
.   .   "t" [0,"",'t',[0]]: "st"
.   .   "v" [0,"",'v',[0]]: "sv"
.   .   "w" [0,"",'w',[1,'c']]: "sw" {
.   .   .   "c" [0,"",'c',[0]]: "swc"
.   .   }
.   }
.   "t" [0,"",'t',[11,'z']] {
.   .   "a" [0,"",'a',[0]]: "ta"
.   .   "e" [0,"",'e',[1,'o']]: "te" {
.   .   .   "o" [0,"",'o',[0]]: "teo"
.   .   }
.   .   "g" [0,"",'g',[0]]: "tg"
.   .   "h" [0,"",'h',[0]]: "th"
.   .   "i" [0,"",'i',[2,'g']]: "ti" {
.   .   .   "_ER" [0,"_E",'R',[0]]: "ti_ER"
.   .   .   "g" [0,"",'g',[0]]: "tig"
.   .   }
.   .   "n" [0,"",'n',[0]]: "tn"
.   .   "o" [0,"",'o',[0]]: "to"
.   .   "r" [0,"",'r',[0]]: "tr"
.   .   "s" [0,"",'s',[0]]: "ts"
.   .   "wq" [0,"w",'q',[0]]: "twq"
.   .   "zm" [0,"z",'m',[0]]: "tzm"
.   }
.   "u" [0,"",'u',[4,'z']] {
.   .   "g" [0,"",'g',[0]]: "ug"
.   .   "k" [0,"",'k',[0]]: "uk"
.   .   "r" [0,"",'r',[0]]: "ur"
.   .   "z" [0,"",'z',[1,'_']]: "uz" {
.   .   .   "_" [0,"",'_',[2,'C']] {
.   .   .   .   "Arab" [0,"Ara",'b',[0]]: "uz_Arab"
.   .   .   .   "Cyrl" [0,"Cyr",'l',[0]]: "uz_Cyrl"
.   .   .   }
.   .   }
.   }
.   "v" [0,"",'v',[5,'u']] {
.   .   "ai_Latn" [0,"ai_Lat",'n',[0]]: "vai_Latn"
.   .   "e" [0,"",'e',[0]]: "ve"
.   .   "i" [0,"",'i',[0]]: "vi"
.   .   "o" [0,"",'o',[0]]: "vo"
.   .   "un" [0,"u",'n',[0]]: "vun"
.   }
.   "wa" [0,"w",'a',[2,'l']] {
.   .   "e" [1,"w",'e',[0]]: "wae"
.   .   "l" [1,"w",'l',[0]]: "wal"
.   }
.   "x" [0,"",'x',[2,'o']] {
.   .   "h" [0,"",'h',[0]]: "xh"
.   .   "og" [0,"o",'g',[0]]: "xog"
.   }
.   "y" [0,"",'y',[2,'o']] {
.   .   "av" [0,"a",'v',[0]]: "yav"
.   .   "o" [0,"",'o',[1,'_']]: "yo" {
.   .   .   "_BJ" [0,"_B",'J',[0]]: "yo_BJ"
.   .   }
.   }
.   "z" [0,"",'z',[3,'u']] {
.   .   "gh" [0,"g",'h',[0]]: "zgh"
.   .   "h" [0,"",'h',[1,'_']]: "zh" {
.   .   .   "_Hant" [0,"_Han",'t',[0]]: "zh_Hant"
.   .   }
.   .   "u" [0,"",'u',[0]]: "zu"
.   }
}
$
$

--[ gen-compact-trie-filenames-array ]------------------------------------------

$ ../src/trie --attrs --dots --gen=compact --output=trie --trie=array < filenames.txt
[1,'c'] {
.   "c++py-tree-demo/" [0,"c++py-tree-demo",'/',[3,'c']] {
.   .   ".src-" [15,"c++py-tree-demo.src",'-',[2,'f']] {
.   .   .   "dirs" [19,"c++py-tree-demo.srcdir",'s',[0]]: "c++py-tree-demo/.src-dirs"
.   .   .   "files" [19,"c++py-tree-demo.srcfile",'s',[0]]: "c++py-tree-demo/.src-files"
.   .   }
.   .   "bin.patch" [15,"c++py-tree-demobin.patc",'h',[0]]: "c++py-tree-demo/bin.patch"
.   .   "c++py" [15,"c++py-tree-democ++p",'y',[2,'/']] {
.   .   .   "-tree" [19,"c++py-tree-democ++p-tre",'e',[2,'.']] {
.   .   .   .   "-" [23,"c++py-tree-democ++p-tre",'-',[3,'r']] {
.   .   .   .   .   "author.txt" [23,"c++py-tree-democ++p-treauthor.tx",'t',[0]]: "c++py-tree-demo/c++py-tree-author.txt"
.   .   .   .   .   "demo.txt" [23,"c++py-tree-democ++p-tredemo.tx",'t',[0]]: "c++py-tree-demo/c++py-tree-demo.txt"
.   .   .   .   .   "readme." [23,"c++py-tree-democ++p-trereadme",'.',[2,'t']] {
.   .   .   .   .   .   "pdf" [29,"c++py-tree-democ++p-trereadmepd",'f',[0]]: "c++py-tree-demo/c++py-tree-readme.pdf"
.   .   .   .   .   .   "t" [29,"c++py-tree-democ++p-trereadme",'t',[2,'x']] {
.   .   .   .   .   .   .   "ex" [29,"c++py-tree-democ++p-trereadmee",'x',[0]]: "c++py-tree-demo/c++py-tree-readme.tex"
.   .   .   .   .   .   .   "xt" [29,"c++py-tree-democ++p-trereadmex",'t',[0]]: "c++py-tree-demo/c++py-tree-readme.txt"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   "." [23,"c++py-tree-democ++p-tre",'.',[2,'t']] {
.   .   .   .   .   "pdf" [23,"c++py-tree-democ++p-trepd",'f',[0]]: "c++py-tree-demo/c++py-tree.pdf"
.   .   .   .   .   "t" [23,"c++py-tree-democ++p-tre",'t',[2,'x']] {
.   .   .   .   .   .   "ex" [23,"c++py-tree-democ++p-tree",'x',[0]]: "c++py-tree-demo/c++py-tree.tex"
.   .   .   .   .   .   "xt" [23,"c++py-tree-democ++p-trex",'t',[0]]: "c++py-tree-demo/c++py-tree.txt"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   "/" [19,"c++py-tree-democ++p",'/',[4,'R']] {
.   .   .   .   ".src-" [19,"c++py-tree-democ++p.src",'-',[2,'f']] {
.   .   .   .   .   "dirs" [23,"c++py-tree-democ++p.srcdir",'s',[0]]: "c++py-tree-demo/c++py/.src-dirs"
.   .   .   .   .   "files" [23,"c++py-tree-democ++p.srcfile",'s',[0]]: "c++py-tree-demo/c++py/.src-files"
.   .   .   .   }
.   .   .   .   "AUTHOR" [19,"c++py-tree-democ++pAUTHO",'R',[0]]: "c++py-tree-demo/c++py/AUTHOR"
.   .   .   .   "Makefile" [19,"c++py-tree-democ++pMakefil",'e',[0]]: "c++py-tree-demo/c++py/Makefile"
.   .   .   .   "README" [19,"c++py-tree-democ++pREADM",'E',[0]]: "c++py-tree-demo/c++py/README"
.   .   .   }
.   .   }
.   }
}
$

--[ gen-compact-trie-filenames-ternary ]----------------------------------------

$ ../src/trie --attrs --dots --gen=compact --output=trie --trie=ternary < filenames.txt
[1,'c'] {
.   "c++py-tree-demo/" [0,"c++py-tree-demo",'/',[3,'c']] {
.   .   ".src-" [15,"c++py-tree-demo.src",'-',[2,'f']] {
.   .   .   "dirs" [19,"c++py-tree-demo.srcdir",'s',[0]]: "c++py-tree-demo/.src-dirs"
.   .   .   "files" [19,"c++py-tree-demo.srcfile",'s',[0]]: "c++py-tree-demo/.src-files"
.   .   }
.   .   "bin.patch" [15,"c++py-tree-demobin.patc",'h',[0]]: "c++py-tree-demo/bin.patch"
.   .   "c++py" [15,"c++py-tree-democ++p",'y',[2,'/']] {
.   .   .   "-tree" [19,"c++py-tree-democ++p-tre",'e',[2,'.']] {
.   .   .   .   "-" [23,"c++py-tree-democ++p-tre",'-',[3,'r']] {
.   .   .   .   .   "author.txt" [23,"c++py-tree-democ++p-treauthor.tx",'t',[0]]: "c++py-tree-demo/c++py-tree-author.txt"
.   .   .   .   .   "demo.txt" [23,"c++py-tree-democ++p-tredemo.tx",'t',[0]]: "c++py-tree-demo/c++py-tree-demo.txt"
.   .   .   .   .   "readme." [23,"c++py-tree-democ++p-trereadme",'.',[2,'t']] {
.   .   .   .   .   .   "pdf" [29,"c++py-tree-democ++p-trereadmepd",'f',[0]]: "c++py-tree-demo/c++py-tree-readme.pdf"
.   .   .   .   .   .   "t" [29,"c++py-tree-democ++p-trereadme",'t',[2,'x']] {
.   .   .   .   .   .   .   "ex" [29,"c++py-tree-democ++p-trereadmee",'x',[0]]: "c++py-tree-demo/c++py-tree-readme.tex"
.   .   .   .   .   .   .   "xt" [29,"c++py-tree-democ++p-trereadmex",'t',[0]]: "c++py-tree-demo/c++py-tree-readme.txt"
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   }
.   .   .   .   "." [23,"c++py-tree-democ++p-tre",'.',[2,'t']] {
.   .   .   .   .   "pdf" [23,"c++py-tree-democ++p-trepd",'f',[0]]: "c++py-tree-demo/c++py-tree.pdf"
.   .   .   .   .   "t" [23,"c++py-tree-democ++p-tre",'t',[2,'x']] {
.   .   .   .   .   .   "ex" [23,"c++py-tree-democ++p-tree",'x',[0]]: "c++py-tree-demo/c++py-tree.tex"
.   .   .   .   .   .   "xt" [23,"c++py-tree-democ++p-trex",'t',[0]]: "c++py-tree-demo/c++py-tree.txt"
.   .   .   .   .   }
.   .   .   .   }
.   .   .   }
.   .   .   "/" [19,"c++py-tree-democ++p",'/',[4,'R']] {
.   .   .   .   ".src-" [19,"c++py-tree-democ++p.src",'-',[2,'f']] {
.   .   .   .   .   "dirs" [23,"c++py-tree-democ++p.srcdir",'s',[0]]: "c++py-tree-demo/c++py/.src-dirs"
.   .   .   .   .   "files" [23,"c++py-tree-democ++p.srcfile",'s',[0]]: "c++py-tree-demo/c++py/.src-files"
.   .   .   .   }
.   .   .   .   "AUTHOR" [19,"c++py-tree-democ++pAUTHO",'R',[0]]: "c++py-tree-demo/c++py/AUTHOR"
.   .   .   .   "Makefile" [19,"c++py-tree-democ++pMakefil",'e',[0]]: "c++py-tree-demo/c++py/Makefile"
.   .   .   .   "README" [19,"c++py-tree-democ++pREADM",'E',[0]]: "c++py-tree-demo/c++py/README"
.   .   .   }
.   .   }
.   }
}
$

--[ gen-wide-expr-cxxpy-depth-0-base0-array ]-----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=0 --trie=array "$@"; }
$ print a|trie
(
    a
)
$ print a ab|trie
(
    a [
        b
    ]
)
$ print a ab abc|trie
(
    a [
        b [
            c
        ]
    ]
)
$ print a b|trie
(
    a |
    b
)
$ print a b abc bac abd|trie
(
    a [
        b (
            c |
            d
        )
    ] |
    b [
        ac
    ]
)
$ print a bb ba c|trie
(
    a |
    b (
        a |
        b
    ) |
    c
)
$ print a bb ba cc|trie
(
    a |
    b (
        a |
        b
    ) |
    cc
)
$ print a bb ba ccc|trie
(
    a |
    b (
        a |
        b
    ) |
    ccc
)
$ print a bb ba cde|trie
(
    a |
    b (
        a |
        b
    ) |
    cde
)
$ print a bb ba cdef|trie
(
    a |
    b (
        a |
        b
    ) |
    cdef
)
$ print a bb ba cdef cdefg|trie
(
    a |
    b (
        a |
        b
    ) |
    cdef [
        g
    ]
)
$ print a bb bac cdef|trie
(
    a |
    b (
        ac |
        b
    ) |
    cdef
)
$ print a bbx ba ccc|trie
(
    a |
    b (
        a |
        bx
    ) |
    ccc
)
$ print a bbx bay ccc|trie
(
    a |
    b (
        ay |
        bx
    ) |
    ccc
)
$ print a cde cdef|trie
(
    a |
    cde [
        f
    ]
)
$ print a cde cdef cdefg|trie
(
    a |
    cde [
        f [
            g
        ]
    ]
)
$ print a cde cdef cdefgh|trie
(
    a |
    cde [
        f [
            gh
        ]
    ]
)
$ print a cdef cdefg|trie
(
    a |
    cdef [
        g
    ]
)
$ print ab|trie
(
    ab
)
$ print ab bb ba ccc|trie
(
    ab |
    b (
        a |
        b
    ) |
    ccc
)
$ print ab bb ba cde|trie
(
    ab |
    b (
        a |
        b
    ) |
    cde
)
$ print ab bbx ba ccc|trie
(
    ab |
    b (
        a |
        bx
    ) |
    ccc
)
$ print ab c|trie
(
    ab |
    c
)
$ print abc bb ba ccc|trie
(
    abc |
    b (
        a |
        b
    ) |
    ccc
)
$ print abcd abde abef|trie
(
    ab (
        cd |
        de |
        ef
    )
)
$ print abg a abc ab abd|trie
(
    a [
        b [
            c |
            d |
            g
        ]
    ]
)
$ print ac ab|trie
(
    a (
        b |
        c
    )
)
$ print aef ae abg a abc ab abd|trie
(
    a [
        b [
            c |
            d |
            g
        ] |
        e [
            f
        ]
    ]
)
$ print cde cdef cdefgh|trie
(
    cde [
        f [
            gh
        ]
    ]
)
$ print cdef cdefg|trie
(
    cdef [
        g
    ]
)
$ print cdex cdfy cdgz cdhw|trie
(
    cd (
        ex |
        fy |
        gz |
        hw
    )
)
$ print ce cdex cdfy cdgz cdhw|trie
(
    c (
        d (
            ex |
            fy |
            gz |
            hw
        ) |
        e
    )
)
$ print pot potato pottery tattoo tempo|trie
(
    pot [
        ato |
        tery
    ] |
    t (
        attoo |
        empo
    )
)
$

--[ gen-wide-expr-cxxpy-depth-0-base0-ternary ]---------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=0 --trie=ternary "$@"; }
$ print a|trie
(
    a
)
$ print a ab|trie
(
    a [
        b
    ]
)
$ print a ab abc|trie
(
    a [
        b [
            c
        ]
    ]
)
$ print a b|trie
(
    a |
    b
)
$ print a b abc bac abd|trie
(
    a [
        b (
            c |
            d
        )
    ] |
    b [
        ac
    ]
)
$ print a bb ba c|trie
(
    a |
    b (
        a |
        b
    ) |
    c
)
$ print a bb ba cc|trie
(
    a |
    b (
        a |
        b
    ) |
    cc
)
$ print a bb ba ccc|trie
(
    a |
    b (
        a |
        b
    ) |
    ccc
)
$ print a bb ba cde|trie
(
    a |
    b (
        a |
        b
    ) |
    cde
)
$ print a bb ba cdef|trie
(
    a |
    b (
        a |
        b
    ) |
    cdef
)
$ print a bb ba cdef cdefg|trie
(
    a |
    b (
        a |
        b
    ) |
    cdef [
        g
    ]
)
$ print a bb bac cdef|trie
(
    a |
    b (
        ac |
        b
    ) |
    cdef
)
$ print a bbx ba ccc|trie
(
    a |
    b (
        a |
        bx
    ) |
    ccc
)
$ print a bbx bay ccc|trie
(
    a |
    b (
        ay |
        bx
    ) |
    ccc
)
$ print a cde cdef|trie
(
    a |
    cde [
        f
    ]
)
$ print a cde cdef cdefg|trie
(
    a |
    cde [
        f [
            g
        ]
    ]
)
$ print a cde cdef cdefgh|trie
(
    a |
    cde [
        f [
            gh
        ]
    ]
)
$ print a cdef cdefg|trie
(
    a |
    cdef [
        g
    ]
)
$ print ab|trie
(
    ab
)
$ print ab bb ba ccc|trie
(
    ab |
    b (
        a |
        b
    ) |
    ccc
)
$ print ab bb ba cde|trie
(
    ab |
    b (
        a |
        b
    ) |
    cde
)
$ print ab bbx ba ccc|trie
(
    ab |
    b (
        a |
        bx
    ) |
    ccc
)
$ print ab c|trie
(
    ab |
    c
)
$ print abc bb ba ccc|trie
(
    abc |
    b (
        a |
        b
    ) |
    ccc
)
$ print abcd abde abef|trie
(
    ab (
        cd |
        de |
        ef
    )
)
$ print abg a abc ab abd|trie
(
    a [
        b [
            c |
            d |
            g
        ]
    ]
)
$ print ac ab|trie
(
    a (
        b |
        c
    )
)
$ print aef ae abg a abc ab abd|trie
(
    a [
        b [
            c |
            d |
            g
        ] |
        e [
            f
        ]
    ]
)
$ print cde cdef cdefgh|trie
(
    cde [
        f [
            gh
        ]
    ]
)
$ print cdef cdefg|trie
(
    cdef [
        g
    ]
)
$ print cdex cdfy cdgz cdhw|trie
(
    cd (
        ex |
        fy |
        gz |
        hw
    )
)
$ print ce cdex cdfy cdgz cdhw|trie
(
    c (
        d (
            ex |
            fy |
            gz |
            hw
        ) |
        e
    )
)
$ print pot potato pottery tattoo tempo|trie
(
    pot [
        ato |
        tery
    ] |
    t (
        attoo |
        empo
    )
)
$

--[ gen-wide-expr-cxxpy-depth-0-base ]------------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=0 --no-dots "$@"; }
$ print a ab abc abd ac|trie
(
    a [
        b [
            c |
            d
        ] |
        c
    ]
)
$ print a ab abc abd ac|trie -t int
(
    a [
        b [
            c |
            d
        ] |
        c
    ]
)
$ print a ab abc abd ac|trie -t float
(
    a [
        b [
            c |
            d
        ] |
        c
    ]
)
$

--[ gen-wide-expr-cxxpy-depth-0-base-array ]------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=0 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(
.   a
)
$ print a b|trie
(
.   a |
.   b
)
$ print a b c|trie
(
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(
.   a [
.   .   b [
.   .   .   c
.   .   ]
.   ]
)
$ print a ab ac|trie
(
.   a [
.   .   b |
.   .   c
.   ]
)
$ print a ab ac ad|trie
(
.   a [
.   .   b |
.   .   c |
.   .   d
.   ]
)
$ print a abd ac|trie
(
.   a [
.   .   bd |
.   .   c
.   ]
)
$ print a ab ac acd|trie
(
.   a [
.   .   b |
.   .   c [
.   .   .   d
.   .   ]
.   ]
)
$ print a bb ba ccc|trie
(
.   a |
.   b (
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print a bb ccc|trie
(
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(
.   a |
.   b (
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print abc abd acde|trie
(
.   a (
.   .   b (
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   cde
.   )
)
$ print abc abd acde ac|trie
(
.   a (
.   .   b (
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   c [
.   .   .   de
.   .   ]
.   )
)
$ print abc abd acde acfg|trie
(
.   a (
.   .   b (
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   c (
.   .   .   de |
.   .   .   fg
.   .   )
.   )
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c (
.   .   de |
.   .   fg [
.   .   .   x [
.   .   .   .   y [
.   .   .   .   .   z
.   .   .   .   ] |
.   .   .   .   zzz
.   .   .   ]
.   .   ]
.   )
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c (
.   .   fg [
.   .   .   x [
.   .   .   .   y [
.   .   .   .   .   z
.   .   .   .   ] |
.   .   .   .   zzz
.   .   .   ]
.   .   ] |
.   .   ge
.   )
)
$ print a abcd abcdefg h hijk|trie
(
.   a [
.   .   bcd [
.   .   .   efg
.   .   ]
.   ] |
.   h [
.   .   ijk
.   ]
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(
.   a [
.   .   bcd [
.   .   .   efg |
.   .   .   xyz
.   .   ]
.   ] |
.   h [
.   .   ijk
.   ]
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(
.   a [
.   .   bcd [
.   .   .   efg |
.   .   .   xyz
.   .   ]
.   ] |
.   h [
.   .   ijk |
.   .   lm
.   ]
)
$

--[ gen-wide-expr-cxxpy-depth-0-base-ternary ]----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=0 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(
.   a
)
$ print a b|trie
(
.   a |
.   b
)
$ print a b c|trie
(
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(
.   a [
.   .   b [
.   .   .   c
.   .   ]
.   ]
)
$ print a ab ac|trie
(
.   a [
.   .   b |
.   .   c
.   ]
)
$ print a ab ac ad|trie
(
.   a [
.   .   b |
.   .   c |
.   .   d
.   ]
)
$ print a abd ac|trie
(
.   a [
.   .   bd |
.   .   c
.   ]
)
$ print a ab ac acd|trie
(
.   a [
.   .   b |
.   .   c [
.   .   .   d
.   .   ]
.   ]
)
$ print a bb ba ccc|trie
(
.   a |
.   b (
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print a bb ccc|trie
(
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(
.   a |
.   b (
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print abc abd acde|trie
(
.   a (
.   .   b (
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   cde
.   )
)
$ print abc abd acde ac|trie
(
.   a (
.   .   b (
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   c [
.   .   .   de
.   .   ]
.   )
)
$ print abc abd acde acfg|trie
(
.   a (
.   .   b (
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   c (
.   .   .   de |
.   .   .   fg
.   .   )
.   )
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c (
.   .   de |
.   .   fg [
.   .   .   x [
.   .   .   .   y [
.   .   .   .   .   z
.   .   .   .   ] |
.   .   .   .   zzz
.   .   .   ]
.   .   ]
.   )
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c (
.   .   fg [
.   .   .   x [
.   .   .   .   y [
.   .   .   .   .   z
.   .   .   .   ] |
.   .   .   .   zzz
.   .   .   ]
.   .   ] |
.   .   ge
.   )
)
$ print a abcd abcdefg h hijk|trie
(
.   a [
.   .   bcd [
.   .   .   efg
.   .   ]
.   ] |
.   h [
.   .   ijk
.   ]
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(
.   a [
.   .   bcd [
.   .   .   efg |
.   .   .   xyz
.   .   ]
.   ] |
.   h [
.   .   ijk
.   ]
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(
.   a [
.   .   bcd [
.   .   .   efg |
.   .   .   xyz
.   .   ]
.   ] |
.   h [
.   .   ijk |
.   .   lm
.   ]
)
$

--[ gen-wide-expr-cxxpy-depth-0-alphabets-array ]-------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=0 --trie=array < alphabets.txt
(
.   a (
.   .   a |
.   .   f |
.   .   gq |
.   .   k |
.   .   m |
.   .   r |
.   .   s [
.   .   .   a |
.   .   .   t
.   .   ] |
.   .   z [
.   .   .   _Cyrl
.   .   ]
.   ) |
.   b (
.   .   as |
.   .   e [
.   .   .   m |
.   .   .   z
.   .   ] |
.   .   g |
.   .   m |
.   .   n |
.   .   o |
.   .   r [
.   .   .   x
.   .   ] |
.   .   s [
.   .   .   _Cyrl
.   .   ] |
.   .   yn
.   ) |
.   c (
.   .   a |
.   .   gg |
.   .   hr |
.   .   s |
.   .   y
.   ) |
.   d (
.   .   a [
.   .   .   v
.   .   ] |
.   .   e |
.   .   je |
.   .   ua |
.   .   yo |
.   .   z
.   ) |
.   e (
.   .   bu |
.   .   e |
.   .   l |
.   .   n |
.   .   o |
.   .   s |
.   .   t |
.   .   u |
.   .   wo
.   ) |
.   f (
.   .   a |
.   .   f |
.   .   i [
.   .   .   l
.   .   ] |
.   .   o |
.   .   r |
.   .   ur |
.   .   y
.   ) |
.   g (
.   .   a |
.   .   d |
.   .   l |
.   .   sw |
.   .   u [
.   .   .   z
.   .   ] |
.   .   v
.   ) |
.   h (
.   .   a [
.   .   .   w
.   .   ] |
.   .   e |
.   .   i |
.   .   r |
.   .   u |
.   .   y
.   ) |
.   i (
.   .   a |
.   .   d |
.   .   g |
.   .   i |
.   .   s |
.   .   t
.   ) |
.   j (
.   .   a |
.   .   go |
.   .   mc
.   ) |
.   k (
.   .   a [
.   .   .   b |
.   .   .   m
.   .   ] |
.   .   de |
.   .   ea |
.   .   hq |
.   .   i |
.   .   k [
.   .   .   j
.   .   ] |
.   .   l [
.   .   .   n
.   .   ] |
.   .   m |
.   .   n |
.   .   o [
.   .   .   k
.   .   ] |
.   .   s (
.   .   .   b |
.   .   .   f |
.   .   .   h
.   .   ) |
.   .   w |
.   .   y
.   ) |
.   l (
.   .   ag |
.   .   g |
.   .   kt |
.   .   n |
.   .   o |
.   .   t |
.   .   u [
.   .   .   o |
.   .   .   y
.   .   ] |
.   .   v
.   ) |
.   m (
.   .   as |
.   .   er |
.   .   fe |
.   .   g [
.   .   .   h |
.   .   .   o
.   .   ] |
.   .   k |
.   .   l |
.   .   n |
.   .   r |
.   .   s |
.   .   t |
.   .   ua |
.   .   y
.   ) |
.   n (
.   .   aq |
.   .   b |
.   .   d |
.   .   e |
.   .   l |
.   .   mg |
.   .   n [
.   .   .   h
.   .   ] |
.   .   r |
.   .   so |
.   .   us |
.   .   yn
.   ) |
.   o (
.   .   m |
.   .   r |
.   .   s
.   ) |
.   p (
.   .   a [
.   .   .   _Arab
.   .   ] |
.   .   l |
.   .   s |
.   .   t
.   ) |
.   r (
.   .   m |
.   .   n |
.   .   o [
.   .   .   f
.   .   ] |
.   .   u |
.   .   w [
.   .   .   k
.   .   ]
.   ) |
.   s (
.   .   a (
.   .   .   h |
.   .   .   q
.   .   ) |
.   .   bp |
.   .   e [
.   .   .   h |
.   .   .   s
.   .   ] |
.   .   g |
.   .   hi [
.   .   .   _Latn
.   .   ] |
.   .   i |
.   .   k |
.   .   l |
.   .   n |
.   .   o |
.   .   q |
.   .   r [
.   .   .   _Latn
.   .   ] |
.   .   s [
.   .   .   y
.   .   ] |
.   .   t |
.   .   v |
.   .   w [
.   .   .   c
.   .   ]
.   ) |
.   t (
.   .   a |
.   .   e [
.   .   .   o
.   .   ] |
.   .   g |
.   .   h |
.   .   i [
.   .   .   _ER |
.   .   .   g
.   .   ] |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   wq |
.   .   zm
.   ) |
.   u (
.   .   g |
.   .   k |
.   .   r |
.   .   z [
.   .   .   _ (
.   .   .   .   Arab |
.   .   .   .   Cyrl
.   .   .   )
.   .   ]
.   ) |
.   v (
.   .   ai_Latn |
.   .   e |
.   .   i |
.   .   o |
.   .   un
.   ) |
.   wa (
.   .   e |
.   .   l
.   ) |
.   x (
.   .   h |
.   .   og
.   ) |
.   y (
.   .   av |
.   .   o [
.   .   .   _BJ
.   .   ]
.   ) |
.   z (
.   .   gh |
.   .   h [
.   .   .   _Hant
.   .   ] |
.   .   u
.   )
)
$

--[ gen-wide-expr-cxxpy-depth-0-alphabets-ternary ]-----------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=0 --trie=ternary < alphabets.txt
(
.   a (
.   .   a |
.   .   f |
.   .   gq |
.   .   k |
.   .   m |
.   .   r |
.   .   s [
.   .   .   a |
.   .   .   t
.   .   ] |
.   .   z [
.   .   .   _Cyrl
.   .   ]
.   ) |
.   b (
.   .   as |
.   .   e [
.   .   .   m |
.   .   .   z
.   .   ] |
.   .   g |
.   .   m |
.   .   n |
.   .   o |
.   .   r [
.   .   .   x
.   .   ] |
.   .   s [
.   .   .   _Cyrl
.   .   ] |
.   .   yn
.   ) |
.   c (
.   .   a |
.   .   gg |
.   .   hr |
.   .   s |
.   .   y
.   ) |
.   d (
.   .   a [
.   .   .   v
.   .   ] |
.   .   e |
.   .   je |
.   .   ua |
.   .   yo |
.   .   z
.   ) |
.   e (
.   .   bu |
.   .   e |
.   .   l |
.   .   n |
.   .   o |
.   .   s |
.   .   t |
.   .   u |
.   .   wo
.   ) |
.   f (
.   .   a |
.   .   f |
.   .   i [
.   .   .   l
.   .   ] |
.   .   o |
.   .   r |
.   .   ur |
.   .   y
.   ) |
.   g (
.   .   a |
.   .   d |
.   .   l |
.   .   sw |
.   .   u [
.   .   .   z
.   .   ] |
.   .   v
.   ) |
.   h (
.   .   a [
.   .   .   w
.   .   ] |
.   .   e |
.   .   i |
.   .   r |
.   .   u |
.   .   y
.   ) |
.   i (
.   .   a |
.   .   d |
.   .   g |
.   .   i |
.   .   s |
.   .   t
.   ) |
.   j (
.   .   a |
.   .   go |
.   .   mc
.   ) |
.   k (
.   .   a [
.   .   .   b |
.   .   .   m
.   .   ] |
.   .   de |
.   .   ea |
.   .   hq |
.   .   i |
.   .   k [
.   .   .   j
.   .   ] |
.   .   l [
.   .   .   n
.   .   ] |
.   .   m |
.   .   n |
.   .   o [
.   .   .   k
.   .   ] |
.   .   s (
.   .   .   b |
.   .   .   f |
.   .   .   h
.   .   ) |
.   .   w |
.   .   y
.   ) |
.   l (
.   .   ag |
.   .   g |
.   .   kt |
.   .   n |
.   .   o |
.   .   t |
.   .   u [
.   .   .   o |
.   .   .   y
.   .   ] |
.   .   v
.   ) |
.   m (
.   .   as |
.   .   er |
.   .   fe |
.   .   g [
.   .   .   h |
.   .   .   o
.   .   ] |
.   .   k |
.   .   l |
.   .   n |
.   .   r |
.   .   s |
.   .   t |
.   .   ua |
.   .   y
.   ) |
.   n (
.   .   aq |
.   .   b |
.   .   d |
.   .   e |
.   .   l |
.   .   mg |
.   .   n [
.   .   .   h
.   .   ] |
.   .   r |
.   .   so |
.   .   us |
.   .   yn
.   ) |
.   o (
.   .   m |
.   .   r |
.   .   s
.   ) |
.   p (
.   .   a [
.   .   .   _Arab
.   .   ] |
.   .   l |
.   .   s |
.   .   t
.   ) |
.   r (
.   .   m |
.   .   n |
.   .   o [
.   .   .   f
.   .   ] |
.   .   u |
.   .   w [
.   .   .   k
.   .   ]
.   ) |
.   s (
.   .   a (
.   .   .   h |
.   .   .   q
.   .   ) |
.   .   bp |
.   .   e [
.   .   .   h |
.   .   .   s
.   .   ] |
.   .   g |
.   .   hi [
.   .   .   _Latn
.   .   ] |
.   .   i |
.   .   k |
.   .   l |
.   .   n |
.   .   o |
.   .   q |
.   .   r [
.   .   .   _Latn
.   .   ] |
.   .   s [
.   .   .   y
.   .   ] |
.   .   t |
.   .   v |
.   .   w [
.   .   .   c
.   .   ]
.   ) |
.   t (
.   .   a |
.   .   e [
.   .   .   o
.   .   ] |
.   .   g |
.   .   h |
.   .   i [
.   .   .   _ER |
.   .   .   g
.   .   ] |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   wq |
.   .   zm
.   ) |
.   u (
.   .   g |
.   .   k |
.   .   r |
.   .   z [
.   .   .   _ (
.   .   .   .   Arab |
.   .   .   .   Cyrl
.   .   .   )
.   .   ]
.   ) |
.   v (
.   .   ai_Latn |
.   .   e |
.   .   i |
.   .   o |
.   .   un
.   ) |
.   wa (
.   .   e |
.   .   l
.   ) |
.   x (
.   .   h |
.   .   og
.   ) |
.   y (
.   .   av |
.   .   o [
.   .   .   _BJ
.   .   ]
.   ) |
.   z (
.   .   gh |
.   .   h [
.   .   .   _Hant
.   .   ] |
.   .   u
.   )
)
$

--[ gen-wide-expr-cxxpy-depth-0-filenames-array ]-------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=0 --trie=array --escape=/ < filenames.txt
(
.   c\+\+py-tree-demo\/ (
.   .   .src- (
.   .   .   dirs |
.   .   .   files
.   .   ) |
.   .   bin.patch |
.   .   c\+\+py (
.   .   .   -tree (
.   .   .   .   - (
.   .   .   .   .   author.txt |
.   .   .   .   .   demo.txt |
.   .   .   .   .   readme. (
.   .   .   .   .   .   pdf |
.   .   .   .   .   .   t (
.   .   .   .   .   .   .   ex |
.   .   .   .   .   .   .   xt
.   .   .   .   .   .   )
.   .   .   .   .   )
.   .   .   .   ) |
.   .   .   .   . (
.   .   .   .   .   pdf |
.   .   .   .   .   t (
.   .   .   .   .   .   ex |
.   .   .   .   .   .   xt
.   .   .   .   .   )
.   .   .   .   )
.   .   .   ) |
.   .   .   \/ (
.   .   .   .   .src- (
.   .   .   .   .   dirs |
.   .   .   .   .   files
.   .   .   .   ) |
.   .   .   .   AUTHOR |
.   .   .   .   Makefile |
.   .   .   .   README
.   .   .   )
.   .   )
.   )
)
$

--[ gen-wide-expr-cxxpy-depth-0-filenames-ternary ]-----------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=0 --trie=ternary --escape=/ < filenames.txt
(
.   c\+\+py-tree-demo\/ (
.   .   .src- (
.   .   .   dirs |
.   .   .   files
.   .   ) |
.   .   bin.patch |
.   .   c\+\+py (
.   .   .   -tree (
.   .   .   .   - (
.   .   .   .   .   author.txt |
.   .   .   .   .   demo.txt |
.   .   .   .   .   readme. (
.   .   .   .   .   .   pdf |
.   .   .   .   .   .   t (
.   .   .   .   .   .   .   ex |
.   .   .   .   .   .   .   xt
.   .   .   .   .   .   )
.   .   .   .   .   )
.   .   .   .   ) |
.   .   .   .   . (
.   .   .   .   .   pdf |
.   .   .   .   .   t (
.   .   .   .   .   .   ex |
.   .   .   .   .   .   xt
.   .   .   .   .   )
.   .   .   .   )
.   .   .   ) |
.   .   .   \/ (
.   .   .   .   .src- (
.   .   .   .   .   dirs |
.   .   .   .   .   files
.   .   .   .   ) |
.   .   .   .   AUTHOR |
.   .   .   .   Makefile |
.   .   .   .   README
.   .   .   )
.   .   )
.   )
)
$

--[ gen-compact-expr-cxxpy-depth-0-base0-array ]--------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=0 --trie=array "$@"; }
$ print a|trie
a
$ print a ab|trie
a[b]
$ print a ab abc|trie
a[b[c]]
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a[b(c|d)]|b[ac]
$ print a bb ba c|trie
a|b(a|b)|c
$ print a bb ba cc|trie
a|b(a|b)|cc
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print a bb ba cde|trie
a|b(a|b)|cde
$ print a bb ba cdef|trie
a|b(a|b)|cdef
$ print a bb ba cdef cdefg|trie
a|b(a|b)|cdef[g]
$ print a bb bac cdef|trie
a|b(ac|b)|cdef
$ print a bbx ba ccc|trie
a|b(a|bx)|ccc
$ print a bbx bay ccc|trie
a|b(ay|bx)|ccc
$ print a cde cdef|trie
a|cde[f]
$ print a cde cdef cdefg|trie
a|cde[f[g]]
$ print a cde cdef cdefgh|trie
a|cde[f[gh]]
$ print a cdef cdefg|trie
a|cdef[g]
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b(a|b)|ccc
$ print ab bb ba cde|trie
ab|b(a|b)|cde
$ print ab bbx ba ccc|trie
ab|b(a|bx)|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b(a|b)|ccc
$ print abcd abde abef|trie
ab(cd|de|ef)
$ print abg a abc ab abd|trie
a[b[c|d|g]]
$ print ac ab|trie
a(b|c)
$ print aef ae abg a abc ab abd|trie
a[b[c|d|g]|e[f]]
$ print cde cdef cdefgh|trie
cde[f[gh]]
$ print cdef cdefg|trie
cdef[g]
$ print cdex cdfy cdgz cdhw|trie
cd(ex|fy|gz|hw)
$ print ce cdex cdfy cdgz cdhw|trie
c(d(ex|fy|gz|hw)|e)
$ print pot potato pottery tattoo tempo|trie
pot[ato|tery]|t(attoo|empo)
$

--[ gen-compact-expr-cxxpy-depth-0-base0-ternary ]------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=0 --trie=ternary "$@"; }
$ print a|trie
a
$ print a ab|trie
a[b]
$ print a ab abc|trie
a[b[c]]
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a[b(c|d)]|b[ac]
$ print a bb ba c|trie
a|b(a|b)|c
$ print a bb ba cc|trie
a|b(a|b)|cc
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print a bb ba cde|trie
a|b(a|b)|cde
$ print a bb ba cdef|trie
a|b(a|b)|cdef
$ print a bb ba cdef cdefg|trie
a|b(a|b)|cdef[g]
$ print a bb bac cdef|trie
a|b(ac|b)|cdef
$ print a bbx ba ccc|trie
a|b(a|bx)|ccc
$ print a bbx bay ccc|trie
a|b(ay|bx)|ccc
$ print a cde cdef|trie
a|cde[f]
$ print a cde cdef cdefg|trie
a|cde[f[g]]
$ print a cde cdef cdefgh|trie
a|cde[f[gh]]
$ print a cdef cdefg|trie
a|cdef[g]
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b(a|b)|ccc
$ print ab bb ba cde|trie
ab|b(a|b)|cde
$ print ab bbx ba ccc|trie
ab|b(a|bx)|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b(a|b)|ccc
$ print abcd abde abef|trie
ab(cd|de|ef)
$ print abg a abc ab abd|trie
a[b[c|d|g]]
$ print ac ab|trie
a(b|c)
$ print aef ae abg a abc ab abd|trie
a[b[c|d|g]|e[f]]
$ print cde cdef cdefgh|trie
cde[f[gh]]
$ print cdef cdefg|trie
cdef[g]
$ print cdex cdfy cdgz cdhw|trie
cd(ex|fy|gz|hw)
$ print ce cdex cdfy cdgz cdhw|trie
c(d(ex|fy|gz|hw)|e)
$ print pot potato pottery tattoo tempo|trie
pot[ato|tery]|t(attoo|empo)
$

--[ gen-compact-expr-cxxpy-depth-0-base ]---------------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=0 --no-dots "$@"; }
$ print a ab abc abd ac|trie
a[b[c|d]|c]
$ print a ab abc abd ac|trie -t int
a[b[c|d]|c]
$ print a ab abc abd ac|trie -t float
a[b[c|d]|c]
$

--[ gen-compact-expr-cxxpy-depth-0-base-array ]---------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=0 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a[b[c]]
$ print a ab ac|trie
a[b|c]
$ print a ab ac ad|trie
a[b|c|d]
$ print a abd ac|trie
a[bd|c]
$ print a ab ac acd|trie
a[b|c[d]]
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print abc abd acde|trie
a(b(c|d)|cde)
$ print abc abd acde ac|trie
a(b(c|d)|c[de])
$ print abc abd acde acfg|trie
a(b(c|d)|c(de|fg))
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(de|fg[x[y[z]|zzz]])
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(fg[x[y[z]|zzz]]|ge)
$ print a abcd abcdefg h hijk|trie
a[bcd[efg]]|h[ijk]
$ print a abcd abcdefg abcdxyz h hijk|trie
a[bcd[efg|xyz]]|h[ijk]
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a[bcd[efg|xyz]]|h[ijk|lm]
$

--[ gen-compact-expr-cxxpy-depth-0-base-ternary ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=0 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a[b[c]]
$ print a ab ac|trie
a[b|c]
$ print a ab ac ad|trie
a[b|c|d]
$ print a abd ac|trie
a[bd|c]
$ print a ab ac acd|trie
a[b|c[d]]
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print abc abd acde|trie
a(b(c|d)|cde)
$ print abc abd acde ac|trie
a(b(c|d)|c[de])
$ print abc abd acde acfg|trie
a(b(c|d)|c(de|fg))
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(de|fg[x[y[z]|zzz]])
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(fg[x[y[z]|zzz]]|ge)
$ print a abcd abcdefg h hijk|trie
a[bcd[efg]]|h[ijk]
$ print a abcd abcdefg abcdxyz h hijk|trie
a[bcd[efg|xyz]]|h[ijk]
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a[bcd[efg|xyz]]|h[ijk|lm]
$

--[ gen-compact-expr-cxxpy-depth-0-alphabets-array ]----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=0 --trie=array < alphabets.txt
a(a|f|gq|k|m|r|s[a|t]|z[_Cyrl])|b(as|e[m|z]|g|m|n|o|r[x]|s[_Cyrl]|yn)|c(a|gg|hr|s|y)|d(a[v]|e|je|ua|yo|z)|e(bu|e|l|n|o|s|t|u|wo)|f(a|f|i[l]|o|r|ur|y)|g(a|d|l|sw|u[z]|v)|h(a[w]|e|i|r|u|y)|i(a|d|g|i|s|t)|j(a|go|mc)|k(a[b|m]|de|ea|hq|i|k[j]|l[n]|m|n|o[k]|s(b|f|h)|w|y)|l(ag|g|kt|n|o|t|u[o|y]|v)|m(as|er|fe|g[h|o]|k|l|n|r|s|t|ua|y)|n(aq|b|d|e|l|mg|n[h]|r|so|us|yn)|o(m|r|s)|p(a[_Arab]|l|s|t)|r(m|n|o[f]|u|w[k])|s(a(h|q)|bp|e[h|s]|g|hi[_Latn]|i|k|l|n|o|q|r[_Latn]|s[y]|t|v|w[c])|t(a|e[o]|g|h|i[_ER|g]|n|o|r|s|wq|zm)|u(g|k|r|z[_(Arab|Cyrl)])|v(ai_Latn|e|i|o|un)|wa(e|l)|x(h|og)|y(av|o[_BJ])|z(gh|h[_Hant]|u)
$

--[ gen-compact-expr-cxxpy-depth-0-alphabets-ternary ]--------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=0 --trie=ternary < alphabets.txt
a(a|f|gq|k|m|r|s[a|t]|z[_Cyrl])|b(as|e[m|z]|g|m|n|o|r[x]|s[_Cyrl]|yn)|c(a|gg|hr|s|y)|d(a[v]|e|je|ua|yo|z)|e(bu|e|l|n|o|s|t|u|wo)|f(a|f|i[l]|o|r|ur|y)|g(a|d|l|sw|u[z]|v)|h(a[w]|e|i|r|u|y)|i(a|d|g|i|s|t)|j(a|go|mc)|k(a[b|m]|de|ea|hq|i|k[j]|l[n]|m|n|o[k]|s(b|f|h)|w|y)|l(ag|g|kt|n|o|t|u[o|y]|v)|m(as|er|fe|g[h|o]|k|l|n|r|s|t|ua|y)|n(aq|b|d|e|l|mg|n[h]|r|so|us|yn)|o(m|r|s)|p(a[_Arab]|l|s|t)|r(m|n|o[f]|u|w[k])|s(a(h|q)|bp|e[h|s]|g|hi[_Latn]|i|k|l|n|o|q|r[_Latn]|s[y]|t|v|w[c])|t(a|e[o]|g|h|i[_ER|g]|n|o|r|s|wq|zm)|u(g|k|r|z[_(Arab|Cyrl)])|v(ai_Latn|e|i|o|un)|wa(e|l)|x(h|og)|y(av|o[_BJ])|z(gh|h[_Hant]|u)
$

--[ gen-compact-expr-cxxpy-depth-0-filenames-array ]----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=0 --trie=array --escape=/ < filenames.txt
c\+\+py-tree-demo\/(.src-(dirs|files)|bin.patch|c\+\+py(-tree(-(author.txt|demo.txt|readme.(pdf|t(ex|xt)))|.(pdf|t(ex|xt)))|\/(.src-(dirs|files)|AUTHOR|Makefile|README)))
$

--[ gen-compact-expr-cxxpy-depth-0-filenames-ternary ]--------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=0 --trie=ternary --escape=/ < filenames.txt
c\+\+py-tree-demo\/(.src-(dirs|files)|bin.patch|c\+\+py(-tree(-(author.txt|demo.txt|readme.(pdf|t(ex|xt)))|.(pdf|t(ex|xt)))|\/(.src-(dirs|files)|AUTHOR|Makefile|README)))
$

--[ gen-wide-expr-cxxpy-depth-1-base0-array ]-----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=1 --trie=array "$@"; }
$ print a|trie
(
    a
)
$ print a ab|trie
(
    a
)
$ print a ab abc|trie
(
    a
)
$ print a b|trie
(
    a |
    b
)
$ print a b abc bac abd|trie
(
    a |
    b
)
$ print a bb ba c|trie
(
    a |
    b |
    c
)
$ print a bb ba cc|trie
(
    a |
    b |
    cc
)
$ print a bb ba ccc|trie
(
    a |
    b |
    ccc
)
$ print a bb ba cde|trie
(
    a |
    b |
    cde
)
$ print a bb ba cdef|trie
(
    a |
    b |
    cdef
)
$ print a bb ba cdef cdefg|trie
(
    a |
    b |
    cdef
)
$ print a bb bac cdef|trie
(
    a |
    b |
    cdef
)
$ print a bbx ba ccc|trie
(
    a |
    b |
    ccc
)
$ print a bbx bay ccc|trie
(
    a |
    b |
    ccc
)
$ print a cde cdef|trie
(
    a |
    cde
)
$ print a cde cdef cdefg|trie
(
    a |
    cde
)
$ print a cde cdef cdefgh|trie
(
    a |
    cde
)
$ print a cdef cdefg|trie
(
    a |
    cdef
)
$ print ab|trie
(
    ab
)
$ print ab bb ba ccc|trie
(
    ab |
    b |
    ccc
)
$ print ab bb ba cde|trie
(
    ab |
    b |
    cde
)
$ print ab bbx ba ccc|trie
(
    ab |
    b |
    ccc
)
$ print ab c|trie
(
    ab |
    c
)
$ print abc bb ba ccc|trie
(
    abc |
    b |
    ccc
)
$ print abcd abde abef|trie
(
    ab
)
$ print abg a abc ab abd|trie
(
    a
)
$ print ac ab|trie
(
    a
)
$ print aef ae abg a abc ab abd|trie
(
    a
)
$ print cde cdef cdefgh|trie
(
    cde
)
$ print cdef cdefg|trie
(
    cdef
)
$ print cdex cdfy cdgz cdhw|trie
(
    cd
)
$ print ce cdex cdfy cdgz cdhw|trie
(
    c
)
$ print pot potato pottery tattoo tempo|trie
(
    pot |
    t
)
$

--[ gen-wide-expr-cxxpy-depth-1-base0-ternary ]---------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=1 --trie=ternary "$@"; }
$ print a|trie
(
    a
)
$ print a ab|trie
(
    a
)
$ print a ab abc|trie
(
    a
)
$ print a b|trie
(
    a |
    b
)
$ print a b abc bac abd|trie
(
    a |
    b
)
$ print a bb ba c|trie
(
    a |
    b |
    c
)
$ print a bb ba cc|trie
(
    a |
    b |
    cc
)
$ print a bb ba ccc|trie
(
    a |
    b |
    ccc
)
$ print a bb ba cde|trie
(
    a |
    b |
    cde
)
$ print a bb ba cdef|trie
(
    a |
    b |
    cdef
)
$ print a bb ba cdef cdefg|trie
(
    a |
    b |
    cdef
)
$ print a bb bac cdef|trie
(
    a |
    b |
    cdef
)
$ print a bbx ba ccc|trie
(
    a |
    b |
    ccc
)
$ print a bbx bay ccc|trie
(
    a |
    b |
    ccc
)
$ print a cde cdef|trie
(
    a |
    cde
)
$ print a cde cdef cdefg|trie
(
    a |
    cde
)
$ print a cde cdef cdefgh|trie
(
    a |
    cde
)
$ print a cdef cdefg|trie
(
    a |
    cdef
)
$ print ab|trie
(
    ab
)
$ print ab bb ba ccc|trie
(
    ab |
    b |
    ccc
)
$ print ab bb ba cde|trie
(
    ab |
    b |
    cde
)
$ print ab bbx ba ccc|trie
(
    ab |
    b |
    ccc
)
$ print ab c|trie
(
    ab |
    c
)
$ print abc bb ba ccc|trie
(
    abc |
    b |
    ccc
)
$ print abcd abde abef|trie
(
    ab
)
$ print abg a abc ab abd|trie
(
    a
)
$ print ac ab|trie
(
    a
)
$ print aef ae abg a abc ab abd|trie
(
    a
)
$ print cde cdef cdefgh|trie
(
    cde
)
$ print cdef cdefg|trie
(
    cdef
)
$ print cdex cdfy cdgz cdhw|trie
(
    cd
)
$ print ce cdex cdfy cdgz cdhw|trie
(
    c
)
$ print pot potato pottery tattoo tempo|trie
(
    pot |
    t
)
$

--[ gen-wide-expr-cxxpy-depth-1-base ]------------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=1 --no-dots "$@"; }
$ print a ab abc abd ac|trie
(
    a
)
$ print a ab abc abd ac|trie -t int
(
    a
)
$ print a ab abc abd ac|trie -t float
(
    a
)
$

--[ gen-wide-expr-cxxpy-depth-1-base-array ]------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=1 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(
.   a
)
$ print a b|trie
(
.   a |
.   b
)
$ print a b c|trie
(
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(
.   a
)
$ print a ab ac|trie
(
.   a
)
$ print a ab ac ad|trie
(
.   a
)
$ print a abd ac|trie
(
.   a
)
$ print a ab ac acd|trie
(
.   a
)
$ print a bb ba ccc|trie
(
.   a |
.   b |
.   ccc
)
$ print a bb ccc|trie
(
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(
.   a |
.   b |
.   ccc
)
$ print abc abd acde|trie
(
.   a
)
$ print abc abd acde ac|trie
(
.   a
)
$ print abc abd acde acfg|trie
(
.   a
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c
)
$ print a abcd abcdefg h hijk|trie
(
.   a |
.   h
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(
.   a |
.   h
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(
.   a |
.   h
)
$

--[ gen-wide-expr-cxxpy-depth-1-base-ternary ]----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=1 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(
.   a
)
$ print a b|trie
(
.   a |
.   b
)
$ print a b c|trie
(
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(
.   a
)
$ print a ab ac|trie
(
.   a
)
$ print a ab ac ad|trie
(
.   a
)
$ print a abd ac|trie
(
.   a
)
$ print a ab ac acd|trie
(
.   a
)
$ print a bb ba ccc|trie
(
.   a |
.   b |
.   ccc
)
$ print a bb ccc|trie
(
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(
.   a |
.   b |
.   ccc
)
$ print abc abd acde|trie
(
.   a
)
$ print abc abd acde ac|trie
(
.   a
)
$ print abc abd acde acfg|trie
(
.   a
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c
)
$ print a abcd abcdefg h hijk|trie
(
.   a |
.   h
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(
.   a |
.   h
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(
.   a |
.   h
)
$

--[ gen-wide-expr-cxxpy-depth-1-alphabets-array ]-------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=1 --trie=array < alphabets.txt
(
.   a |
.   b |
.   c |
.   d |
.   e |
.   f |
.   g |
.   h |
.   i |
.   j |
.   k |
.   l |
.   m |
.   n |
.   o |
.   p |
.   r |
.   s |
.   t |
.   u |
.   v |
.   wa |
.   x |
.   y |
.   z
)
$

--[ gen-wide-expr-cxxpy-depth-1-alphabets-ternary ]-----------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=1 --trie=ternary < alphabets.txt
(
.   a |
.   b |
.   c |
.   d |
.   e |
.   f |
.   g |
.   h |
.   i |
.   j |
.   k |
.   l |
.   m |
.   n |
.   o |
.   p |
.   r |
.   s |
.   t |
.   u |
.   v |
.   wa |
.   x |
.   y |
.   z
)
$

--[ gen-wide-expr-cxxpy-depth-1-filenames-array ]-------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=1 --trie=array --escape=/ < filenames.txt
(
.   c\+\+py-tree-demo\/
)
$

--[ gen-wide-expr-cxxpy-depth-1-filenames-ternary ]-----------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=1 --trie=ternary --escape=/ < filenames.txt
(
.   c\+\+py-tree-demo\/
)
$

--[ gen-compact-expr-cxxpy-depth-1-base0-array ]--------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=1 --trie=array "$@"; }
$ print a|trie
a
$ print a ab|trie
a
$ print a ab abc|trie
a
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a|b
$ print a bb ba c|trie
a|b|c
$ print a bb ba cc|trie
a|b|cc
$ print a bb ba ccc|trie
a|b|ccc
$ print a bb ba cde|trie
a|b|cde
$ print a bb ba cdef|trie
a|b|cdef
$ print a bb ba cdef cdefg|trie
a|b|cdef
$ print a bb bac cdef|trie
a|b|cdef
$ print a bbx ba ccc|trie
a|b|ccc
$ print a bbx bay ccc|trie
a|b|ccc
$ print a cde cdef|trie
a|cde
$ print a cde cdef cdefg|trie
a|cde
$ print a cde cdef cdefgh|trie
a|cde
$ print a cdef cdefg|trie
a|cdef
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b|ccc
$ print ab bb ba cde|trie
ab|b|cde
$ print ab bbx ba ccc|trie
ab|b|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b|ccc
$ print abcd abde abef|trie
ab
$ print abg a abc ab abd|trie
a
$ print ac ab|trie
a
$ print aef ae abg a abc ab abd|trie
a
$ print cde cdef cdefgh|trie
cde
$ print cdef cdefg|trie
cdef
$ print cdex cdfy cdgz cdhw|trie
cd
$ print ce cdex cdfy cdgz cdhw|trie
c
$ print pot potato pottery tattoo tempo|trie
pot|t
$

--[ gen-compact-expr-cxxpy-depth-1-base0-ternary ]------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=1 --trie=ternary "$@"; }
$ print a|trie
a
$ print a ab|trie
a
$ print a ab abc|trie
a
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a|b
$ print a bb ba c|trie
a|b|c
$ print a bb ba cc|trie
a|b|cc
$ print a bb ba ccc|trie
a|b|ccc
$ print a bb ba cde|trie
a|b|cde
$ print a bb ba cdef|trie
a|b|cdef
$ print a bb ba cdef cdefg|trie
a|b|cdef
$ print a bb bac cdef|trie
a|b|cdef
$ print a bbx ba ccc|trie
a|b|ccc
$ print a bbx bay ccc|trie
a|b|ccc
$ print a cde cdef|trie
a|cde
$ print a cde cdef cdefg|trie
a|cde
$ print a cde cdef cdefgh|trie
a|cde
$ print a cdef cdefg|trie
a|cdef
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b|ccc
$ print ab bb ba cde|trie
ab|b|cde
$ print ab bbx ba ccc|trie
ab|b|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b|ccc
$ print abcd abde abef|trie
ab
$ print abg a abc ab abd|trie
a
$ print ac ab|trie
a
$ print aef ae abg a abc ab abd|trie
a
$ print cde cdef cdefgh|trie
cde
$ print cdef cdefg|trie
cdef
$ print cdex cdfy cdgz cdhw|trie
cd
$ print ce cdex cdfy cdgz cdhw|trie
c
$ print pot potato pottery tattoo tempo|trie
pot|t
$

--[ gen-compact-expr-cxxpy-depth-1-base ]---------------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=1 --no-dots "$@"; }
$ print a ab abc abd ac|trie
a
$ print a ab abc abd ac|trie -t int
a
$ print a ab abc abd ac|trie -t float
a
$

--[ gen-compact-expr-cxxpy-depth-1-base-array ]---------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=1 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a
$ print a ab ac|trie
a
$ print a ab ac ad|trie
a
$ print a abd ac|trie
a
$ print a ab ac acd|trie
a
$ print a bb ba ccc|trie
a|b|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b|ccc
$ print abc abd acde|trie
a
$ print abc abd acde ac|trie
a
$ print abc abd acde acfg|trie
a
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c
$ print a abcd abcdefg h hijk|trie
a|h
$ print a abcd abcdefg abcdxyz h hijk|trie
a|h
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a|h
$

--[ gen-compact-expr-cxxpy-depth-1-base-ternary ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=1 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a
$ print a ab ac|trie
a
$ print a ab ac ad|trie
a
$ print a abd ac|trie
a
$ print a ab ac acd|trie
a
$ print a bb ba ccc|trie
a|b|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b|ccc
$ print abc abd acde|trie
a
$ print abc abd acde ac|trie
a
$ print abc abd acde acfg|trie
a
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c
$ print a abcd abcdefg h hijk|trie
a|h
$ print a abcd abcdefg abcdxyz h hijk|trie
a|h
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a|h
$

--[ gen-compact-expr-cxxpy-depth-1-alphabets-array ]----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=1 --trie=array < alphabets.txt
a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|r|s|t|u|v|wa|x|y|z
$

--[ gen-compact-expr-cxxpy-depth-1-alphabets-ternary ]--------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=1 --trie=ternary < alphabets.txt
a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|r|s|t|u|v|wa|x|y|z
$

--[ gen-compact-expr-cxxpy-depth-1-filenames-array ]----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=1 --trie=array --escape=/ < filenames.txt
c\+\+py-tree-demo\/
$

--[ gen-compact-expr-cxxpy-depth-1-filenames-ternary ]--------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=1 --trie=ternary --escape=/ < filenames.txt
c\+\+py-tree-demo\/
$

--[ gen-wide-expr-cxxpy-depth-2-base0-array ]-----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=2 --trie=array "$@"; }
$ print a|trie
(
    a
)
$ print a ab|trie
(
    a [
        b
    ]
)
$ print a ab abc|trie
(
    a [
        b
    ]
)
$ print a b|trie
(
    a |
    b
)
$ print a b abc bac abd|trie
(
    a [
        b
    ] |
    b [
        ac
    ]
)
$ print a bb ba c|trie
(
    a |
    b (
        a |
        b
    ) |
    c
)
$ print a bb ba cc|trie
(
    a |
    b (
        a |
        b
    ) |
    cc
)
$ print a bb ba ccc|trie
(
    a |
    b (
        a |
        b
    ) |
    ccc
)
$ print a bb ba cde|trie
(
    a |
    b (
        a |
        b
    ) |
    cde
)
$ print a bb ba cdef|trie
(
    a |
    b (
        a |
        b
    ) |
    cdef
)
$ print a bb ba cdef cdefg|trie
(
    a |
    b (
        a |
        b
    ) |
    cdef [
        g
    ]
)
$ print a bb bac cdef|trie
(
    a |
    b (
        ac |
        b
    ) |
    cdef
)
$ print a bbx ba ccc|trie
(
    a |
    b (
        a |
        bx
    ) |
    ccc
)
$ print a bbx bay ccc|trie
(
    a |
    b (
        ay |
        bx
    ) |
    ccc
)
$ print a cde cdef|trie
(
    a |
    cde [
        f
    ]
)
$ print a cde cdef cdefg|trie
(
    a |
    cde [
        f
    ]
)
$ print a cde cdef cdefgh|trie
(
    a |
    cde [
        f
    ]
)
$ print a cdef cdefg|trie
(
    a |
    cdef [
        g
    ]
)
$ print ab|trie
(
    ab
)
$ print ab bb ba ccc|trie
(
    ab |
    b (
        a |
        b
    ) |
    ccc
)
$ print ab bb ba cde|trie
(
    ab |
    b (
        a |
        b
    ) |
    cde
)
$ print ab bbx ba ccc|trie
(
    ab |
    b (
        a |
        bx
    ) |
    ccc
)
$ print ab c|trie
(
    ab |
    c
)
$ print abc bb ba ccc|trie
(
    abc |
    b (
        a |
        b
    ) |
    ccc
)
$ print abcd abde abef|trie
(
    ab (
        cd |
        de |
        ef
    )
)
$ print abg a abc ab abd|trie
(
    a [
        b
    ]
)
$ print ac ab|trie
(
    a (
        b |
        c
    )
)
$ print aef ae abg a abc ab abd|trie
(
    a [
        b |
        e
    ]
)
$ print cde cdef cdefgh|trie
(
    cde [
        f
    ]
)
$ print cdef cdefg|trie
(
    cdef [
        g
    ]
)
$ print cdex cdfy cdgz cdhw|trie
(
    cd (
        ex |
        fy |
        gz |
        hw
    )
)
$ print ce cdex cdfy cdgz cdhw|trie
(
    c (
        d |
        e
    )
)
$ print pot potato pottery tattoo tempo|trie
(
    pot [
        ato |
        tery
    ] |
    t (
        attoo |
        empo
    )
)
$

--[ gen-wide-expr-cxxpy-depth-2-base0-ternary ]---------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=2 --trie=ternary "$@"; }
$ print a|trie
(
    a
)
$ print a ab|trie
(
    a [
        b
    ]
)
$ print a ab abc|trie
(
    a [
        b
    ]
)
$ print a b|trie
(
    a |
    b
)
$ print a b abc bac abd|trie
(
    a [
        b
    ] |
    b [
        ac
    ]
)
$ print a bb ba c|trie
(
    a |
    b (
        a |
        b
    ) |
    c
)
$ print a bb ba cc|trie
(
    a |
    b (
        a |
        b
    ) |
    cc
)
$ print a bb ba ccc|trie
(
    a |
    b (
        a |
        b
    ) |
    ccc
)
$ print a bb ba cde|trie
(
    a |
    b (
        a |
        b
    ) |
    cde
)
$ print a bb ba cdef|trie
(
    a |
    b (
        a |
        b
    ) |
    cdef
)
$ print a bb ba cdef cdefg|trie
(
    a |
    b (
        a |
        b
    ) |
    cdef [
        g
    ]
)
$ print a bb bac cdef|trie
(
    a |
    b (
        ac |
        b
    ) |
    cdef
)
$ print a bbx ba ccc|trie
(
    a |
    b (
        a |
        bx
    ) |
    ccc
)
$ print a bbx bay ccc|trie
(
    a |
    b (
        ay |
        bx
    ) |
    ccc
)
$ print a cde cdef|trie
(
    a |
    cde [
        f
    ]
)
$ print a cde cdef cdefg|trie
(
    a |
    cde [
        f
    ]
)
$ print a cde cdef cdefgh|trie
(
    a |
    cde [
        f
    ]
)
$ print a cdef cdefg|trie
(
    a |
    cdef [
        g
    ]
)
$ print ab|trie
(
    ab
)
$ print ab bb ba ccc|trie
(
    ab |
    b (
        a |
        b
    ) |
    ccc
)
$ print ab bb ba cde|trie
(
    ab |
    b (
        a |
        b
    ) |
    cde
)
$ print ab bbx ba ccc|trie
(
    ab |
    b (
        a |
        bx
    ) |
    ccc
)
$ print ab c|trie
(
    ab |
    c
)
$ print abc bb ba ccc|trie
(
    abc |
    b (
        a |
        b
    ) |
    ccc
)
$ print abcd abde abef|trie
(
    ab (
        cd |
        de |
        ef
    )
)
$ print abg a abc ab abd|trie
(
    a [
        b
    ]
)
$ print ac ab|trie
(
    a (
        b |
        c
    )
)
$ print aef ae abg a abc ab abd|trie
(
    a [
        b |
        e
    ]
)
$ print cde cdef cdefgh|trie
(
    cde [
        f
    ]
)
$ print cdef cdefg|trie
(
    cdef [
        g
    ]
)
$ print cdex cdfy cdgz cdhw|trie
(
    cd (
        ex |
        fy |
        gz |
        hw
    )
)
$ print ce cdex cdfy cdgz cdhw|trie
(
    c (
        d |
        e
    )
)
$ print pot potato pottery tattoo tempo|trie
(
    pot [
        ato |
        tery
    ] |
    t (
        attoo |
        empo
    )
)
$

--[ gen-wide-expr-cxxpy-depth-2-base ]------------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=2 --no-dots "$@"; }
$ print a ab abc abd ac|trie
(
    a [
        b |
        c
    ]
)
$ print a ab abc abd ac|trie -t int
(
    a [
        b |
        c
    ]
)
$ print a ab abc abd ac|trie -t float
(
    a [
        b |
        c
    ]
)
$

--[ gen-wide-expr-cxxpy-depth-2-base-array ]------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=2 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(
.   a
)
$ print a b|trie
(
.   a |
.   b
)
$ print a b c|trie
(
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(
.   a [
.   .   b
.   ]
)
$ print a ab ac|trie
(
.   a [
.   .   b |
.   .   c
.   ]
)
$ print a ab ac ad|trie
(
.   a [
.   .   b |
.   .   c |
.   .   d
.   ]
)
$ print a abd ac|trie
(
.   a [
.   .   bd |
.   .   c
.   ]
)
$ print a ab ac acd|trie
(
.   a [
.   .   b |
.   .   c
.   ]
)
$ print a bb ba ccc|trie
(
.   a |
.   b (
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print a bb ccc|trie
(
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(
.   a |
.   b (
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print abc abd acde|trie
(
.   a (
.   .   b |
.   .   cde
.   )
)
$ print abc abd acde ac|trie
(
.   a (
.   .   b |
.   .   c
.   )
)
$ print abc abd acde acfg|trie
(
.   a (
.   .   b |
.   .   c
.   )
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c (
.   .   de |
.   .   fg
.   )
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c (
.   .   fg |
.   .   ge
.   )
)
$ print a abcd abcdefg h hijk|trie
(
.   a [
.   .   bcd
.   ] |
.   h [
.   .   ijk
.   ]
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(
.   a [
.   .   bcd
.   ] |
.   h [
.   .   ijk
.   ]
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(
.   a [
.   .   bcd
.   ] |
.   h [
.   .   ijk |
.   .   lm
.   ]
)
$

--[ gen-wide-expr-cxxpy-depth-2-base-ternary ]----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=cxxpy --depth=2 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(
.   a
)
$ print a b|trie
(
.   a |
.   b
)
$ print a b c|trie
(
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(
.   a [
.   .   b
.   ]
)
$ print a ab ac|trie
(
.   a [
.   .   b |
.   .   c
.   ]
)
$ print a ab ac ad|trie
(
.   a [
.   .   b |
.   .   c |
.   .   d
.   ]
)
$ print a abd ac|trie
(
.   a [
.   .   bd |
.   .   c
.   ]
)
$ print a ab ac acd|trie
(
.   a [
.   .   b |
.   .   c
.   ]
)
$ print a bb ba ccc|trie
(
.   a |
.   b (
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print a bb ccc|trie
(
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(
.   a |
.   b (
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print abc abd acde|trie
(
.   a (
.   .   b |
.   .   cde
.   )
)
$ print abc abd acde ac|trie
(
.   a (
.   .   b |
.   .   c
.   )
)
$ print abc abd acde acfg|trie
(
.   a (
.   .   b |
.   .   c
.   )
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c (
.   .   de |
.   .   fg
.   )
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(
.   c (
.   .   fg |
.   .   ge
.   )
)
$ print a abcd abcdefg h hijk|trie
(
.   a [
.   .   bcd
.   ] |
.   h [
.   .   ijk
.   ]
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(
.   a [
.   .   bcd
.   ] |
.   h [
.   .   ijk
.   ]
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(
.   a [
.   .   bcd
.   ] |
.   h [
.   .   ijk |
.   .   lm
.   ]
)
$

--[ gen-wide-expr-cxxpy-depth-2-alphabets-array ]-------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=2 --trie=array < alphabets.txt
(
.   a (
.   .   a |
.   .   f |
.   .   gq |
.   .   k |
.   .   m |
.   .   r |
.   .   s |
.   .   z
.   ) |
.   b (
.   .   as |
.   .   e |
.   .   g |
.   .   m |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   yn
.   ) |
.   c (
.   .   a |
.   .   gg |
.   .   hr |
.   .   s |
.   .   y
.   ) |
.   d (
.   .   a |
.   .   e |
.   .   je |
.   .   ua |
.   .   yo |
.   .   z
.   ) |
.   e (
.   .   bu |
.   .   e |
.   .   l |
.   .   n |
.   .   o |
.   .   s |
.   .   t |
.   .   u |
.   .   wo
.   ) |
.   f (
.   .   a |
.   .   f |
.   .   i |
.   .   o |
.   .   r |
.   .   ur |
.   .   y
.   ) |
.   g (
.   .   a |
.   .   d |
.   .   l |
.   .   sw |
.   .   u |
.   .   v
.   ) |
.   h (
.   .   a |
.   .   e |
.   .   i |
.   .   r |
.   .   u |
.   .   y
.   ) |
.   i (
.   .   a |
.   .   d |
.   .   g |
.   .   i |
.   .   s |
.   .   t
.   ) |
.   j (
.   .   a |
.   .   go |
.   .   mc
.   ) |
.   k (
.   .   a |
.   .   de |
.   .   ea |
.   .   hq |
.   .   i |
.   .   k |
.   .   l |
.   .   m |
.   .   n |
.   .   o |
.   .   s |
.   .   w |
.   .   y
.   ) |
.   l (
.   .   ag |
.   .   g |
.   .   kt |
.   .   n |
.   .   o |
.   .   t |
.   .   u |
.   .   v
.   ) |
.   m (
.   .   as |
.   .   er |
.   .   fe |
.   .   g |
.   .   k |
.   .   l |
.   .   n |
.   .   r |
.   .   s |
.   .   t |
.   .   ua |
.   .   y
.   ) |
.   n (
.   .   aq |
.   .   b |
.   .   d |
.   .   e |
.   .   l |
.   .   mg |
.   .   n |
.   .   r |
.   .   so |
.   .   us |
.   .   yn
.   ) |
.   o (
.   .   m |
.   .   r |
.   .   s
.   ) |
.   p (
.   .   a |
.   .   l |
.   .   s |
.   .   t
.   ) |
.   r (
.   .   m |
.   .   n |
.   .   o |
.   .   u |
.   .   w
.   ) |
.   s (
.   .   a |
.   .   bp |
.   .   e |
.   .   g |
.   .   hi |
.   .   i |
.   .   k |
.   .   l |
.   .   n |
.   .   o |
.   .   q |
.   .   r |
.   .   s |
.   .   t |
.   .   v |
.   .   w
.   ) |
.   t (
.   .   a |
.   .   e |
.   .   g |
.   .   h |
.   .   i |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   wq |
.   .   zm
.   ) |
.   u (
.   .   g |
.   .   k |
.   .   r |
.   .   z
.   ) |
.   v (
.   .   ai_Latn |
.   .   e |
.   .   i |
.   .   o |
.   .   un
.   ) |
.   wa (
.   .   e |
.   .   l
.   ) |
.   x (
.   .   h |
.   .   og
.   ) |
.   y (
.   .   av |
.   .   o
.   ) |
.   z (
.   .   gh |
.   .   h |
.   .   u
.   )
)
$

--[ gen-wide-expr-cxxpy-depth-2-alphabets-ternary ]-----------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=2 --trie=ternary < alphabets.txt
(
.   a (
.   .   a |
.   .   f |
.   .   gq |
.   .   k |
.   .   m |
.   .   r |
.   .   s |
.   .   z
.   ) |
.   b (
.   .   as |
.   .   e |
.   .   g |
.   .   m |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   yn
.   ) |
.   c (
.   .   a |
.   .   gg |
.   .   hr |
.   .   s |
.   .   y
.   ) |
.   d (
.   .   a |
.   .   e |
.   .   je |
.   .   ua |
.   .   yo |
.   .   z
.   ) |
.   e (
.   .   bu |
.   .   e |
.   .   l |
.   .   n |
.   .   o |
.   .   s |
.   .   t |
.   .   u |
.   .   wo
.   ) |
.   f (
.   .   a |
.   .   f |
.   .   i |
.   .   o |
.   .   r |
.   .   ur |
.   .   y
.   ) |
.   g (
.   .   a |
.   .   d |
.   .   l |
.   .   sw |
.   .   u |
.   .   v
.   ) |
.   h (
.   .   a |
.   .   e |
.   .   i |
.   .   r |
.   .   u |
.   .   y
.   ) |
.   i (
.   .   a |
.   .   d |
.   .   g |
.   .   i |
.   .   s |
.   .   t
.   ) |
.   j (
.   .   a |
.   .   go |
.   .   mc
.   ) |
.   k (
.   .   a |
.   .   de |
.   .   ea |
.   .   hq |
.   .   i |
.   .   k |
.   .   l |
.   .   m |
.   .   n |
.   .   o |
.   .   s |
.   .   w |
.   .   y
.   ) |
.   l (
.   .   ag |
.   .   g |
.   .   kt |
.   .   n |
.   .   o |
.   .   t |
.   .   u |
.   .   v
.   ) |
.   m (
.   .   as |
.   .   er |
.   .   fe |
.   .   g |
.   .   k |
.   .   l |
.   .   n |
.   .   r |
.   .   s |
.   .   t |
.   .   ua |
.   .   y
.   ) |
.   n (
.   .   aq |
.   .   b |
.   .   d |
.   .   e |
.   .   l |
.   .   mg |
.   .   n |
.   .   r |
.   .   so |
.   .   us |
.   .   yn
.   ) |
.   o (
.   .   m |
.   .   r |
.   .   s
.   ) |
.   p (
.   .   a |
.   .   l |
.   .   s |
.   .   t
.   ) |
.   r (
.   .   m |
.   .   n |
.   .   o |
.   .   u |
.   .   w
.   ) |
.   s (
.   .   a |
.   .   bp |
.   .   e |
.   .   g |
.   .   hi |
.   .   i |
.   .   k |
.   .   l |
.   .   n |
.   .   o |
.   .   q |
.   .   r |
.   .   s |
.   .   t |
.   .   v |
.   .   w
.   ) |
.   t (
.   .   a |
.   .   e |
.   .   g |
.   .   h |
.   .   i |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   wq |
.   .   zm
.   ) |
.   u (
.   .   g |
.   .   k |
.   .   r |
.   .   z
.   ) |
.   v (
.   .   ai_Latn |
.   .   e |
.   .   i |
.   .   o |
.   .   un
.   ) |
.   wa (
.   .   e |
.   .   l
.   ) |
.   x (
.   .   h |
.   .   og
.   ) |
.   y (
.   .   av |
.   .   o
.   ) |
.   z (
.   .   gh |
.   .   h |
.   .   u
.   )
)
$

--[ gen-wide-expr-cxxpy-depth-2-filenames-array ]-------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=2 --trie=array --escape=/ < filenames.txt
(
.   c\+\+py-tree-demo\/ (
.   .   .src- |
.   .   bin.patch |
.   .   c\+\+py
.   )
)
$

--[ gen-wide-expr-cxxpy-depth-2-filenames-ternary ]-----------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=cxxpy --depth=2 --trie=ternary --escape=/ < filenames.txt
(
.   c\+\+py-tree-demo\/ (
.   .   .src- |
.   .   bin.patch |
.   .   c\+\+py
.   )
)
$

--[ gen-compact-expr-cxxpy-depth-2-base0-array ]--------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=2 --trie=array "$@"; }
$ print a|trie
a
$ print a ab|trie
a[b]
$ print a ab abc|trie
a[b]
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a[b]|b[ac]
$ print a bb ba c|trie
a|b(a|b)|c
$ print a bb ba cc|trie
a|b(a|b)|cc
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print a bb ba cde|trie
a|b(a|b)|cde
$ print a bb ba cdef|trie
a|b(a|b)|cdef
$ print a bb ba cdef cdefg|trie
a|b(a|b)|cdef[g]
$ print a bb bac cdef|trie
a|b(ac|b)|cdef
$ print a bbx ba ccc|trie
a|b(a|bx)|ccc
$ print a bbx bay ccc|trie
a|b(ay|bx)|ccc
$ print a cde cdef|trie
a|cde[f]
$ print a cde cdef cdefg|trie
a|cde[f]
$ print a cde cdef cdefgh|trie
a|cde[f]
$ print a cdef cdefg|trie
a|cdef[g]
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b(a|b)|ccc
$ print ab bb ba cde|trie
ab|b(a|b)|cde
$ print ab bbx ba ccc|trie
ab|b(a|bx)|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b(a|b)|ccc
$ print abcd abde abef|trie
ab(cd|de|ef)
$ print abg a abc ab abd|trie
a[b]
$ print ac ab|trie
a(b|c)
$ print aef ae abg a abc ab abd|trie
a[b|e]
$ print cde cdef cdefgh|trie
cde[f]
$ print cdef cdefg|trie
cdef[g]
$ print cdex cdfy cdgz cdhw|trie
cd(ex|fy|gz|hw)
$ print ce cdex cdfy cdgz cdhw|trie
c(d|e)
$ print pot potato pottery tattoo tempo|trie
pot[ato|tery]|t(attoo|empo)
$

--[ gen-compact-expr-cxxpy-depth-2-base0-ternary ]------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=2 --trie=ternary "$@"; }
$ print a|trie
a
$ print a ab|trie
a[b]
$ print a ab abc|trie
a[b]
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a[b]|b[ac]
$ print a bb ba c|trie
a|b(a|b)|c
$ print a bb ba cc|trie
a|b(a|b)|cc
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print a bb ba cde|trie
a|b(a|b)|cde
$ print a bb ba cdef|trie
a|b(a|b)|cdef
$ print a bb ba cdef cdefg|trie
a|b(a|b)|cdef[g]
$ print a bb bac cdef|trie
a|b(ac|b)|cdef
$ print a bbx ba ccc|trie
a|b(a|bx)|ccc
$ print a bbx bay ccc|trie
a|b(ay|bx)|ccc
$ print a cde cdef|trie
a|cde[f]
$ print a cde cdef cdefg|trie
a|cde[f]
$ print a cde cdef cdefgh|trie
a|cde[f]
$ print a cdef cdefg|trie
a|cdef[g]
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b(a|b)|ccc
$ print ab bb ba cde|trie
ab|b(a|b)|cde
$ print ab bbx ba ccc|trie
ab|b(a|bx)|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b(a|b)|ccc
$ print abcd abde abef|trie
ab(cd|de|ef)
$ print abg a abc ab abd|trie
a[b]
$ print ac ab|trie
a(b|c)
$ print aef ae abg a abc ab abd|trie
a[b|e]
$ print cde cdef cdefgh|trie
cde[f]
$ print cdef cdefg|trie
cdef[g]
$ print cdex cdfy cdgz cdhw|trie
cd(ex|fy|gz|hw)
$ print ce cdex cdfy cdgz cdhw|trie
c(d|e)
$ print pot potato pottery tattoo tempo|trie
pot[ato|tery]|t(attoo|empo)
$

--[ gen-compact-expr-cxxpy-depth-2-base ]---------------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=2 --no-dots "$@"; }
$ print a ab abc abd ac|trie
a[b|c]
$ print a ab abc abd ac|trie -t int
a[b|c]
$ print a ab abc abd ac|trie -t float
a[b|c]
$

--[ gen-compact-expr-cxxpy-depth-2-base-array ]---------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=2 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a[b]
$ print a ab ac|trie
a[b|c]
$ print a ab ac ad|trie
a[b|c|d]
$ print a abd ac|trie
a[bd|c]
$ print a ab ac acd|trie
a[b|c]
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print abc abd acde|trie
a(b|cde)
$ print abc abd acde ac|trie
a(b|c)
$ print abc abd acde acfg|trie
a(b|c)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(de|fg)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(fg|ge)
$ print a abcd abcdefg h hijk|trie
a[bcd]|h[ijk]
$ print a abcd abcdefg abcdxyz h hijk|trie
a[bcd]|h[ijk]
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a[bcd]|h[ijk|lm]
$

--[ gen-compact-expr-cxxpy-depth-2-base-ternary ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=cxxpy --depth=2 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a[b]
$ print a ab ac|trie
a[b|c]
$ print a ab ac ad|trie
a[b|c|d]
$ print a abd ac|trie
a[bd|c]
$ print a ab ac acd|trie
a[b|c]
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b(a|b)|ccc
$ print abc abd acde|trie
a(b|cde)
$ print abc abd acde ac|trie
a(b|c)
$ print abc abd acde acfg|trie
a(b|c)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(de|fg)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(fg|ge)
$ print a abcd abcdefg h hijk|trie
a[bcd]|h[ijk]
$ print a abcd abcdefg abcdxyz h hijk|trie
a[bcd]|h[ijk]
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a[bcd]|h[ijk|lm]
$

--[ gen-compact-expr-cxxpy-depth-2-alphabets-array ]----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=2 --trie=array < alphabets.txt
a(a|f|gq|k|m|r|s|z)|b(as|e|g|m|n|o|r|s|yn)|c(a|gg|hr|s|y)|d(a|e|je|ua|yo|z)|e(bu|e|l|n|o|s|t|u|wo)|f(a|f|i|o|r|ur|y)|g(a|d|l|sw|u|v)|h(a|e|i|r|u|y)|i(a|d|g|i|s|t)|j(a|go|mc)|k(a|de|ea|hq|i|k|l|m|n|o|s|w|y)|l(ag|g|kt|n|o|t|u|v)|m(as|er|fe|g|k|l|n|r|s|t|ua|y)|n(aq|b|d|e|l|mg|n|r|so|us|yn)|o(m|r|s)|p(a|l|s|t)|r(m|n|o|u|w)|s(a|bp|e|g|hi|i|k|l|n|o|q|r|s|t|v|w)|t(a|e|g|h|i|n|o|r|s|wq|zm)|u(g|k|r|z)|v(ai_Latn|e|i|o|un)|wa(e|l)|x(h|og)|y(av|o)|z(gh|h|u)
$

--[ gen-compact-expr-cxxpy-depth-2-alphabets-ternary ]--------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=2 --trie=ternary < alphabets.txt
a(a|f|gq|k|m|r|s|z)|b(as|e|g|m|n|o|r|s|yn)|c(a|gg|hr|s|y)|d(a|e|je|ua|yo|z)|e(bu|e|l|n|o|s|t|u|wo)|f(a|f|i|o|r|ur|y)|g(a|d|l|sw|u|v)|h(a|e|i|r|u|y)|i(a|d|g|i|s|t)|j(a|go|mc)|k(a|de|ea|hq|i|k|l|m|n|o|s|w|y)|l(ag|g|kt|n|o|t|u|v)|m(as|er|fe|g|k|l|n|r|s|t|ua|y)|n(aq|b|d|e|l|mg|n|r|so|us|yn)|o(m|r|s)|p(a|l|s|t)|r(m|n|o|u|w)|s(a|bp|e|g|hi|i|k|l|n|o|q|r|s|t|v|w)|t(a|e|g|h|i|n|o|r|s|wq|zm)|u(g|k|r|z)|v(ai_Latn|e|i|o|un)|wa(e|l)|x(h|og)|y(av|o)|z(gh|h|u)
$

--[ gen-compact-expr-cxxpy-depth-2-filenames-array ]----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=2 --trie=array --escape=/ < filenames.txt
c\+\+py-tree-demo\/(.src-|bin.patch|c\+\+py)
$

--[ gen-compact-expr-cxxpy-depth-2-filenames-ternary ]--------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=cxxpy --depth=2 --trie=ternary --escape=/ < filenames.txt
c\+\+py-tree-demo\/(.src-|bin.patch|c\+\+py)
$

--[ gen-wide-expr-perl-depth-0-base0-array ]------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=0 --trie=array "$@"; }
$ print a|trie
(?:
    a
)
$ print a ab|trie
(?:
    a (?:
        b
    )?
)
$ print a ab abc|trie
(?:
    a (?:
        b (?:
            c
        )?
    )?
)
$ print a b|trie
(?:
    a |
    b
)
$ print a b abc bac abd|trie
(?:
    a (?:
        b (?:
            c |
            d
        )
    )? |
    b (?:
        ac
    )?
)
$ print a bb ba c|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    c
)
$ print a bb ba cc|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cc
)
$ print a bb ba ccc|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print a bb ba cde|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cde
)
$ print a bb ba cdef|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cdef
)
$ print a bb ba cdef cdefg|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cdef (?:
        g
    )?
)
$ print a bb bac cdef|trie
(?:
    a |
    b (?:
        ac |
        b
    ) |
    cdef
)
$ print a bbx ba ccc|trie
(?:
    a |
    b (?:
        a |
        bx
    ) |
    ccc
)
$ print a bbx bay ccc|trie
(?:
    a |
    b (?:
        ay |
        bx
    ) |
    ccc
)
$ print a cde cdef|trie
(?:
    a |
    cde (?:
        f
    )?
)
$ print a cde cdef cdefg|trie
(?:
    a |
    cde (?:
        f (?:
            g
        )?
    )?
)
$ print a cde cdef cdefgh|trie
(?:
    a |
    cde (?:
        f (?:
            gh
        )?
    )?
)
$ print a cdef cdefg|trie
(?:
    a |
    cdef (?:
        g
    )?
)
$ print ab|trie
(?:
    ab
)
$ print ab bb ba ccc|trie
(?:
    ab |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print ab bb ba cde|trie
(?:
    ab |
    b (?:
        a |
        b
    ) |
    cde
)
$ print ab bbx ba ccc|trie
(?:
    ab |
    b (?:
        a |
        bx
    ) |
    ccc
)
$ print ab c|trie
(?:
    ab |
    c
)
$ print abc bb ba ccc|trie
(?:
    abc |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print abcd abde abef|trie
(?:
    ab (?:
        cd |
        de |
        ef
    )
)
$ print abg a abc ab abd|trie
(?:
    a (?:
        b (?:
            c |
            d |
            g
        )?
    )?
)
$ print ac ab|trie
(?:
    a (?:
        b |
        c
    )
)
$ print aef ae abg a abc ab abd|trie
(?:
    a (?:
        b (?:
            c |
            d |
            g
        )? |
        e (?:
            f
        )?
    )?
)
$ print cde cdef cdefgh|trie
(?:
    cde (?:
        f (?:
            gh
        )?
    )?
)
$ print cdef cdefg|trie
(?:
    cdef (?:
        g
    )?
)
$ print cdex cdfy cdgz cdhw|trie
(?:
    cd (?:
        ex |
        fy |
        gz |
        hw
    )
)
$ print ce cdex cdfy cdgz cdhw|trie
(?:
    c (?:
        d (?:
            ex |
            fy |
            gz |
            hw
        ) |
        e
    )
)
$ print pot potato pottery tattoo tempo|trie
(?:
    pot (?:
        ato |
        tery
    )? |
    t (?:
        attoo |
        empo
    )
)
$

--[ gen-wide-expr-perl-depth-0-base0-ternary ]----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=0 --trie=ternary "$@"; }
$ print a|trie
(?:
    a
)
$ print a ab|trie
(?:
    a (?:
        b
    )?
)
$ print a ab abc|trie
(?:
    a (?:
        b (?:
            c
        )?
    )?
)
$ print a b|trie
(?:
    a |
    b
)
$ print a b abc bac abd|trie
(?:
    a (?:
        b (?:
            c |
            d
        )
    )? |
    b (?:
        ac
    )?
)
$ print a bb ba c|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    c
)
$ print a bb ba cc|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cc
)
$ print a bb ba ccc|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print a bb ba cde|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cde
)
$ print a bb ba cdef|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cdef
)
$ print a bb ba cdef cdefg|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cdef (?:
        g
    )?
)
$ print a bb bac cdef|trie
(?:
    a |
    b (?:
        ac |
        b
    ) |
    cdef
)
$ print a bbx ba ccc|trie
(?:
    a |
    b (?:
        a |
        bx
    ) |
    ccc
)
$ print a bbx bay ccc|trie
(?:
    a |
    b (?:
        ay |
        bx
    ) |
    ccc
)
$ print a cde cdef|trie
(?:
    a |
    cde (?:
        f
    )?
)
$ print a cde cdef cdefg|trie
(?:
    a |
    cde (?:
        f (?:
            g
        )?
    )?
)
$ print a cde cdef cdefgh|trie
(?:
    a |
    cde (?:
        f (?:
            gh
        )?
    )?
)
$ print a cdef cdefg|trie
(?:
    a |
    cdef (?:
        g
    )?
)
$ print ab|trie
(?:
    ab
)
$ print ab bb ba ccc|trie
(?:
    ab |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print ab bb ba cde|trie
(?:
    ab |
    b (?:
        a |
        b
    ) |
    cde
)
$ print ab bbx ba ccc|trie
(?:
    ab |
    b (?:
        a |
        bx
    ) |
    ccc
)
$ print ab c|trie
(?:
    ab |
    c
)
$ print abc bb ba ccc|trie
(?:
    abc |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print abcd abde abef|trie
(?:
    ab (?:
        cd |
        de |
        ef
    )
)
$ print abg a abc ab abd|trie
(?:
    a (?:
        b (?:
            c |
            d |
            g
        )?
    )?
)
$ print ac ab|trie
(?:
    a (?:
        b |
        c
    )
)
$ print aef ae abg a abc ab abd|trie
(?:
    a (?:
        b (?:
            c |
            d |
            g
        )? |
        e (?:
            f
        )?
    )?
)
$ print cde cdef cdefgh|trie
(?:
    cde (?:
        f (?:
            gh
        )?
    )?
)
$ print cdef cdefg|trie
(?:
    cdef (?:
        g
    )?
)
$ print cdex cdfy cdgz cdhw|trie
(?:
    cd (?:
        ex |
        fy |
        gz |
        hw
    )
)
$ print ce cdex cdfy cdgz cdhw|trie
(?:
    c (?:
        d (?:
            ex |
            fy |
            gz |
            hw
        ) |
        e
    )
)
$ print pot potato pottery tattoo tempo|trie
(?:
    pot (?:
        ato |
        tery
    )? |
    t (?:
        attoo |
        empo
    )
)
$

--[ gen-wide-expr-perl-depth-0-base ]-------------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=0 --no-dots "$@"; }
$ print a ab abc abd ac|trie
(?:
    a (?:
        b (?:
            c |
            d
        )? |
        c
    )?
)
$ print a ab abc abd ac|trie -t int
(?:
    a (?:
        b (?:
            c |
            d
        )? |
        c
    )?
)
$ print a ab abc abd ac|trie -t float
(?:
    a (?:
        b (?:
            c |
            d
        )? |
        c
    )?
)
$

--[ gen-wide-expr-perl-depth-0-base-array ]-------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=0 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(?:
.   a
)
$ print a b|trie
(?:
.   a |
.   b
)
$ print a b c|trie
(?:
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(?:
.   a (?:
.   .   b (?:
.   .   .   c
.   .   )?
.   )?
)
$ print a ab ac|trie
(?:
.   a (?:
.   .   b |
.   .   c
.   )?
)
$ print a ab ac ad|trie
(?:
.   a (?:
.   .   b |
.   .   c |
.   .   d
.   )?
)
$ print a abd ac|trie
(?:
.   a (?:
.   .   bd |
.   .   c
.   )?
)
$ print a ab ac acd|trie
(?:
.   a (?:
.   .   b |
.   .   c (?:
.   .   .   d
.   .   )?
.   )?
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b (?:
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print a bb ccc|trie
(?:
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b (?:
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print abc abd acde|trie
(?:
.   a (?:
.   .   b (?:
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   cde
.   )
)
$ print abc abd acde ac|trie
(?:
.   a (?:
.   .   b (?:
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   c (?:
.   .   .   de
.   .   )?
.   )
)
$ print abc abd acde acfg|trie
(?:
.   a (?:
.   .   b (?:
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   c (?:
.   .   .   de |
.   .   .   fg
.   .   )
.   )
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c (?:
.   .   de |
.   .   fg (?:
.   .   .   x (?:
.   .   .   .   y (?:
.   .   .   .   .   z
.   .   .   .   )? |
.   .   .   .   zzz
.   .   .   )?
.   .   )?
.   )
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c (?:
.   .   fg (?:
.   .   .   x (?:
.   .   .   .   y (?:
.   .   .   .   .   z
.   .   .   .   )? |
.   .   .   .   zzz
.   .   .   )?
.   .   )? |
.   .   ge
.   )
)
$ print a abcd abcdefg h hijk|trie
(?:
.   a (?:
.   .   bcd (?:
.   .   .   efg
.   .   )?
.   )? |
.   h (?:
.   .   ijk
.   )?
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(?:
.   a (?:
.   .   bcd (?:
.   .   .   efg |
.   .   .   xyz
.   .   )?
.   )? |
.   h (?:
.   .   ijk
.   )?
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(?:
.   a (?:
.   .   bcd (?:
.   .   .   efg |
.   .   .   xyz
.   .   )?
.   )? |
.   h (?:
.   .   ijk |
.   .   lm
.   )?
)
$

--[ gen-wide-expr-perl-depth-0-base-ternary ]-----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=0 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(?:
.   a
)
$ print a b|trie
(?:
.   a |
.   b
)
$ print a b c|trie
(?:
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(?:
.   a (?:
.   .   b (?:
.   .   .   c
.   .   )?
.   )?
)
$ print a ab ac|trie
(?:
.   a (?:
.   .   b |
.   .   c
.   )?
)
$ print a ab ac ad|trie
(?:
.   a (?:
.   .   b |
.   .   c |
.   .   d
.   )?
)
$ print a abd ac|trie
(?:
.   a (?:
.   .   bd |
.   .   c
.   )?
)
$ print a ab ac acd|trie
(?:
.   a (?:
.   .   b |
.   .   c (?:
.   .   .   d
.   .   )?
.   )?
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b (?:
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print a bb ccc|trie
(?:
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b (?:
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print abc abd acde|trie
(?:
.   a (?:
.   .   b (?:
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   cde
.   )
)
$ print abc abd acde ac|trie
(?:
.   a (?:
.   .   b (?:
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   c (?:
.   .   .   de
.   .   )?
.   )
)
$ print abc abd acde acfg|trie
(?:
.   a (?:
.   .   b (?:
.   .   .   c |
.   .   .   d
.   .   ) |
.   .   c (?:
.   .   .   de |
.   .   .   fg
.   .   )
.   )
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c (?:
.   .   de |
.   .   fg (?:
.   .   .   x (?:
.   .   .   .   y (?:
.   .   .   .   .   z
.   .   .   .   )? |
.   .   .   .   zzz
.   .   .   )?
.   .   )?
.   )
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c (?:
.   .   fg (?:
.   .   .   x (?:
.   .   .   .   y (?:
.   .   .   .   .   z
.   .   .   .   )? |
.   .   .   .   zzz
.   .   .   )?
.   .   )? |
.   .   ge
.   )
)
$ print a abcd abcdefg h hijk|trie
(?:
.   a (?:
.   .   bcd (?:
.   .   .   efg
.   .   )?
.   )? |
.   h (?:
.   .   ijk
.   )?
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(?:
.   a (?:
.   .   bcd (?:
.   .   .   efg |
.   .   .   xyz
.   .   )?
.   )? |
.   h (?:
.   .   ijk
.   )?
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(?:
.   a (?:
.   .   bcd (?:
.   .   .   efg |
.   .   .   xyz
.   .   )?
.   )? |
.   h (?:
.   .   ijk |
.   .   lm
.   )?
)
$

--[ gen-wide-expr-perl-depth-0-alphabets-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=0 --trie=array < alphabets.txt
(?:
.   a (?:
.   .   a |
.   .   f |
.   .   gq |
.   .   k |
.   .   m |
.   .   r |
.   .   s (?:
.   .   .   a |
.   .   .   t
.   .   )? |
.   .   z (?:
.   .   .   _Cyrl
.   .   )?
.   ) |
.   b (?:
.   .   as |
.   .   e (?:
.   .   .   m |
.   .   .   z
.   .   )? |
.   .   g |
.   .   m |
.   .   n |
.   .   o |
.   .   r (?:
.   .   .   x
.   .   )? |
.   .   s (?:
.   .   .   _Cyrl
.   .   )? |
.   .   yn
.   ) |
.   c (?:
.   .   a |
.   .   gg |
.   .   hr |
.   .   s |
.   .   y
.   ) |
.   d (?:
.   .   a (?:
.   .   .   v
.   .   )? |
.   .   e |
.   .   je |
.   .   ua |
.   .   yo |
.   .   z
.   ) |
.   e (?:
.   .   bu |
.   .   e |
.   .   l |
.   .   n |
.   .   o |
.   .   s |
.   .   t |
.   .   u |
.   .   wo
.   ) |
.   f (?:
.   .   a |
.   .   f |
.   .   i (?:
.   .   .   l
.   .   )? |
.   .   o |
.   .   r |
.   .   ur |
.   .   y
.   ) |
.   g (?:
.   .   a |
.   .   d |
.   .   l |
.   .   sw |
.   .   u (?:
.   .   .   z
.   .   )? |
.   .   v
.   ) |
.   h (?:
.   .   a (?:
.   .   .   w
.   .   )? |
.   .   e |
.   .   i |
.   .   r |
.   .   u |
.   .   y
.   ) |
.   i (?:
.   .   a |
.   .   d |
.   .   g |
.   .   i |
.   .   s |
.   .   t
.   ) |
.   j (?:
.   .   a |
.   .   go |
.   .   mc
.   ) |
.   k (?:
.   .   a (?:
.   .   .   b |
.   .   .   m
.   .   )? |
.   .   de |
.   .   ea |
.   .   hq |
.   .   i |
.   .   k (?:
.   .   .   j
.   .   )? |
.   .   l (?:
.   .   .   n
.   .   )? |
.   .   m |
.   .   n |
.   .   o (?:
.   .   .   k
.   .   )? |
.   .   s (?:
.   .   .   b |
.   .   .   f |
.   .   .   h
.   .   ) |
.   .   w |
.   .   y
.   ) |
.   l (?:
.   .   ag |
.   .   g |
.   .   kt |
.   .   n |
.   .   o |
.   .   t |
.   .   u (?:
.   .   .   o |
.   .   .   y
.   .   )? |
.   .   v
.   ) |
.   m (?:
.   .   as |
.   .   er |
.   .   fe |
.   .   g (?:
.   .   .   h |
.   .   .   o
.   .   )? |
.   .   k |
.   .   l |
.   .   n |
.   .   r |
.   .   s |
.   .   t |
.   .   ua |
.   .   y
.   ) |
.   n (?:
.   .   aq |
.   .   b |
.   .   d |
.   .   e |
.   .   l |
.   .   mg |
.   .   n (?:
.   .   .   h
.   .   )? |
.   .   r |
.   .   so |
.   .   us |
.   .   yn
.   ) |
.   o (?:
.   .   m |
.   .   r |
.   .   s
.   ) |
.   p (?:
.   .   a (?:
.   .   .   _Arab
.   .   )? |
.   .   l |
.   .   s |
.   .   t
.   ) |
.   r (?:
.   .   m |
.   .   n |
.   .   o (?:
.   .   .   f
.   .   )? |
.   .   u |
.   .   w (?:
.   .   .   k
.   .   )?
.   ) |
.   s (?:
.   .   a (?:
.   .   .   h |
.   .   .   q
.   .   ) |
.   .   bp |
.   .   e (?:
.   .   .   h |
.   .   .   s
.   .   )? |
.   .   g |
.   .   hi (?:
.   .   .   _Latn
.   .   )? |
.   .   i |
.   .   k |
.   .   l |
.   .   n |
.   .   o |
.   .   q |
.   .   r (?:
.   .   .   _Latn
.   .   )? |
.   .   s (?:
.   .   .   y
.   .   )? |
.   .   t |
.   .   v |
.   .   w (?:
.   .   .   c
.   .   )?
.   ) |
.   t (?:
.   .   a |
.   .   e (?:
.   .   .   o
.   .   )? |
.   .   g |
.   .   h |
.   .   i (?:
.   .   .   _ER |
.   .   .   g
.   .   )? |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   wq |
.   .   zm
.   ) |
.   u (?:
.   .   g |
.   .   k |
.   .   r |
.   .   z (?:
.   .   .   _ (?:
.   .   .   .   Arab |
.   .   .   .   Cyrl
.   .   .   )
.   .   )?
.   ) |
.   v (?:
.   .   ai_Latn |
.   .   e |
.   .   i |
.   .   o |
.   .   un
.   ) |
.   wa (?:
.   .   e |
.   .   l
.   ) |
.   x (?:
.   .   h |
.   .   og
.   ) |
.   y (?:
.   .   av |
.   .   o (?:
.   .   .   _BJ
.   .   )?
.   ) |
.   z (?:
.   .   gh |
.   .   h (?:
.   .   .   _Hant
.   .   )? |
.   .   u
.   )
)
$

--[ gen-wide-expr-perl-depth-0-alphabets-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=0 --trie=ternary < alphabets.txt
(?:
.   a (?:
.   .   a |
.   .   f |
.   .   gq |
.   .   k |
.   .   m |
.   .   r |
.   .   s (?:
.   .   .   a |
.   .   .   t
.   .   )? |
.   .   z (?:
.   .   .   _Cyrl
.   .   )?
.   ) |
.   b (?:
.   .   as |
.   .   e (?:
.   .   .   m |
.   .   .   z
.   .   )? |
.   .   g |
.   .   m |
.   .   n |
.   .   o |
.   .   r (?:
.   .   .   x
.   .   )? |
.   .   s (?:
.   .   .   _Cyrl
.   .   )? |
.   .   yn
.   ) |
.   c (?:
.   .   a |
.   .   gg |
.   .   hr |
.   .   s |
.   .   y
.   ) |
.   d (?:
.   .   a (?:
.   .   .   v
.   .   )? |
.   .   e |
.   .   je |
.   .   ua |
.   .   yo |
.   .   z
.   ) |
.   e (?:
.   .   bu |
.   .   e |
.   .   l |
.   .   n |
.   .   o |
.   .   s |
.   .   t |
.   .   u |
.   .   wo
.   ) |
.   f (?:
.   .   a |
.   .   f |
.   .   i (?:
.   .   .   l
.   .   )? |
.   .   o |
.   .   r |
.   .   ur |
.   .   y
.   ) |
.   g (?:
.   .   a |
.   .   d |
.   .   l |
.   .   sw |
.   .   u (?:
.   .   .   z
.   .   )? |
.   .   v
.   ) |
.   h (?:
.   .   a (?:
.   .   .   w
.   .   )? |
.   .   e |
.   .   i |
.   .   r |
.   .   u |
.   .   y
.   ) |
.   i (?:
.   .   a |
.   .   d |
.   .   g |
.   .   i |
.   .   s |
.   .   t
.   ) |
.   j (?:
.   .   a |
.   .   go |
.   .   mc
.   ) |
.   k (?:
.   .   a (?:
.   .   .   b |
.   .   .   m
.   .   )? |
.   .   de |
.   .   ea |
.   .   hq |
.   .   i |
.   .   k (?:
.   .   .   j
.   .   )? |
.   .   l (?:
.   .   .   n
.   .   )? |
.   .   m |
.   .   n |
.   .   o (?:
.   .   .   k
.   .   )? |
.   .   s (?:
.   .   .   b |
.   .   .   f |
.   .   .   h
.   .   ) |
.   .   w |
.   .   y
.   ) |
.   l (?:
.   .   ag |
.   .   g |
.   .   kt |
.   .   n |
.   .   o |
.   .   t |
.   .   u (?:
.   .   .   o |
.   .   .   y
.   .   )? |
.   .   v
.   ) |
.   m (?:
.   .   as |
.   .   er |
.   .   fe |
.   .   g (?:
.   .   .   h |
.   .   .   o
.   .   )? |
.   .   k |
.   .   l |
.   .   n |
.   .   r |
.   .   s |
.   .   t |
.   .   ua |
.   .   y
.   ) |
.   n (?:
.   .   aq |
.   .   b |
.   .   d |
.   .   e |
.   .   l |
.   .   mg |
.   .   n (?:
.   .   .   h
.   .   )? |
.   .   r |
.   .   so |
.   .   us |
.   .   yn
.   ) |
.   o (?:
.   .   m |
.   .   r |
.   .   s
.   ) |
.   p (?:
.   .   a (?:
.   .   .   _Arab
.   .   )? |
.   .   l |
.   .   s |
.   .   t
.   ) |
.   r (?:
.   .   m |
.   .   n |
.   .   o (?:
.   .   .   f
.   .   )? |
.   .   u |
.   .   w (?:
.   .   .   k
.   .   )?
.   ) |
.   s (?:
.   .   a (?:
.   .   .   h |
.   .   .   q
.   .   ) |
.   .   bp |
.   .   e (?:
.   .   .   h |
.   .   .   s
.   .   )? |
.   .   g |
.   .   hi (?:
.   .   .   _Latn
.   .   )? |
.   .   i |
.   .   k |
.   .   l |
.   .   n |
.   .   o |
.   .   q |
.   .   r (?:
.   .   .   _Latn
.   .   )? |
.   .   s (?:
.   .   .   y
.   .   )? |
.   .   t |
.   .   v |
.   .   w (?:
.   .   .   c
.   .   )?
.   ) |
.   t (?:
.   .   a |
.   .   e (?:
.   .   .   o
.   .   )? |
.   .   g |
.   .   h |
.   .   i (?:
.   .   .   _ER |
.   .   .   g
.   .   )? |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   wq |
.   .   zm
.   ) |
.   u (?:
.   .   g |
.   .   k |
.   .   r |
.   .   z (?:
.   .   .   _ (?:
.   .   .   .   Arab |
.   .   .   .   Cyrl
.   .   .   )
.   .   )?
.   ) |
.   v (?:
.   .   ai_Latn |
.   .   e |
.   .   i |
.   .   o |
.   .   un
.   ) |
.   wa (?:
.   .   e |
.   .   l
.   ) |
.   x (?:
.   .   h |
.   .   og
.   ) |
.   y (?:
.   .   av |
.   .   o (?:
.   .   .   _BJ
.   .   )?
.   ) |
.   z (?:
.   .   gh |
.   .   h (?:
.   .   .   _Hant
.   .   )? |
.   .   u
.   )
)
$

--[ gen-wide-expr-perl-depth-0-filenames-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=0 --trie=array --escape=/ < filenames.txt
(?:
.   c\+\+py-tree-demo\/ (?:
.   .   \.src- (?:
.   .   .   dirs |
.   .   .   files
.   .   ) |
.   .   bin\.patch |
.   .   c\+\+py (?:
.   .   .   -tree (?:
.   .   .   .   - (?:
.   .   .   .   .   author\.txt |
.   .   .   .   .   demo\.txt |
.   .   .   .   .   readme\. (?:
.   .   .   .   .   .   pdf |
.   .   .   .   .   .   t (?:
.   .   .   .   .   .   .   ex |
.   .   .   .   .   .   .   xt
.   .   .   .   .   .   )
.   .   .   .   .   )
.   .   .   .   ) |
.   .   .   .   \. (?:
.   .   .   .   .   pdf |
.   .   .   .   .   t (?:
.   .   .   .   .   .   ex |
.   .   .   .   .   .   xt
.   .   .   .   .   )
.   .   .   .   )
.   .   .   ) |
.   .   .   \/ (?:
.   .   .   .   \.src- (?:
.   .   .   .   .   dirs |
.   .   .   .   .   files
.   .   .   .   ) |
.   .   .   .   AUTHOR |
.   .   .   .   Makefile |
.   .   .   .   README
.   .   .   )
.   .   )
.   )
)
$

--[ gen-wide-expr-perl-depth-0-filenames-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=0 --trie=ternary --escape=/ < filenames.txt
(?:
.   c\+\+py-tree-demo\/ (?:
.   .   \.src- (?:
.   .   .   dirs |
.   .   .   files
.   .   ) |
.   .   bin\.patch |
.   .   c\+\+py (?:
.   .   .   -tree (?:
.   .   .   .   - (?:
.   .   .   .   .   author\.txt |
.   .   .   .   .   demo\.txt |
.   .   .   .   .   readme\. (?:
.   .   .   .   .   .   pdf |
.   .   .   .   .   .   t (?:
.   .   .   .   .   .   .   ex |
.   .   .   .   .   .   .   xt
.   .   .   .   .   .   )
.   .   .   .   .   )
.   .   .   .   ) |
.   .   .   .   \. (?:
.   .   .   .   .   pdf |
.   .   .   .   .   t (?:
.   .   .   .   .   .   ex |
.   .   .   .   .   .   xt
.   .   .   .   .   )
.   .   .   .   )
.   .   .   ) |
.   .   .   \/ (?:
.   .   .   .   \.src- (?:
.   .   .   .   .   dirs |
.   .   .   .   .   files
.   .   .   .   ) |
.   .   .   .   AUTHOR |
.   .   .   .   Makefile |
.   .   .   .   README
.   .   .   )
.   .   )
.   )
)
$

--[ gen-compact-expr-perl-depth-0-base0-array ]---------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=0 --trie=array "$@"; }
$ print a|trie
a
$ print a ab|trie
a(?:b)?
$ print a ab abc|trie
a(?:b(?:c)?)?
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a(?:b(?:c|d))?|b(?:ac)?
$ print a bb ba c|trie
a|b(?:a|b)|c
$ print a bb ba cc|trie
a|b(?:a|b)|cc
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print a bb ba cde|trie
a|b(?:a|b)|cde
$ print a bb ba cdef|trie
a|b(?:a|b)|cdef
$ print a bb ba cdef cdefg|trie
a|b(?:a|b)|cdef(?:g)?
$ print a bb bac cdef|trie
a|b(?:ac|b)|cdef
$ print a bbx ba ccc|trie
a|b(?:a|bx)|ccc
$ print a bbx bay ccc|trie
a|b(?:ay|bx)|ccc
$ print a cde cdef|trie
a|cde(?:f)?
$ print a cde cdef cdefg|trie
a|cde(?:f(?:g)?)?
$ print a cde cdef cdefgh|trie
a|cde(?:f(?:gh)?)?
$ print a cdef cdefg|trie
a|cdef(?:g)?
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b(?:a|b)|ccc
$ print ab bb ba cde|trie
ab|b(?:a|b)|cde
$ print ab bbx ba ccc|trie
ab|b(?:a|bx)|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b(?:a|b)|ccc
$ print abcd abde abef|trie
ab(?:cd|de|ef)
$ print abg a abc ab abd|trie
a(?:b(?:c|d|g)?)?
$ print ac ab|trie
a(?:b|c)
$ print aef ae abg a abc ab abd|trie
a(?:b(?:c|d|g)?|e(?:f)?)?
$ print cde cdef cdefgh|trie
cde(?:f(?:gh)?)?
$ print cdef cdefg|trie
cdef(?:g)?
$ print cdex cdfy cdgz cdhw|trie
cd(?:ex|fy|gz|hw)
$ print ce cdex cdfy cdgz cdhw|trie
c(?:d(?:ex|fy|gz|hw)|e)
$ print pot potato pottery tattoo tempo|trie
pot(?:ato|tery)?|t(?:attoo|empo)
$

--[ gen-compact-expr-perl-depth-0-base0-ternary ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=0 --trie=ternary "$@"; }
$ print a|trie
a
$ print a ab|trie
a(?:b)?
$ print a ab abc|trie
a(?:b(?:c)?)?
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a(?:b(?:c|d))?|b(?:ac)?
$ print a bb ba c|trie
a|b(?:a|b)|c
$ print a bb ba cc|trie
a|b(?:a|b)|cc
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print a bb ba cde|trie
a|b(?:a|b)|cde
$ print a bb ba cdef|trie
a|b(?:a|b)|cdef
$ print a bb ba cdef cdefg|trie
a|b(?:a|b)|cdef(?:g)?
$ print a bb bac cdef|trie
a|b(?:ac|b)|cdef
$ print a bbx ba ccc|trie
a|b(?:a|bx)|ccc
$ print a bbx bay ccc|trie
a|b(?:ay|bx)|ccc
$ print a cde cdef|trie
a|cde(?:f)?
$ print a cde cdef cdefg|trie
a|cde(?:f(?:g)?)?
$ print a cde cdef cdefgh|trie
a|cde(?:f(?:gh)?)?
$ print a cdef cdefg|trie
a|cdef(?:g)?
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b(?:a|b)|ccc
$ print ab bb ba cde|trie
ab|b(?:a|b)|cde
$ print ab bbx ba ccc|trie
ab|b(?:a|bx)|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b(?:a|b)|ccc
$ print abcd abde abef|trie
ab(?:cd|de|ef)
$ print abg a abc ab abd|trie
a(?:b(?:c|d|g)?)?
$ print ac ab|trie
a(?:b|c)
$ print aef ae abg a abc ab abd|trie
a(?:b(?:c|d|g)?|e(?:f)?)?
$ print cde cdef cdefgh|trie
cde(?:f(?:gh)?)?
$ print cdef cdefg|trie
cdef(?:g)?
$ print cdex cdfy cdgz cdhw|trie
cd(?:ex|fy|gz|hw)
$ print ce cdex cdfy cdgz cdhw|trie
c(?:d(?:ex|fy|gz|hw)|e)
$ print pot potato pottery tattoo tempo|trie
pot(?:ato|tery)?|t(?:attoo|empo)
$

--[ gen-compact-expr-perl-depth-0-base ]----------------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=0 --no-dots "$@"; }
$ print a ab abc abd ac|trie
a(?:b(?:c|d)?|c)?
$ print a ab abc abd ac|trie -t int
a(?:b(?:c|d)?|c)?
$ print a ab abc abd ac|trie -t float
a(?:b(?:c|d)?|c)?
$

--[ gen-compact-expr-perl-depth-0-base-array ]----------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=0 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a(?:b(?:c)?)?
$ print a ab ac|trie
a(?:b|c)?
$ print a ab ac ad|trie
a(?:b|c|d)?
$ print a abd ac|trie
a(?:bd|c)?
$ print a ab ac acd|trie
a(?:b|c(?:d)?)?
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print abc abd acde|trie
a(?:b(?:c|d)|cde)
$ print abc abd acde ac|trie
a(?:b(?:c|d)|c(?:de)?)
$ print abc abd acde acfg|trie
a(?:b(?:c|d)|c(?:de|fg))
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(?:de|fg(?:x(?:y(?:z)?|zzz)?)?)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(?:fg(?:x(?:y(?:z)?|zzz)?)?|ge)
$ print a abcd abcdefg h hijk|trie
a(?:bcd(?:efg)?)?|h(?:ijk)?
$ print a abcd abcdefg abcdxyz h hijk|trie
a(?:bcd(?:efg|xyz)?)?|h(?:ijk)?
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a(?:bcd(?:efg|xyz)?)?|h(?:ijk|lm)?
$

--[ gen-compact-expr-perl-depth-0-base-ternary ]--------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=0 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a(?:b(?:c)?)?
$ print a ab ac|trie
a(?:b|c)?
$ print a ab ac ad|trie
a(?:b|c|d)?
$ print a abd ac|trie
a(?:bd|c)?
$ print a ab ac acd|trie
a(?:b|c(?:d)?)?
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print abc abd acde|trie
a(?:b(?:c|d)|cde)
$ print abc abd acde ac|trie
a(?:b(?:c|d)|c(?:de)?)
$ print abc abd acde acfg|trie
a(?:b(?:c|d)|c(?:de|fg))
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(?:de|fg(?:x(?:y(?:z)?|zzz)?)?)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(?:fg(?:x(?:y(?:z)?|zzz)?)?|ge)
$ print a abcd abcdefg h hijk|trie
a(?:bcd(?:efg)?)?|h(?:ijk)?
$ print a abcd abcdefg abcdxyz h hijk|trie
a(?:bcd(?:efg|xyz)?)?|h(?:ijk)?
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a(?:bcd(?:efg|xyz)?)?|h(?:ijk|lm)?
$

--[ gen-compact-expr-perl-depth-0-alphabets-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=0 --trie=array < alphabets.txt
a(?:a|f|gq|k|m|r|s(?:a|t)?|z(?:_Cyrl)?)|b(?:as|e(?:m|z)?|g|m|n|o|r(?:x)?|s(?:_Cyrl)?|yn)|c(?:a|gg|hr|s|y)|d(?:a(?:v)?|e|je|ua|yo|z)|e(?:bu|e|l|n|o|s|t|u|wo)|f(?:a|f|i(?:l)?|o|r|ur|y)|g(?:a|d|l|sw|u(?:z)?|v)|h(?:a(?:w)?|e|i|r|u|y)|i(?:a|d|g|i|s|t)|j(?:a|go|mc)|k(?:a(?:b|m)?|de|ea|hq|i|k(?:j)?|l(?:n)?|m|n|o(?:k)?|s(?:b|f|h)|w|y)|l(?:ag|g|kt|n|o|t|u(?:o|y)?|v)|m(?:as|er|fe|g(?:h|o)?|k|l|n|r|s|t|ua|y)|n(?:aq|b|d|e|l|mg|n(?:h)?|r|so|us|yn)|o(?:m|r|s)|p(?:a(?:_Arab)?|l|s|t)|r(?:m|n|o(?:f)?|u|w(?:k)?)|s(?:a(?:h|q)|bp|e(?:h|s)?|g|hi(?:_Latn)?|i|k|l|n|o|q|r(?:_Latn)?|s(?:y)?|t|v|w(?:c)?)|t(?:a|e(?:o)?|g|h|i(?:_ER|g)?|n|o|r|s|wq|zm)|u(?:g|k|r|z(?:_(?:Arab|Cyrl))?)|v(?:ai_Latn|e|i|o|un)|wa(?:e|l)|x(?:h|og)|y(?:av|o(?:_BJ)?)|z(?:gh|h(?:_Hant)?|u)
$

--[ gen-compact-expr-perl-depth-0-alphabets-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=0 --trie=ternary < alphabets.txt
a(?:a|f|gq|k|m|r|s(?:a|t)?|z(?:_Cyrl)?)|b(?:as|e(?:m|z)?|g|m|n|o|r(?:x)?|s(?:_Cyrl)?|yn)|c(?:a|gg|hr|s|y)|d(?:a(?:v)?|e|je|ua|yo|z)|e(?:bu|e|l|n|o|s|t|u|wo)|f(?:a|f|i(?:l)?|o|r|ur|y)|g(?:a|d|l|sw|u(?:z)?|v)|h(?:a(?:w)?|e|i|r|u|y)|i(?:a|d|g|i|s|t)|j(?:a|go|mc)|k(?:a(?:b|m)?|de|ea|hq|i|k(?:j)?|l(?:n)?|m|n|o(?:k)?|s(?:b|f|h)|w|y)|l(?:ag|g|kt|n|o|t|u(?:o|y)?|v)|m(?:as|er|fe|g(?:h|o)?|k|l|n|r|s|t|ua|y)|n(?:aq|b|d|e|l|mg|n(?:h)?|r|so|us|yn)|o(?:m|r|s)|p(?:a(?:_Arab)?|l|s|t)|r(?:m|n|o(?:f)?|u|w(?:k)?)|s(?:a(?:h|q)|bp|e(?:h|s)?|g|hi(?:_Latn)?|i|k|l|n|o|q|r(?:_Latn)?|s(?:y)?|t|v|w(?:c)?)|t(?:a|e(?:o)?|g|h|i(?:_ER|g)?|n|o|r|s|wq|zm)|u(?:g|k|r|z(?:_(?:Arab|Cyrl))?)|v(?:ai_Latn|e|i|o|un)|wa(?:e|l)|x(?:h|og)|y(?:av|o(?:_BJ)?)|z(?:gh|h(?:_Hant)?|u)
$

--[ gen-compact-expr-perl-depth-0-filenames-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=0 --trie=array --escape=/ < filenames.txt
c\+\+py-tree-demo\/(?:\.src-(?:dirs|files)|bin\.patch|c\+\+py(?:-tree(?:-(?:author\.txt|demo\.txt|readme\.(?:pdf|t(?:ex|xt)))|\.(?:pdf|t(?:ex|xt)))|\/(?:\.src-(?:dirs|files)|AUTHOR|Makefile|README)))
$

--[ gen-compact-expr-perl-depth-0-filenames-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=0 --trie=ternary --escape=/ < filenames.txt
c\+\+py-tree-demo\/(?:\.src-(?:dirs|files)|bin\.patch|c\+\+py(?:-tree(?:-(?:author\.txt|demo\.txt|readme\.(?:pdf|t(?:ex|xt)))|\.(?:pdf|t(?:ex|xt)))|\/(?:\.src-(?:dirs|files)|AUTHOR|Makefile|README)))
$

--[ gen-wide-expr-perl-depth-1-base0-array ]------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=1 --trie=array "$@"; }
$ print a|trie
(?:
    a
)
$ print a ab|trie
(?:
    a
)
$ print a ab abc|trie
(?:
    a
)
$ print a b|trie
(?:
    a |
    b
)
$ print a b abc bac abd|trie
(?:
    a |
    b
)
$ print a bb ba c|trie
(?:
    a |
    b |
    c
)
$ print a bb ba cc|trie
(?:
    a |
    b |
    cc
)
$ print a bb ba ccc|trie
(?:
    a |
    b |
    ccc
)
$ print a bb ba cde|trie
(?:
    a |
    b |
    cde
)
$ print a bb ba cdef|trie
(?:
    a |
    b |
    cdef
)
$ print a bb ba cdef cdefg|trie
(?:
    a |
    b |
    cdef
)
$ print a bb bac cdef|trie
(?:
    a |
    b |
    cdef
)
$ print a bbx ba ccc|trie
(?:
    a |
    b |
    ccc
)
$ print a bbx bay ccc|trie
(?:
    a |
    b |
    ccc
)
$ print a cde cdef|trie
(?:
    a |
    cde
)
$ print a cde cdef cdefg|trie
(?:
    a |
    cde
)
$ print a cde cdef cdefgh|trie
(?:
    a |
    cde
)
$ print a cdef cdefg|trie
(?:
    a |
    cdef
)
$ print ab|trie
(?:
    ab
)
$ print ab bb ba ccc|trie
(?:
    ab |
    b |
    ccc
)
$ print ab bb ba cde|trie
(?:
    ab |
    b |
    cde
)
$ print ab bbx ba ccc|trie
(?:
    ab |
    b |
    ccc
)
$ print ab c|trie
(?:
    ab |
    c
)
$ print abc bb ba ccc|trie
(?:
    abc |
    b |
    ccc
)
$ print abcd abde abef|trie
(?:
    ab
)
$ print abg a abc ab abd|trie
(?:
    a
)
$ print ac ab|trie
(?:
    a
)
$ print aef ae abg a abc ab abd|trie
(?:
    a
)
$ print cde cdef cdefgh|trie
(?:
    cde
)
$ print cdef cdefg|trie
(?:
    cdef
)
$ print cdex cdfy cdgz cdhw|trie
(?:
    cd
)
$ print ce cdex cdfy cdgz cdhw|trie
(?:
    c
)
$ print pot potato pottery tattoo tempo|trie
(?:
    pot |
    t
)
$

--[ gen-wide-expr-perl-depth-1-base0-ternary ]----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=1 --trie=ternary "$@"; }
$ print a|trie
(?:
    a
)
$ print a ab|trie
(?:
    a
)
$ print a ab abc|trie
(?:
    a
)
$ print a b|trie
(?:
    a |
    b
)
$ print a b abc bac abd|trie
(?:
    a |
    b
)
$ print a bb ba c|trie
(?:
    a |
    b |
    c
)
$ print a bb ba cc|trie
(?:
    a |
    b |
    cc
)
$ print a bb ba ccc|trie
(?:
    a |
    b |
    ccc
)
$ print a bb ba cde|trie
(?:
    a |
    b |
    cde
)
$ print a bb ba cdef|trie
(?:
    a |
    b |
    cdef
)
$ print a bb ba cdef cdefg|trie
(?:
    a |
    b |
    cdef
)
$ print a bb bac cdef|trie
(?:
    a |
    b |
    cdef
)
$ print a bbx ba ccc|trie
(?:
    a |
    b |
    ccc
)
$ print a bbx bay ccc|trie
(?:
    a |
    b |
    ccc
)
$ print a cde cdef|trie
(?:
    a |
    cde
)
$ print a cde cdef cdefg|trie
(?:
    a |
    cde
)
$ print a cde cdef cdefgh|trie
(?:
    a |
    cde
)
$ print a cdef cdefg|trie
(?:
    a |
    cdef
)
$ print ab|trie
(?:
    ab
)
$ print ab bb ba ccc|trie
(?:
    ab |
    b |
    ccc
)
$ print ab bb ba cde|trie
(?:
    ab |
    b |
    cde
)
$ print ab bbx ba ccc|trie
(?:
    ab |
    b |
    ccc
)
$ print ab c|trie
(?:
    ab |
    c
)
$ print abc bb ba ccc|trie
(?:
    abc |
    b |
    ccc
)
$ print abcd abde abef|trie
(?:
    ab
)
$ print abg a abc ab abd|trie
(?:
    a
)
$ print ac ab|trie
(?:
    a
)
$ print aef ae abg a abc ab abd|trie
(?:
    a
)
$ print cde cdef cdefgh|trie
(?:
    cde
)
$ print cdef cdefg|trie
(?:
    cdef
)
$ print cdex cdfy cdgz cdhw|trie
(?:
    cd
)
$ print ce cdex cdfy cdgz cdhw|trie
(?:
    c
)
$ print pot potato pottery tattoo tempo|trie
(?:
    pot |
    t
)
$

--[ gen-wide-expr-perl-depth-1-base ]-------------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=1 --no-dots "$@"; }
$ print a ab abc abd ac|trie
(?:
    a
)
$ print a ab abc abd ac|trie -t int
(?:
    a
)
$ print a ab abc abd ac|trie -t float
(?:
    a
)
$

--[ gen-wide-expr-perl-depth-1-base-array ]-------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=1 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(?:
.   a
)
$ print a b|trie
(?:
.   a |
.   b
)
$ print a b c|trie
(?:
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(?:
.   a
)
$ print a ab ac|trie
(?:
.   a
)
$ print a ab ac ad|trie
(?:
.   a
)
$ print a abd ac|trie
(?:
.   a
)
$ print a ab ac acd|trie
(?:
.   a
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b |
.   ccc
)
$ print a bb ccc|trie
(?:
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b |
.   ccc
)
$ print abc abd acde|trie
(?:
.   a
)
$ print abc abd acde ac|trie
(?:
.   a
)
$ print abc abd acde acfg|trie
(?:
.   a
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c
)
$ print a abcd abcdefg h hijk|trie
(?:
.   a |
.   h
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(?:
.   a |
.   h
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(?:
.   a |
.   h
)
$

--[ gen-wide-expr-perl-depth-1-base-ternary ]-----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=1 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(?:
.   a
)
$ print a b|trie
(?:
.   a |
.   b
)
$ print a b c|trie
(?:
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(?:
.   a
)
$ print a ab ac|trie
(?:
.   a
)
$ print a ab ac ad|trie
(?:
.   a
)
$ print a abd ac|trie
(?:
.   a
)
$ print a ab ac acd|trie
(?:
.   a
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b |
.   ccc
)
$ print a bb ccc|trie
(?:
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b |
.   ccc
)
$ print abc abd acde|trie
(?:
.   a
)
$ print abc abd acde ac|trie
(?:
.   a
)
$ print abc abd acde acfg|trie
(?:
.   a
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c
)
$ print a abcd abcdefg h hijk|trie
(?:
.   a |
.   h
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(?:
.   a |
.   h
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(?:
.   a |
.   h
)
$

--[ gen-wide-expr-perl-depth-1-alphabets-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=1 --trie=array < alphabets.txt
(?:
.   a |
.   b |
.   c |
.   d |
.   e |
.   f |
.   g |
.   h |
.   i |
.   j |
.   k |
.   l |
.   m |
.   n |
.   o |
.   p |
.   r |
.   s |
.   t |
.   u |
.   v |
.   wa |
.   x |
.   y |
.   z
)
$

--[ gen-wide-expr-perl-depth-1-alphabets-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=1 --trie=ternary < alphabets.txt
(?:
.   a |
.   b |
.   c |
.   d |
.   e |
.   f |
.   g |
.   h |
.   i |
.   j |
.   k |
.   l |
.   m |
.   n |
.   o |
.   p |
.   r |
.   s |
.   t |
.   u |
.   v |
.   wa |
.   x |
.   y |
.   z
)
$

--[ gen-wide-expr-perl-depth-1-filenames-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=1 --trie=array --escape=/ < filenames.txt
(?:
.   c\+\+py-tree-demo\/
)
$

--[ gen-wide-expr-perl-depth-1-filenames-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=1 --trie=ternary --escape=/ < filenames.txt
(?:
.   c\+\+py-tree-demo\/
)
$

--[ gen-compact-expr-perl-depth-1-base0-array ]---------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=1 --trie=array "$@"; }
$ print a|trie
a
$ print a ab|trie
a
$ print a ab abc|trie
a
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a|b
$ print a bb ba c|trie
a|b|c
$ print a bb ba cc|trie
a|b|cc
$ print a bb ba ccc|trie
a|b|ccc
$ print a bb ba cde|trie
a|b|cde
$ print a bb ba cdef|trie
a|b|cdef
$ print a bb ba cdef cdefg|trie
a|b|cdef
$ print a bb bac cdef|trie
a|b|cdef
$ print a bbx ba ccc|trie
a|b|ccc
$ print a bbx bay ccc|trie
a|b|ccc
$ print a cde cdef|trie
a|cde
$ print a cde cdef cdefg|trie
a|cde
$ print a cde cdef cdefgh|trie
a|cde
$ print a cdef cdefg|trie
a|cdef
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b|ccc
$ print ab bb ba cde|trie
ab|b|cde
$ print ab bbx ba ccc|trie
ab|b|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b|ccc
$ print abcd abde abef|trie
ab
$ print abg a abc ab abd|trie
a
$ print ac ab|trie
a
$ print aef ae abg a abc ab abd|trie
a
$ print cde cdef cdefgh|trie
cde
$ print cdef cdefg|trie
cdef
$ print cdex cdfy cdgz cdhw|trie
cd
$ print ce cdex cdfy cdgz cdhw|trie
c
$ print pot potato pottery tattoo tempo|trie
pot|t
$

--[ gen-compact-expr-perl-depth-1-base0-ternary ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=1 --trie=ternary "$@"; }
$ print a|trie
a
$ print a ab|trie
a
$ print a ab abc|trie
a
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a|b
$ print a bb ba c|trie
a|b|c
$ print a bb ba cc|trie
a|b|cc
$ print a bb ba ccc|trie
a|b|ccc
$ print a bb ba cde|trie
a|b|cde
$ print a bb ba cdef|trie
a|b|cdef
$ print a bb ba cdef cdefg|trie
a|b|cdef
$ print a bb bac cdef|trie
a|b|cdef
$ print a bbx ba ccc|trie
a|b|ccc
$ print a bbx bay ccc|trie
a|b|ccc
$ print a cde cdef|trie
a|cde
$ print a cde cdef cdefg|trie
a|cde
$ print a cde cdef cdefgh|trie
a|cde
$ print a cdef cdefg|trie
a|cdef
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b|ccc
$ print ab bb ba cde|trie
ab|b|cde
$ print ab bbx ba ccc|trie
ab|b|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b|ccc
$ print abcd abde abef|trie
ab
$ print abg a abc ab abd|trie
a
$ print ac ab|trie
a
$ print aef ae abg a abc ab abd|trie
a
$ print cde cdef cdefgh|trie
cde
$ print cdef cdefg|trie
cdef
$ print cdex cdfy cdgz cdhw|trie
cd
$ print ce cdex cdfy cdgz cdhw|trie
c
$ print pot potato pottery tattoo tempo|trie
pot|t
$

--[ gen-compact-expr-perl-depth-1-base ]----------------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=1 --no-dots "$@"; }
$ print a ab abc abd ac|trie
a
$ print a ab abc abd ac|trie -t int
a
$ print a ab abc abd ac|trie -t float
a
$

--[ gen-compact-expr-perl-depth-1-base-array ]----------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=1 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a
$ print a ab ac|trie
a
$ print a ab ac ad|trie
a
$ print a abd ac|trie
a
$ print a ab ac acd|trie
a
$ print a bb ba ccc|trie
a|b|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b|ccc
$ print abc abd acde|trie
a
$ print abc abd acde ac|trie
a
$ print abc abd acde acfg|trie
a
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c
$ print a abcd abcdefg h hijk|trie
a|h
$ print a abcd abcdefg abcdxyz h hijk|trie
a|h
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a|h
$

--[ gen-compact-expr-perl-depth-1-base-ternary ]--------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=1 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a
$ print a ab ac|trie
a
$ print a ab ac ad|trie
a
$ print a abd ac|trie
a
$ print a ab ac acd|trie
a
$ print a bb ba ccc|trie
a|b|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b|ccc
$ print abc abd acde|trie
a
$ print abc abd acde ac|trie
a
$ print abc abd acde acfg|trie
a
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c
$ print a abcd abcdefg h hijk|trie
a|h
$ print a abcd abcdefg abcdxyz h hijk|trie
a|h
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a|h
$

--[ gen-compact-expr-perl-depth-1-alphabets-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=1 --trie=array < alphabets.txt
a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|r|s|t|u|v|wa|x|y|z
$

--[ gen-compact-expr-perl-depth-1-alphabets-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=1 --trie=ternary < alphabets.txt
a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|r|s|t|u|v|wa|x|y|z
$

--[ gen-compact-expr-perl-depth-1-filenames-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=1 --trie=array --escape=/ < filenames.txt
c\+\+py-tree-demo\/
$

--[ gen-compact-expr-perl-depth-1-filenames-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=1 --trie=ternary --escape=/ < filenames.txt
c\+\+py-tree-demo\/
$

--[ gen-wide-expr-perl-depth-2-base0-array ]------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=2 --trie=array "$@"; }
$ print a|trie
(?:
    a
)
$ print a ab|trie
(?:
    a (?:
        b
    )?
)
$ print a ab abc|trie
(?:
    a (?:
        b
    )?
)
$ print a b|trie
(?:
    a |
    b
)
$ print a b abc bac abd|trie
(?:
    a (?:
        b
    )? |
    b (?:
        ac
    )?
)
$ print a bb ba c|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    c
)
$ print a bb ba cc|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cc
)
$ print a bb ba ccc|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print a bb ba cde|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cde
)
$ print a bb ba cdef|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cdef
)
$ print a bb ba cdef cdefg|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cdef (?:
        g
    )?
)
$ print a bb bac cdef|trie
(?:
    a |
    b (?:
        ac |
        b
    ) |
    cdef
)
$ print a bbx ba ccc|trie
(?:
    a |
    b (?:
        a |
        bx
    ) |
    ccc
)
$ print a bbx bay ccc|trie
(?:
    a |
    b (?:
        ay |
        bx
    ) |
    ccc
)
$ print a cde cdef|trie
(?:
    a |
    cde (?:
        f
    )?
)
$ print a cde cdef cdefg|trie
(?:
    a |
    cde (?:
        f
    )?
)
$ print a cde cdef cdefgh|trie
(?:
    a |
    cde (?:
        f
    )?
)
$ print a cdef cdefg|trie
(?:
    a |
    cdef (?:
        g
    )?
)
$ print ab|trie
(?:
    ab
)
$ print ab bb ba ccc|trie
(?:
    ab |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print ab bb ba cde|trie
(?:
    ab |
    b (?:
        a |
        b
    ) |
    cde
)
$ print ab bbx ba ccc|trie
(?:
    ab |
    b (?:
        a |
        bx
    ) |
    ccc
)
$ print ab c|trie
(?:
    ab |
    c
)
$ print abc bb ba ccc|trie
(?:
    abc |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print abcd abde abef|trie
(?:
    ab (?:
        cd |
        de |
        ef
    )
)
$ print abg a abc ab abd|trie
(?:
    a (?:
        b
    )?
)
$ print ac ab|trie
(?:
    a (?:
        b |
        c
    )
)
$ print aef ae abg a abc ab abd|trie
(?:
    a (?:
        b |
        e
    )?
)
$ print cde cdef cdefgh|trie
(?:
    cde (?:
        f
    )?
)
$ print cdef cdefg|trie
(?:
    cdef (?:
        g
    )?
)
$ print cdex cdfy cdgz cdhw|trie
(?:
    cd (?:
        ex |
        fy |
        gz |
        hw
    )
)
$ print ce cdex cdfy cdgz cdhw|trie
(?:
    c (?:
        d |
        e
    )
)
$ print pot potato pottery tattoo tempo|trie
(?:
    pot (?:
        ato |
        tery
    )? |
    t (?:
        attoo |
        empo
    )
)
$

--[ gen-wide-expr-perl-depth-2-base0-ternary ]----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=2 --trie=ternary "$@"; }
$ print a|trie
(?:
    a
)
$ print a ab|trie
(?:
    a (?:
        b
    )?
)
$ print a ab abc|trie
(?:
    a (?:
        b
    )?
)
$ print a b|trie
(?:
    a |
    b
)
$ print a b abc bac abd|trie
(?:
    a (?:
        b
    )? |
    b (?:
        ac
    )?
)
$ print a bb ba c|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    c
)
$ print a bb ba cc|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cc
)
$ print a bb ba ccc|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print a bb ba cde|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cde
)
$ print a bb ba cdef|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cdef
)
$ print a bb ba cdef cdefg|trie
(?:
    a |
    b (?:
        a |
        b
    ) |
    cdef (?:
        g
    )?
)
$ print a bb bac cdef|trie
(?:
    a |
    b (?:
        ac |
        b
    ) |
    cdef
)
$ print a bbx ba ccc|trie
(?:
    a |
    b (?:
        a |
        bx
    ) |
    ccc
)
$ print a bbx bay ccc|trie
(?:
    a |
    b (?:
        ay |
        bx
    ) |
    ccc
)
$ print a cde cdef|trie
(?:
    a |
    cde (?:
        f
    )?
)
$ print a cde cdef cdefg|trie
(?:
    a |
    cde (?:
        f
    )?
)
$ print a cde cdef cdefgh|trie
(?:
    a |
    cde (?:
        f
    )?
)
$ print a cdef cdefg|trie
(?:
    a |
    cdef (?:
        g
    )?
)
$ print ab|trie
(?:
    ab
)
$ print ab bb ba ccc|trie
(?:
    ab |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print ab bb ba cde|trie
(?:
    ab |
    b (?:
        a |
        b
    ) |
    cde
)
$ print ab bbx ba ccc|trie
(?:
    ab |
    b (?:
        a |
        bx
    ) |
    ccc
)
$ print ab c|trie
(?:
    ab |
    c
)
$ print abc bb ba ccc|trie
(?:
    abc |
    b (?:
        a |
        b
    ) |
    ccc
)
$ print abcd abde abef|trie
(?:
    ab (?:
        cd |
        de |
        ef
    )
)
$ print abg a abc ab abd|trie
(?:
    a (?:
        b
    )?
)
$ print ac ab|trie
(?:
    a (?:
        b |
        c
    )
)
$ print aef ae abg a abc ab abd|trie
(?:
    a (?:
        b |
        e
    )?
)
$ print cde cdef cdefgh|trie
(?:
    cde (?:
        f
    )?
)
$ print cdef cdefg|trie
(?:
    cdef (?:
        g
    )?
)
$ print cdex cdfy cdgz cdhw|trie
(?:
    cd (?:
        ex |
        fy |
        gz |
        hw
    )
)
$ print ce cdex cdfy cdgz cdhw|trie
(?:
    c (?:
        d |
        e
    )
)
$ print pot potato pottery tattoo tempo|trie
(?:
    pot (?:
        ato |
        tery
    )? |
    t (?:
        attoo |
        empo
    )
)
$

--[ gen-wide-expr-perl-depth-2-base ]-------------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=2 --no-dots "$@"; }
$ print a ab abc abd ac|trie
(?:
    a (?:
        b |
        c
    )?
)
$ print a ab abc abd ac|trie -t int
(?:
    a (?:
        b |
        c
    )?
)
$ print a ab abc abd ac|trie -t float
(?:
    a (?:
        b |
        c
    )?
)
$

--[ gen-wide-expr-perl-depth-2-base-array ]-------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=2 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(?:
.   a
)
$ print a b|trie
(?:
.   a |
.   b
)
$ print a b c|trie
(?:
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(?:
.   a (?:
.   .   b
.   )?
)
$ print a ab ac|trie
(?:
.   a (?:
.   .   b |
.   .   c
.   )?
)
$ print a ab ac ad|trie
(?:
.   a (?:
.   .   b |
.   .   c |
.   .   d
.   )?
)
$ print a abd ac|trie
(?:
.   a (?:
.   .   bd |
.   .   c
.   )?
)
$ print a ab ac acd|trie
(?:
.   a (?:
.   .   b |
.   .   c
.   )?
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b (?:
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print a bb ccc|trie
(?:
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b (?:
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print abc abd acde|trie
(?:
.   a (?:
.   .   b |
.   .   cde
.   )
)
$ print abc abd acde ac|trie
(?:
.   a (?:
.   .   b |
.   .   c
.   )
)
$ print abc abd acde acfg|trie
(?:
.   a (?:
.   .   b |
.   .   c
.   )
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c (?:
.   .   de |
.   .   fg
.   )
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c (?:
.   .   fg |
.   .   ge
.   )
)
$ print a abcd abcdefg h hijk|trie
(?:
.   a (?:
.   .   bcd
.   )? |
.   h (?:
.   .   ijk
.   )?
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(?:
.   a (?:
.   .   bcd
.   )? |
.   h (?:
.   .   ijk
.   )?
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(?:
.   a (?:
.   .   bcd
.   )? |
.   h (?:
.   .   ijk |
.   .   lm
.   )?
)
$

--[ gen-wide-expr-perl-depth-2-base-ternary ]-----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=perl --depth=2 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
(?:
.   a
)
$ print a b|trie
(?:
.   a |
.   b
)
$ print a b c|trie
(?:
.   a |
.   b |
.   c
)
$ print a ab abc|trie
(?:
.   a (?:
.   .   b
.   )?
)
$ print a ab ac|trie
(?:
.   a (?:
.   .   b |
.   .   c
.   )?
)
$ print a ab ac ad|trie
(?:
.   a (?:
.   .   b |
.   .   c |
.   .   d
.   )?
)
$ print a abd ac|trie
(?:
.   a (?:
.   .   bd |
.   .   c
.   )?
)
$ print a ab ac acd|trie
(?:
.   a (?:
.   .   b |
.   .   c
.   )?
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b (?:
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print a bb ccc|trie
(?:
.   a |
.   bb |
.   ccc
)
$ print a bb ba ccc|trie
(?:
.   a |
.   b (?:
.   .   a |
.   .   b
.   ) |
.   ccc
)
$ print abc abd acde|trie
(?:
.   a (?:
.   .   b |
.   .   cde
.   )
)
$ print abc abd acde ac|trie
(?:
.   a (?:
.   .   b |
.   .   c
.   )
)
$ print abc abd acde acfg|trie
(?:
.   a (?:
.   .   b |
.   .   c
.   )
)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c (?:
.   .   de |
.   .   fg
.   )
)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
(?:
.   c (?:
.   .   fg |
.   .   ge
.   )
)
$ print a abcd abcdefg h hijk|trie
(?:
.   a (?:
.   .   bcd
.   )? |
.   h (?:
.   .   ijk
.   )?
)
$ print a abcd abcdefg abcdxyz h hijk|trie
(?:
.   a (?:
.   .   bcd
.   )? |
.   h (?:
.   .   ijk
.   )?
)
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
(?:
.   a (?:
.   .   bcd
.   )? |
.   h (?:
.   .   ijk |
.   .   lm
.   )?
)
$

--[ gen-wide-expr-perl-depth-2-alphabets-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=2 --trie=array < alphabets.txt
(?:
.   a (?:
.   .   a |
.   .   f |
.   .   gq |
.   .   k |
.   .   m |
.   .   r |
.   .   s |
.   .   z
.   ) |
.   b (?:
.   .   as |
.   .   e |
.   .   g |
.   .   m |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   yn
.   ) |
.   c (?:
.   .   a |
.   .   gg |
.   .   hr |
.   .   s |
.   .   y
.   ) |
.   d (?:
.   .   a |
.   .   e |
.   .   je |
.   .   ua |
.   .   yo |
.   .   z
.   ) |
.   e (?:
.   .   bu |
.   .   e |
.   .   l |
.   .   n |
.   .   o |
.   .   s |
.   .   t |
.   .   u |
.   .   wo
.   ) |
.   f (?:
.   .   a |
.   .   f |
.   .   i |
.   .   o |
.   .   r |
.   .   ur |
.   .   y
.   ) |
.   g (?:
.   .   a |
.   .   d |
.   .   l |
.   .   sw |
.   .   u |
.   .   v
.   ) |
.   h (?:
.   .   a |
.   .   e |
.   .   i |
.   .   r |
.   .   u |
.   .   y
.   ) |
.   i (?:
.   .   a |
.   .   d |
.   .   g |
.   .   i |
.   .   s |
.   .   t
.   ) |
.   j (?:
.   .   a |
.   .   go |
.   .   mc
.   ) |
.   k (?:
.   .   a |
.   .   de |
.   .   ea |
.   .   hq |
.   .   i |
.   .   k |
.   .   l |
.   .   m |
.   .   n |
.   .   o |
.   .   s |
.   .   w |
.   .   y
.   ) |
.   l (?:
.   .   ag |
.   .   g |
.   .   kt |
.   .   n |
.   .   o |
.   .   t |
.   .   u |
.   .   v
.   ) |
.   m (?:
.   .   as |
.   .   er |
.   .   fe |
.   .   g |
.   .   k |
.   .   l |
.   .   n |
.   .   r |
.   .   s |
.   .   t |
.   .   ua |
.   .   y
.   ) |
.   n (?:
.   .   aq |
.   .   b |
.   .   d |
.   .   e |
.   .   l |
.   .   mg |
.   .   n |
.   .   r |
.   .   so |
.   .   us |
.   .   yn
.   ) |
.   o (?:
.   .   m |
.   .   r |
.   .   s
.   ) |
.   p (?:
.   .   a |
.   .   l |
.   .   s |
.   .   t
.   ) |
.   r (?:
.   .   m |
.   .   n |
.   .   o |
.   .   u |
.   .   w
.   ) |
.   s (?:
.   .   a |
.   .   bp |
.   .   e |
.   .   g |
.   .   hi |
.   .   i |
.   .   k |
.   .   l |
.   .   n |
.   .   o |
.   .   q |
.   .   r |
.   .   s |
.   .   t |
.   .   v |
.   .   w
.   ) |
.   t (?:
.   .   a |
.   .   e |
.   .   g |
.   .   h |
.   .   i |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   wq |
.   .   zm
.   ) |
.   u (?:
.   .   g |
.   .   k |
.   .   r |
.   .   z
.   ) |
.   v (?:
.   .   ai_Latn |
.   .   e |
.   .   i |
.   .   o |
.   .   un
.   ) |
.   wa (?:
.   .   e |
.   .   l
.   ) |
.   x (?:
.   .   h |
.   .   og
.   ) |
.   y (?:
.   .   av |
.   .   o
.   ) |
.   z (?:
.   .   gh |
.   .   h |
.   .   u
.   )
)
$

--[ gen-wide-expr-perl-depth-2-alphabets-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=2 --trie=ternary < alphabets.txt
(?:
.   a (?:
.   .   a |
.   .   f |
.   .   gq |
.   .   k |
.   .   m |
.   .   r |
.   .   s |
.   .   z
.   ) |
.   b (?:
.   .   as |
.   .   e |
.   .   g |
.   .   m |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   yn
.   ) |
.   c (?:
.   .   a |
.   .   gg |
.   .   hr |
.   .   s |
.   .   y
.   ) |
.   d (?:
.   .   a |
.   .   e |
.   .   je |
.   .   ua |
.   .   yo |
.   .   z
.   ) |
.   e (?:
.   .   bu |
.   .   e |
.   .   l |
.   .   n |
.   .   o |
.   .   s |
.   .   t |
.   .   u |
.   .   wo
.   ) |
.   f (?:
.   .   a |
.   .   f |
.   .   i |
.   .   o |
.   .   r |
.   .   ur |
.   .   y
.   ) |
.   g (?:
.   .   a |
.   .   d |
.   .   l |
.   .   sw |
.   .   u |
.   .   v
.   ) |
.   h (?:
.   .   a |
.   .   e |
.   .   i |
.   .   r |
.   .   u |
.   .   y
.   ) |
.   i (?:
.   .   a |
.   .   d |
.   .   g |
.   .   i |
.   .   s |
.   .   t
.   ) |
.   j (?:
.   .   a |
.   .   go |
.   .   mc
.   ) |
.   k (?:
.   .   a |
.   .   de |
.   .   ea |
.   .   hq |
.   .   i |
.   .   k |
.   .   l |
.   .   m |
.   .   n |
.   .   o |
.   .   s |
.   .   w |
.   .   y
.   ) |
.   l (?:
.   .   ag |
.   .   g |
.   .   kt |
.   .   n |
.   .   o |
.   .   t |
.   .   u |
.   .   v
.   ) |
.   m (?:
.   .   as |
.   .   er |
.   .   fe |
.   .   g |
.   .   k |
.   .   l |
.   .   n |
.   .   r |
.   .   s |
.   .   t |
.   .   ua |
.   .   y
.   ) |
.   n (?:
.   .   aq |
.   .   b |
.   .   d |
.   .   e |
.   .   l |
.   .   mg |
.   .   n |
.   .   r |
.   .   so |
.   .   us |
.   .   yn
.   ) |
.   o (?:
.   .   m |
.   .   r |
.   .   s
.   ) |
.   p (?:
.   .   a |
.   .   l |
.   .   s |
.   .   t
.   ) |
.   r (?:
.   .   m |
.   .   n |
.   .   o |
.   .   u |
.   .   w
.   ) |
.   s (?:
.   .   a |
.   .   bp |
.   .   e |
.   .   g |
.   .   hi |
.   .   i |
.   .   k |
.   .   l |
.   .   n |
.   .   o |
.   .   q |
.   .   r |
.   .   s |
.   .   t |
.   .   v |
.   .   w
.   ) |
.   t (?:
.   .   a |
.   .   e |
.   .   g |
.   .   h |
.   .   i |
.   .   n |
.   .   o |
.   .   r |
.   .   s |
.   .   wq |
.   .   zm
.   ) |
.   u (?:
.   .   g |
.   .   k |
.   .   r |
.   .   z
.   ) |
.   v (?:
.   .   ai_Latn |
.   .   e |
.   .   i |
.   .   o |
.   .   un
.   ) |
.   wa (?:
.   .   e |
.   .   l
.   ) |
.   x (?:
.   .   h |
.   .   og
.   ) |
.   y (?:
.   .   av |
.   .   o
.   ) |
.   z (?:
.   .   gh |
.   .   h |
.   .   u
.   )
)
$

--[ gen-wide-expr-perl-depth-2-filenames-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=2 --trie=array --escape=/ < filenames.txt
(?:
.   c\+\+py-tree-demo\/ (?:
.   .   \.src- |
.   .   bin\.patch |
.   .   c\+\+py
.   )
)
$

--[ gen-wide-expr-perl-depth-2-filenames-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=perl --depth=2 --trie=ternary --escape=/ < filenames.txt
(?:
.   c\+\+py-tree-demo\/ (?:
.   .   \.src- |
.   .   bin\.patch |
.   .   c\+\+py
.   )
)
$

--[ gen-compact-expr-perl-depth-2-base0-array ]---------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=2 --trie=array "$@"; }
$ print a|trie
a
$ print a ab|trie
a(?:b)?
$ print a ab abc|trie
a(?:b)?
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a(?:b)?|b(?:ac)?
$ print a bb ba c|trie
a|b(?:a|b)|c
$ print a bb ba cc|trie
a|b(?:a|b)|cc
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print a bb ba cde|trie
a|b(?:a|b)|cde
$ print a bb ba cdef|trie
a|b(?:a|b)|cdef
$ print a bb ba cdef cdefg|trie
a|b(?:a|b)|cdef(?:g)?
$ print a bb bac cdef|trie
a|b(?:ac|b)|cdef
$ print a bbx ba ccc|trie
a|b(?:a|bx)|ccc
$ print a bbx bay ccc|trie
a|b(?:ay|bx)|ccc
$ print a cde cdef|trie
a|cde(?:f)?
$ print a cde cdef cdefg|trie
a|cde(?:f)?
$ print a cde cdef cdefgh|trie
a|cde(?:f)?
$ print a cdef cdefg|trie
a|cdef(?:g)?
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b(?:a|b)|ccc
$ print ab bb ba cde|trie
ab|b(?:a|b)|cde
$ print ab bbx ba ccc|trie
ab|b(?:a|bx)|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b(?:a|b)|ccc
$ print abcd abde abef|trie
ab(?:cd|de|ef)
$ print abg a abc ab abd|trie
a(?:b)?
$ print ac ab|trie
a(?:b|c)
$ print aef ae abg a abc ab abd|trie
a(?:b|e)?
$ print cde cdef cdefgh|trie
cde(?:f)?
$ print cdef cdefg|trie
cdef(?:g)?
$ print cdex cdfy cdgz cdhw|trie
cd(?:ex|fy|gz|hw)
$ print ce cdex cdfy cdgz cdhw|trie
c(?:d|e)
$ print pot potato pottery tattoo tempo|trie
pot(?:ato|tery)?|t(?:attoo|empo)
$

--[ gen-compact-expr-perl-depth-2-base0-ternary ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=2 --trie=ternary "$@"; }
$ print a|trie
a
$ print a ab|trie
a(?:b)?
$ print a ab abc|trie
a(?:b)?
$ print a b|trie
a|b
$ print a b abc bac abd|trie
a(?:b)?|b(?:ac)?
$ print a bb ba c|trie
a|b(?:a|b)|c
$ print a bb ba cc|trie
a|b(?:a|b)|cc
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print a bb ba cde|trie
a|b(?:a|b)|cde
$ print a bb ba cdef|trie
a|b(?:a|b)|cdef
$ print a bb ba cdef cdefg|trie
a|b(?:a|b)|cdef(?:g)?
$ print a bb bac cdef|trie
a|b(?:ac|b)|cdef
$ print a bbx ba ccc|trie
a|b(?:a|bx)|ccc
$ print a bbx bay ccc|trie
a|b(?:ay|bx)|ccc
$ print a cde cdef|trie
a|cde(?:f)?
$ print a cde cdef cdefg|trie
a|cde(?:f)?
$ print a cde cdef cdefgh|trie
a|cde(?:f)?
$ print a cdef cdefg|trie
a|cdef(?:g)?
$ print ab|trie
ab
$ print ab bb ba ccc|trie
ab|b(?:a|b)|ccc
$ print ab bb ba cde|trie
ab|b(?:a|b)|cde
$ print ab bbx ba ccc|trie
ab|b(?:a|bx)|ccc
$ print ab c|trie
ab|c
$ print abc bb ba ccc|trie
abc|b(?:a|b)|ccc
$ print abcd abde abef|trie
ab(?:cd|de|ef)
$ print abg a abc ab abd|trie
a(?:b)?
$ print ac ab|trie
a(?:b|c)
$ print aef ae abg a abc ab abd|trie
a(?:b|e)?
$ print cde cdef cdefgh|trie
cde(?:f)?
$ print cdef cdefg|trie
cdef(?:g)?
$ print cdex cdfy cdgz cdhw|trie
cd(?:ex|fy|gz|hw)
$ print ce cdex cdfy cdgz cdhw|trie
c(?:d|e)
$ print pot potato pottery tattoo tempo|trie
pot(?:ato|tery)?|t(?:attoo|empo)
$

--[ gen-compact-expr-perl-depth-2-base ]----------------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=2 --no-dots "$@"; }
$ print a ab abc abd ac|trie
a(?:b|c)?
$ print a ab abc abd ac|trie -t int
a(?:b|c)?
$ print a ab abc abd ac|trie -t float
a(?:b|c)?
$

--[ gen-compact-expr-perl-depth-2-base-array ]----------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=2 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a(?:b)?
$ print a ab ac|trie
a(?:b|c)?
$ print a ab ac ad|trie
a(?:b|c|d)?
$ print a abd ac|trie
a(?:bd|c)?
$ print a ab ac acd|trie
a(?:b|c)?
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print abc abd acde|trie
a(?:b|cde)
$ print abc abd acde ac|trie
a(?:b|c)
$ print abc abd acde acfg|trie
a(?:b|c)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(?:de|fg)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(?:fg|ge)
$ print a abcd abcdefg h hijk|trie
a(?:bcd)?|h(?:ijk)?
$ print a abcd abcdefg abcdxyz h hijk|trie
a(?:bcd)?|h(?:ijk)?
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a(?:bcd)?|h(?:ijk|lm)?
$

--[ gen-compact-expr-perl-depth-2-base-ternary ]--------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=perl --depth=2 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
a
$ print a b|trie
a|b
$ print a b c|trie
a|b|c
$ print a ab abc|trie
a(?:b)?
$ print a ab ac|trie
a(?:b|c)?
$ print a ab ac ad|trie
a(?:b|c|d)?
$ print a abd ac|trie
a(?:bd|c)?
$ print a ab ac acd|trie
a(?:b|c)?
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print a bb ccc|trie
a|bb|ccc
$ print a bb ba ccc|trie
a|b(?:a|b)|ccc
$ print abc abd acde|trie
a(?:b|cde)
$ print abc abd acde ac|trie
a(?:b|c)
$ print abc abd acde acfg|trie
a(?:b|c)
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(?:de|fg)
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
c(?:fg|ge)
$ print a abcd abcdefg h hijk|trie
a(?:bcd)?|h(?:ijk)?
$ print a abcd abcdefg abcdxyz h hijk|trie
a(?:bcd)?|h(?:ijk)?
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
a(?:bcd)?|h(?:ijk|lm)?
$

--[ gen-compact-expr-perl-depth-2-alphabets-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=2 --trie=array < alphabets.txt
a(?:a|f|gq|k|m|r|s|z)|b(?:as|e|g|m|n|o|r|s|yn)|c(?:a|gg|hr|s|y)|d(?:a|e|je|ua|yo|z)|e(?:bu|e|l|n|o|s|t|u|wo)|f(?:a|f|i|o|r|ur|y)|g(?:a|d|l|sw|u|v)|h(?:a|e|i|r|u|y)|i(?:a|d|g|i|s|t)|j(?:a|go|mc)|k(?:a|de|ea|hq|i|k|l|m|n|o|s|w|y)|l(?:ag|g|kt|n|o|t|u|v)|m(?:as|er|fe|g|k|l|n|r|s|t|ua|y)|n(?:aq|b|d|e|l|mg|n|r|so|us|yn)|o(?:m|r|s)|p(?:a|l|s|t)|r(?:m|n|o|u|w)|s(?:a|bp|e|g|hi|i|k|l|n|o|q|r|s|t|v|w)|t(?:a|e|g|h|i|n|o|r|s|wq|zm)|u(?:g|k|r|z)|v(?:ai_Latn|e|i|o|un)|wa(?:e|l)|x(?:h|og)|y(?:av|o)|z(?:gh|h|u)
$

--[ gen-compact-expr-perl-depth-2-alphabets-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=2 --trie=ternary < alphabets.txt
a(?:a|f|gq|k|m|r|s|z)|b(?:as|e|g|m|n|o|r|s|yn)|c(?:a|gg|hr|s|y)|d(?:a|e|je|ua|yo|z)|e(?:bu|e|l|n|o|s|t|u|wo)|f(?:a|f|i|o|r|ur|y)|g(?:a|d|l|sw|u|v)|h(?:a|e|i|r|u|y)|i(?:a|d|g|i|s|t)|j(?:a|go|mc)|k(?:a|de|ea|hq|i|k|l|m|n|o|s|w|y)|l(?:ag|g|kt|n|o|t|u|v)|m(?:as|er|fe|g|k|l|n|r|s|t|ua|y)|n(?:aq|b|d|e|l|mg|n|r|so|us|yn)|o(?:m|r|s)|p(?:a|l|s|t)|r(?:m|n|o|u|w)|s(?:a|bp|e|g|hi|i|k|l|n|o|q|r|s|t|v|w)|t(?:a|e|g|h|i|n|o|r|s|wq|zm)|u(?:g|k|r|z)|v(?:ai_Latn|e|i|o|un)|wa(?:e|l)|x(?:h|og)|y(?:av|o)|z(?:gh|h|u)
$

--[ gen-compact-expr-perl-depth-2-filenames-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=2 --trie=array --escape=/ < filenames.txt
c\+\+py-tree-demo\/(?:\.src-|bin\.patch|c\+\+py)
$

--[ gen-compact-expr-perl-depth-2-filenames-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=perl --depth=2 --trie=ternary --escape=/ < filenames.txt
c\+\+py-tree-demo\/(?:\.src-|bin\.patch|c\+\+py)
$

--[ gen-wide-expr-bash-depth-0-base0-array ]------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=0 --trie=array "$@"; }
$ print a|trie
{
    a
}
$ print a ab|trie
{
    a {,
        b
    }
}
$ print a ab abc|trie
{
    a {,
        b {,
            c
        }
    }
}
$ print a b|trie
{
    a ,
    b
}
$ print a b abc bac abd|trie
{
    a {,
        b {
            c ,
            d
        }
    } ,
    b {,
        ac
    }
}
$ print a bb ba c|trie
{
    a ,
    b {
        a ,
        b
    } ,
    c
}
$ print a bb ba cc|trie
{
    a ,
    b {
        a ,
        b
    } ,
    cc
}
$ print a bb ba ccc|trie
{
    a ,
    b {
        a ,
        b
    } ,
    ccc
}
$ print a bb ba cde|trie
{
    a ,
    b {
        a ,
        b
    } ,
    cde
}
$ print a bb ba cdef|trie
{
    a ,
    b {
        a ,
        b
    } ,
    cdef
}
$ print a bb ba cdef cdefg|trie
{
    a ,
    b {
        a ,
        b
    } ,
    cdef {,
        g
    }
}
$ print a bb bac cdef|trie
{
    a ,
    b {
        ac ,
        b
    } ,
    cdef
}
$ print a bbx ba ccc|trie
{
    a ,
    b {
        a ,
        bx
    } ,
    ccc
}
$ print a bbx bay ccc|trie
{
    a ,
    b {
        ay ,
        bx
    } ,
    ccc
}
$ print a cde cdef|trie
{
    a ,
    cde {,
        f
    }
}
$ print a cde cdef cdefg|trie
{
    a ,
    cde {,
        f {,
            g
        }
    }
}
$ print a cde cdef cdefgh|trie
{
    a ,
    cde {,
        f {,
            gh
        }
    }
}
$ print a cdef cdefg|trie
{
    a ,
    cdef {,
        g
    }
}
$ print ab|trie
{
    ab
}
$ print ab bb ba ccc|trie
{
    ab ,
    b {
        a ,
        b
    } ,
    ccc
}
$ print ab bb ba cde|trie
{
    ab ,
    b {
        a ,
        b
    } ,
    cde
}
$ print ab bbx ba ccc|trie
{
    ab ,
    b {
        a ,
        bx
    } ,
    ccc
}
$ print ab c|trie
{
    ab ,
    c
}
$ print abc bb ba ccc|trie
{
    abc ,
    b {
        a ,
        b
    } ,
    ccc
}
$ print abcd abde abef|trie
{
    ab {
        cd ,
        de ,
        ef
    }
}
$ print abg a abc ab abd|trie
{
    a {,
        b {,
            c ,
            d ,
            g
        }
    }
}
$ print ac ab|trie
{
    a {
        b ,
        c
    }
}
$ print aef ae abg a abc ab abd|trie
{
    a {,
        b {,
            c ,
            d ,
            g
        } ,
        e {,
            f
        }
    }
}
$ print cde cdef cdefgh|trie
{
    cde {,
        f {,
            gh
        }
    }
}
$ print cdef cdefg|trie
{
    cdef {,
        g
    }
}
$ print cdex cdfy cdgz cdhw|trie
{
    cd {
        ex ,
        fy ,
        gz ,
        hw
    }
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    c {
        d {
            ex ,
            fy ,
            gz ,
            hw
        } ,
        e
    }
}
$ print pot potato pottery tattoo tempo|trie
{
    pot {,
        ato ,
        tery
    } ,
    t {
        attoo ,
        empo
    }
}
$

--[ gen-wide-expr-bash-depth-0-base0-ternary ]----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=0 --trie=ternary "$@"; }
$ print a|trie
{
    a
}
$ print a ab|trie
{
    a {,
        b
    }
}
$ print a ab abc|trie
{
    a {,
        b {,
            c
        }
    }
}
$ print a b|trie
{
    a,
    b
}
$ print a b abc bac abd|trie
{
    a {,
        b {
            c,
            d
        }
    },
    b {,
        ac
    }
}
$ print a bb ba c|trie
{
    a,
    b {
        a,
        b
    },
    c
}
$ print a bb ba cc|trie
{
    a,
    b {
        a,
        b
    },
    cc
}
$ print a bb ba ccc|trie
{
    a,
    b {
        a,
        b
    },
    ccc
}
$ print a bb ba cde|trie
{
    a,
    b {
        a,
        b
    },
    cde
}
$ print a bb ba cdef|trie
{
    a,
    b {
        a,
        b
    },
    cdef
}
$ print a bb ba cdef cdefg|trie
{
    a,
    b {
        a,
        b
    },
    cdef {,
        g
    }
}
$ print a bb bac cdef|trie
{
    a,
    b {
        ac,
        b
    },
    cdef
}
$ print a bbx ba ccc|trie
{
    a,
    b {
        a,
        bx
    },
    ccc
}
$ print a bbx bay ccc|trie
{
    a,
    b {
        ay,
        bx
    },
    ccc
}
$ print a cde cdef|trie
{
    a,
    cde {,
        f
    }
}
$ print a cde cdef cdefg|trie
{
    a,
    cde {,
        f {,
            g
        }
    }
}
$ print a cde cdef cdefgh|trie
{
    a,
    cde {,
        f {,
            gh
        }
    }
}
$ print a cdef cdefg|trie
{
    a,
    cdef {,
        g
    }
}
$ print ab|trie
{
    ab
}
$ print ab bb ba ccc|trie
{
    ab,
    b {
        a,
        b
    },
    ccc
}
$ print ab bb ba cde|trie
{
    ab,
    b {
        a,
        b
    },
    cde
}
$ print ab bbx ba ccc|trie
{
    ab,
    b {
        a,
        bx
    },
    ccc
}
$ print ab c|trie
{
    ab,
    c
}
$ print abc bb ba ccc|trie
{
    abc,
    b {
        a,
        b
    },
    ccc
}
$ print abcd abde abef|trie
{
    ab {
        cd,
        de,
        ef
    }
}
$ print abg a abc ab abd|trie
{
    a {,
        b {,
            c,
            d,
            g
        }
    }
}
$ print ac ab|trie
{
    a {
        b,
        c
    }
}
$ print aef ae abg a abc ab abd|trie
{
    a {,
        b {,
            c,
            d,
            g
        },
        e {,
            f
        }
    }
}
$ print cde cdef cdefgh|trie
{
    cde {,
        f {,
            gh
        }
    }
}
$ print cdef cdefg|trie
{
    cdef {,
        g
    }
}
$ print cdex cdfy cdgz cdhw|trie
{
    cd {
        ex,
        fy,
        gz,
        hw
    }
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    c {
        d {
            ex,
            fy,
            gz,
            hw
        },
        e
    }
}
$ print pot potato pottery tattoo tempo|trie
{
    pot {,
        ato,
        tery
    },
    t {
        attoo,
        empo
    }
}
$

--[ gen-wide-expr-bash-depth-0-base ]-------------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=0 --no-dots "$@"; }
$ print a ab abc abd ac|trie
{
    a {,
        b {,
            c,
            d
        },
        c
    }
}
$ print a ab abc abd ac|trie -t int
{
    a {,
        b {,
            c,
            d
        },
        c
    }
}
$ print a ab abc abd ac|trie -t float
{
    a {,
        b {,
            c,
            d
        },
        c
    }
}
$

--[ gen-wide-expr-bash-depth-0-base-array ]-------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=0 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{
.   a
}
$ print a b|trie
{
.   a ,
.   b
}
$ print a b c|trie
{
.   a ,
.   b ,
.   c
}
$ print a ab abc|trie
{
.   a {,
.   .   b {,
.   .   .   c
.   .   }
.   }
}
$ print a ab ac|trie
{
.   a {,
.   .   b ,
.   .   c
.   }
}
$ print a ab ac ad|trie
{
.   a {,
.   .   b ,
.   .   c ,
.   .   d
.   }
}
$ print a abd ac|trie
{
.   a {,
.   .   bd ,
.   .   c
.   }
}
$ print a ab ac acd|trie
{
.   a {,
.   .   b ,
.   .   c {,
.   .   .   d
.   .   }
.   }
}
$ print a bb ba ccc|trie
{
.   a ,
.   b {
.   .   a ,
.   .   b
.   } ,
.   ccc
}
$ print a bb ccc|trie
{
.   a ,
.   bb ,
.   ccc
}
$ print a bb ba ccc|trie
{
.   a ,
.   b {
.   .   a ,
.   .   b
.   } ,
.   ccc
}
$ print abc abd acde|trie
{
.   a {
.   .   b {
.   .   .   c ,
.   .   .   d
.   .   } ,
.   .   cde
.   }
}
$ print abc abd acde ac|trie
{
.   a {
.   .   b {
.   .   .   c ,
.   .   .   d
.   .   } ,
.   .   c {,
.   .   .   de
.   .   }
.   }
}
$ print abc abd acde acfg|trie
{
.   a {
.   .   b {
.   .   .   c ,
.   .   .   d
.   .   } ,
.   .   c {
.   .   .   de ,
.   .   .   fg
.   .   }
.   }
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c {
.   .   de ,
.   .   fg {,
.   .   .   x {,
.   .   .   .   y {,
.   .   .   .   .   z
.   .   .   .   } ,
.   .   .   .   zzz
.   .   .   }
.   .   }
.   }
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c {
.   .   fg {,
.   .   .   x {,
.   .   .   .   y {,
.   .   .   .   .   z
.   .   .   .   } ,
.   .   .   .   zzz
.   .   .   }
.   .   } ,
.   .   ge
.   }
}
$ print a abcd abcdefg h hijk|trie
{
.   a {,
.   .   bcd {,
.   .   .   efg
.   .   }
.   } ,
.   h {,
.   .   ijk
.   }
}
$ print a abcd abcdefg abcdxyz h hijk|trie
{
.   a {,
.   .   bcd {,
.   .   .   efg ,
.   .   .   xyz
.   .   }
.   } ,
.   h {,
.   .   ijk
.   }
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{
.   a {,
.   .   bcd {,
.   .   .   efg ,
.   .   .   xyz
.   .   }
.   } ,
.   h {,
.   .   ijk ,
.   .   lm
.   }
}
$

--[ gen-wide-expr-bash-depth-0-base-ternary ]-----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=0 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{
.   a
}
$ print a b|trie
{
.   a,
.   b
}
$ print a b c|trie
{
.   a,
.   b,
.   c
}
$ print a ab abc|trie
{
.   a {,
.   .   b {,
.   .   .   c
.   .   }
.   }
}
$ print a ab ac|trie
{
.   a {,
.   .   b,
.   .   c
.   }
}
$ print a ab ac ad|trie
{
.   a {,
.   .   b,
.   .   c,
.   .   d
.   }
}
$ print a abd ac|trie
{
.   a {,
.   .   bd,
.   .   c
.   }
}
$ print a ab ac acd|trie
{
.   a {,
.   .   b,
.   .   c {,
.   .   .   d
.   .   }
.   }
}
$ print a bb ba ccc|trie
{
.   a,
.   b {
.   .   a,
.   .   b
.   },
.   ccc
}
$ print a bb ccc|trie
{
.   a,
.   bb,
.   ccc
}
$ print a bb ba ccc|trie
{
.   a,
.   b {
.   .   a,
.   .   b
.   },
.   ccc
}
$ print abc abd acde|trie
{
.   a {
.   .   b {
.   .   .   c,
.   .   .   d
.   .   },
.   .   cde
.   }
}
$ print abc abd acde ac|trie
{
.   a {
.   .   b {
.   .   .   c,
.   .   .   d
.   .   },
.   .   c {,
.   .   .   de
.   .   }
.   }
}
$ print abc abd acde acfg|trie
{
.   a {
.   .   b {
.   .   .   c,
.   .   .   d
.   .   },
.   .   c {
.   .   .   de,
.   .   .   fg
.   .   }
.   }
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c {
.   .   de,
.   .   fg {,
.   .   .   x {,
.   .   .   .   y {,
.   .   .   .   .   z
.   .   .   .   },
.   .   .   .   zzz
.   .   .   }
.   .   }
.   }
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c {
.   .   fg {,
.   .   .   x {,
.   .   .   .   y {,
.   .   .   .   .   z
.   .   .   .   },
.   .   .   .   zzz
.   .   .   }
.   .   },
.   .   ge
.   }
}
$ print a abcd abcdefg h hijk|trie
{
.   a {,
.   .   bcd {,
.   .   .   efg
.   .   }
.   },
.   h {,
.   .   ijk
.   }
}
$ print a abcd abcdefg abcdxyz h hijk|trie
{
.   a {,
.   .   bcd {,
.   .   .   efg,
.   .   .   xyz
.   .   }
.   },
.   h {,
.   .   ijk
.   }
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{
.   a {,
.   .   bcd {,
.   .   .   efg,
.   .   .   xyz
.   .   }
.   },
.   h {,
.   .   ijk,
.   .   lm
.   }
}
$

--[ gen-wide-expr-bash-depth-0-alphabets-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=0 --trie=array < alphabets.txt
{
.   a {
.   .   a ,
.   .   f ,
.   .   gq ,
.   .   k ,
.   .   m ,
.   .   r ,
.   .   s {,
.   .   .   a ,
.   .   .   t
.   .   } ,
.   .   z {,
.   .   .   _Cyrl
.   .   }
.   } ,
.   b {
.   .   as ,
.   .   e {,
.   .   .   m ,
.   .   .   z
.   .   } ,
.   .   g ,
.   .   m ,
.   .   n ,
.   .   o ,
.   .   r {,
.   .   .   x
.   .   } ,
.   .   s {,
.   .   .   _Cyrl
.   .   } ,
.   .   yn
.   } ,
.   c {
.   .   a ,
.   .   gg ,
.   .   hr ,
.   .   s ,
.   .   y
.   } ,
.   d {
.   .   a {,
.   .   .   v
.   .   } ,
.   .   e ,
.   .   je ,
.   .   ua ,
.   .   yo ,
.   .   z
.   } ,
.   e {
.   .   bu ,
.   .   e ,
.   .   l ,
.   .   n ,
.   .   o ,
.   .   s ,
.   .   t ,
.   .   u ,
.   .   wo
.   } ,
.   f {
.   .   a ,
.   .   f ,
.   .   i {,
.   .   .   l
.   .   } ,
.   .   o ,
.   .   r ,
.   .   ur ,
.   .   y
.   } ,
.   g {
.   .   a ,
.   .   d ,
.   .   l ,
.   .   sw ,
.   .   u {,
.   .   .   z
.   .   } ,
.   .   v
.   } ,
.   h {
.   .   a {,
.   .   .   w
.   .   } ,
.   .   e ,
.   .   i ,
.   .   r ,
.   .   u ,
.   .   y
.   } ,
.   i {
.   .   a ,
.   .   d ,
.   .   g ,
.   .   i ,
.   .   s ,
.   .   t
.   } ,
.   j {
.   .   a ,
.   .   go ,
.   .   mc
.   } ,
.   k {
.   .   a {,
.   .   .   b ,
.   .   .   m
.   .   } ,
.   .   de ,
.   .   ea ,
.   .   hq ,
.   .   i ,
.   .   k {,
.   .   .   j
.   .   } ,
.   .   l {,
.   .   .   n
.   .   } ,
.   .   m ,
.   .   n ,
.   .   o {,
.   .   .   k
.   .   } ,
.   .   s {
.   .   .   b ,
.   .   .   f ,
.   .   .   h
.   .   } ,
.   .   w ,
.   .   y
.   } ,
.   l {
.   .   ag ,
.   .   g ,
.   .   kt ,
.   .   n ,
.   .   o ,
.   .   t ,
.   .   u {,
.   .   .   o ,
.   .   .   y
.   .   } ,
.   .   v
.   } ,
.   m {
.   .   as ,
.   .   er ,
.   .   fe ,
.   .   g {,
.   .   .   h ,
.   .   .   o
.   .   } ,
.   .   k ,
.   .   l ,
.   .   n ,
.   .   r ,
.   .   s ,
.   .   t ,
.   .   ua ,
.   .   y
.   } ,
.   n {
.   .   aq ,
.   .   b ,
.   .   d ,
.   .   e ,
.   .   l ,
.   .   mg ,
.   .   n {,
.   .   .   h
.   .   } ,
.   .   r ,
.   .   so ,
.   .   us ,
.   .   yn
.   } ,
.   o {
.   .   m ,
.   .   r ,
.   .   s
.   } ,
.   p {
.   .   a {,
.   .   .   _Arab
.   .   } ,
.   .   l ,
.   .   s ,
.   .   t
.   } ,
.   r {
.   .   m ,
.   .   n ,
.   .   o {,
.   .   .   f
.   .   } ,
.   .   u ,
.   .   w {,
.   .   .   k
.   .   }
.   } ,
.   s {
.   .   a {
.   .   .   h ,
.   .   .   q
.   .   } ,
.   .   bp ,
.   .   e {,
.   .   .   h ,
.   .   .   s
.   .   } ,
.   .   g ,
.   .   hi {,
.   .   .   _Latn
.   .   } ,
.   .   i ,
.   .   k ,
.   .   l ,
.   .   n ,
.   .   o ,
.   .   q ,
.   .   r {,
.   .   .   _Latn
.   .   } ,
.   .   s {,
.   .   .   y
.   .   } ,
.   .   t ,
.   .   v ,
.   .   w {,
.   .   .   c
.   .   }
.   } ,
.   t {
.   .   a ,
.   .   e {,
.   .   .   o
.   .   } ,
.   .   g ,
.   .   h ,
.   .   i {,
.   .   .   _ER ,
.   .   .   g
.   .   } ,
.   .   n ,
.   .   o ,
.   .   r ,
.   .   s ,
.   .   wq ,
.   .   zm
.   } ,
.   u {
.   .   g ,
.   .   k ,
.   .   r ,
.   .   z {,
.   .   .   _ {
.   .   .   .   Arab ,
.   .   .   .   Cyrl
.   .   .   }
.   .   }
.   } ,
.   v {
.   .   ai_Latn ,
.   .   e ,
.   .   i ,
.   .   o ,
.   .   un
.   } ,
.   wa {
.   .   e ,
.   .   l
.   } ,
.   x {
.   .   h ,
.   .   og
.   } ,
.   y {
.   .   av ,
.   .   o {,
.   .   .   _BJ
.   .   }
.   } ,
.   z {
.   .   gh ,
.   .   h {,
.   .   .   _Hant
.   .   } ,
.   .   u
.   }
}
$

--[ gen-wide-expr-bash-depth-0-alphabets-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=0 --trie=ternary < alphabets.txt
{
.   a {
.   .   a,
.   .   f,
.   .   gq,
.   .   k,
.   .   m,
.   .   r,
.   .   s {,
.   .   .   a,
.   .   .   t
.   .   },
.   .   z {,
.   .   .   _Cyrl
.   .   }
.   },
.   b {
.   .   as,
.   .   e {,
.   .   .   m,
.   .   .   z
.   .   },
.   .   g,
.   .   m,
.   .   n,
.   .   o,
.   .   r {,
.   .   .   x
.   .   },
.   .   s {,
.   .   .   _Cyrl
.   .   },
.   .   yn
.   },
.   c {
.   .   a,
.   .   gg,
.   .   hr,
.   .   s,
.   .   y
.   },
.   d {
.   .   a {,
.   .   .   v
.   .   },
.   .   e,
.   .   je,
.   .   ua,
.   .   yo,
.   .   z
.   },
.   e {
.   .   bu,
.   .   e,
.   .   l,
.   .   n,
.   .   o,
.   .   s,
.   .   t,
.   .   u,
.   .   wo
.   },
.   f {
.   .   a,
.   .   f,
.   .   i {,
.   .   .   l
.   .   },
.   .   o,
.   .   r,
.   .   ur,
.   .   y
.   },
.   g {
.   .   a,
.   .   d,
.   .   l,
.   .   sw,
.   .   u {,
.   .   .   z
.   .   },
.   .   v
.   },
.   h {
.   .   a {,
.   .   .   w
.   .   },
.   .   e,
.   .   i,
.   .   r,
.   .   u,
.   .   y
.   },
.   i {
.   .   a,
.   .   d,
.   .   g,
.   .   i,
.   .   s,
.   .   t
.   },
.   j {
.   .   a,
.   .   go,
.   .   mc
.   },
.   k {
.   .   a {,
.   .   .   b,
.   .   .   m
.   .   },
.   .   de,
.   .   ea,
.   .   hq,
.   .   i,
.   .   k {,
.   .   .   j
.   .   },
.   .   l {,
.   .   .   n
.   .   },
.   .   m,
.   .   n,
.   .   o {,
.   .   .   k
.   .   },
.   .   s {
.   .   .   b,
.   .   .   f,
.   .   .   h
.   .   },
.   .   w,
.   .   y
.   },
.   l {
.   .   ag,
.   .   g,
.   .   kt,
.   .   n,
.   .   o,
.   .   t,
.   .   u {,
.   .   .   o,
.   .   .   y
.   .   },
.   .   v
.   },
.   m {
.   .   as,
.   .   er,
.   .   fe,
.   .   g {,
.   .   .   h,
.   .   .   o
.   .   },
.   .   k,
.   .   l,
.   .   n,
.   .   r,
.   .   s,
.   .   t,
.   .   ua,
.   .   y
.   },
.   n {
.   .   aq,
.   .   b,
.   .   d,
.   .   e,
.   .   l,
.   .   mg,
.   .   n {,
.   .   .   h
.   .   },
.   .   r,
.   .   so,
.   .   us,
.   .   yn
.   },
.   o {
.   .   m,
.   .   r,
.   .   s
.   },
.   p {
.   .   a {,
.   .   .   _Arab
.   .   },
.   .   l,
.   .   s,
.   .   t
.   },
.   r {
.   .   m,
.   .   n,
.   .   o {,
.   .   .   f
.   .   },
.   .   u,
.   .   w {,
.   .   .   k
.   .   }
.   },
.   s {
.   .   a {
.   .   .   h,
.   .   .   q
.   .   },
.   .   bp,
.   .   e {,
.   .   .   h,
.   .   .   s
.   .   },
.   .   g,
.   .   hi {,
.   .   .   _Latn
.   .   },
.   .   i,
.   .   k,
.   .   l,
.   .   n,
.   .   o,
.   .   q,
.   .   r {,
.   .   .   _Latn
.   .   },
.   .   s {,
.   .   .   y
.   .   },
.   .   t,
.   .   v,
.   .   w {,
.   .   .   c
.   .   }
.   },
.   t {
.   .   a,
.   .   e {,
.   .   .   o
.   .   },
.   .   g,
.   .   h,
.   .   i {,
.   .   .   _ER,
.   .   .   g
.   .   },
.   .   n,
.   .   o,
.   .   r,
.   .   s,
.   .   wq,
.   .   zm
.   },
.   u {
.   .   g,
.   .   k,
.   .   r,
.   .   z {,
.   .   .   _ {
.   .   .   .   Arab,
.   .   .   .   Cyrl
.   .   .   }
.   .   }
.   },
.   v {
.   .   ai_Latn,
.   .   e,
.   .   i,
.   .   o,
.   .   un
.   },
.   wa {
.   .   e,
.   .   l
.   },
.   x {
.   .   h,
.   .   og
.   },
.   y {
.   .   av,
.   .   o {,
.   .   .   _BJ
.   .   }
.   },
.   z {
.   .   gh,
.   .   h {,
.   .   .   _Hant
.   .   },
.   .   u
.   }
}
$

--[ gen-wide-expr-bash-depth-0-filenames-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=0 --trie=array --escape=/ < filenames.txt
{
.   c++py-tree-demo\/ {
.   .   .src- {
.   .   .   dirs ,
.   .   .   files
.   .   } ,
.   .   bin.patch ,
.   .   c++py {
.   .   .   -tree {
.   .   .   .   - {
.   .   .   .   .   author.txt ,
.   .   .   .   .   demo.txt ,
.   .   .   .   .   readme. {
.   .   .   .   .   .   pdf ,
.   .   .   .   .   .   t {
.   .   .   .   .   .   .   ex ,
.   .   .   .   .   .   .   xt
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   } ,
.   .   .   .   . {
.   .   .   .   .   pdf ,
.   .   .   .   .   t {
.   .   .   .   .   .   ex ,
.   .   .   .   .   .   xt
.   .   .   .   .   }
.   .   .   .   }
.   .   .   } ,
.   .   .   \/ {
.   .   .   .   .src- {
.   .   .   .   .   dirs ,
.   .   .   .   .   files
.   .   .   .   } ,
.   .   .   .   AUTHOR ,
.   .   .   .   Makefile ,
.   .   .   .   README
.   .   .   }
.   .   }
.   }
}
$

--[ gen-wide-expr-bash-depth-0-filenames-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=0 --trie=ternary --escape=/ < filenames.txt
{
.   c++py-tree-demo\/ {
.   .   .src- {
.   .   .   dirs,
.   .   .   files
.   .   },
.   .   bin.patch,
.   .   c++py {
.   .   .   -tree {
.   .   .   .   - {
.   .   .   .   .   author.txt,
.   .   .   .   .   demo.txt,
.   .   .   .   .   readme. {
.   .   .   .   .   .   pdf,
.   .   .   .   .   .   t {
.   .   .   .   .   .   .   ex,
.   .   .   .   .   .   .   xt
.   .   .   .   .   .   }
.   .   .   .   .   }
.   .   .   .   },
.   .   .   .   . {
.   .   .   .   .   pdf,
.   .   .   .   .   t {
.   .   .   .   .   .   ex,
.   .   .   .   .   .   xt
.   .   .   .   .   }
.   .   .   .   }
.   .   .   },
.   .   .   \/ {
.   .   .   .   .src- {
.   .   .   .   .   dirs,
.   .   .   .   .   files
.   .   .   .   },
.   .   .   .   AUTHOR,
.   .   .   .   Makefile,
.   .   .   .   README
.   .   .   }
.   .   }
.   }
}
$

--[ gen-compact-expr-bash-depth-0-base0-array ]---------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=0 --trie=array "$@"; }
$ print a|trie
{a}
$ print a ab|trie
{a{,b}}
$ print a ab abc|trie
{a{,b{,c}}}
$ print a b|trie
{a,b}
$ print a b abc bac abd|trie
{a{,b{c,d}},b{,ac}}
$ print a bb ba c|trie
{a,b{a,b},c}
$ print a bb ba cc|trie
{a,b{a,b},cc}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print a bb ba cde|trie
{a,b{a,b},cde}
$ print a bb ba cdef|trie
{a,b{a,b},cdef}
$ print a bb ba cdef cdefg|trie
{a,b{a,b},cdef{,g}}
$ print a bb bac cdef|trie
{a,b{ac,b},cdef}
$ print a bbx ba ccc|trie
{a,b{a,bx},ccc}
$ print a bbx bay ccc|trie
{a,b{ay,bx},ccc}
$ print a cde cdef|trie
{a,cde{,f}}
$ print a cde cdef cdefg|trie
{a,cde{,f{,g}}}
$ print a cde cdef cdefgh|trie
{a,cde{,f{,gh}}}
$ print a cdef cdefg|trie
{a,cdef{,g}}
$ print ab|trie
{ab}
$ print ab bb ba ccc|trie
{ab,b{a,b},ccc}
$ print ab bb ba cde|trie
{ab,b{a,b},cde}
$ print ab bbx ba ccc|trie
{ab,b{a,bx},ccc}
$ print ab c|trie
{ab,c}
$ print abc bb ba ccc|trie
{abc,b{a,b},ccc}
$ print abcd abde abef|trie
{ab{cd,de,ef}}
$ print abg a abc ab abd|trie
{a{,b{,c,d,g}}}
$ print ac ab|trie
{a{b,c}}
$ print aef ae abg a abc ab abd|trie
{a{,b{,c,d,g},e{,f}}}
$ print cde cdef cdefgh|trie
{cde{,f{,gh}}}
$ print cdef cdefg|trie
{cdef{,g}}
$ print cdex cdfy cdgz cdhw|trie
{cd{ex,fy,gz,hw}}
$ print ce cdex cdfy cdgz cdhw|trie
{c{d{ex,fy,gz,hw},e}}
$ print pot potato pottery tattoo tempo|trie
{pot{,ato,tery},t{attoo,empo}}
$

--[ gen-compact-expr-bash-depth-0-base0-ternary ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=0 --trie=ternary "$@"; }
$ print a|trie
{a}
$ print a ab|trie
{a{,b}}
$ print a ab abc|trie
{a{,b{,c}}}
$ print a b|trie
{a,b}
$ print a b abc bac abd|trie
{a{,b{c,d}},b{,ac}}
$ print a bb ba c|trie
{a,b{a,b},c}
$ print a bb ba cc|trie
{a,b{a,b},cc}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print a bb ba cde|trie
{a,b{a,b},cde}
$ print a bb ba cdef|trie
{a,b{a,b},cdef}
$ print a bb ba cdef cdefg|trie
{a,b{a,b},cdef{,g}}
$ print a bb bac cdef|trie
{a,b{ac,b},cdef}
$ print a bbx ba ccc|trie
{a,b{a,bx},ccc}
$ print a bbx bay ccc|trie
{a,b{ay,bx},ccc}
$ print a cde cdef|trie
{a,cde{,f}}
$ print a cde cdef cdefg|trie
{a,cde{,f{,g}}}
$ print a cde cdef cdefgh|trie
{a,cde{,f{,gh}}}
$ print a cdef cdefg|trie
{a,cdef{,g}}
$ print ab|trie
{ab}
$ print ab bb ba ccc|trie
{ab,b{a,b},ccc}
$ print ab bb ba cde|trie
{ab,b{a,b},cde}
$ print ab bbx ba ccc|trie
{ab,b{a,bx},ccc}
$ print ab c|trie
{ab,c}
$ print abc bb ba ccc|trie
{abc,b{a,b},ccc}
$ print abcd abde abef|trie
{ab{cd,de,ef}}
$ print abg a abc ab abd|trie
{a{,b{,c,d,g}}}
$ print ac ab|trie
{a{b,c}}
$ print aef ae abg a abc ab abd|trie
{a{,b{,c,d,g},e{,f}}}
$ print cde cdef cdefgh|trie
{cde{,f{,gh}}}
$ print cdef cdefg|trie
{cdef{,g}}
$ print cdex cdfy cdgz cdhw|trie
{cd{ex,fy,gz,hw}}
$ print ce cdex cdfy cdgz cdhw|trie
{c{d{ex,fy,gz,hw},e}}
$ print pot potato pottery tattoo tempo|trie
{pot{,ato,tery},t{attoo,empo}}
$

--[ gen-compact-expr-bash-depth-0-base ]----------------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=0 --no-dots "$@"; }
$ print a ab abc abd ac|trie
{a{,b{,c,d},c}}
$ print a ab abc abd ac|trie -t int
{a{,b{,c,d},c}}
$ print a ab abc abd ac|trie -t float
{a{,b{,c,d},c}}
$

--[ gen-compact-expr-bash-depth-0-base-array ]----------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=0 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{a}
$ print a b|trie
{a,b}
$ print a b c|trie
{a,b,c}
$ print a ab abc|trie
{a{,b{,c}}}
$ print a ab ac|trie
{a{,b,c}}
$ print a ab ac ad|trie
{a{,b,c,d}}
$ print a abd ac|trie
{a{,bd,c}}
$ print a ab ac acd|trie
{a{,b,c{,d}}}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print a bb ccc|trie
{a,bb,ccc}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print abc abd acde|trie
{a{b{c,d},cde}}
$ print abc abd acde ac|trie
{a{b{c,d},c{,de}}}
$ print abc abd acde acfg|trie
{a{b{c,d},c{de,fg}}}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c{de,fg{,x{,y{,z},zzz}}}}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c{fg{,x{,y{,z},zzz}},ge}}
$ print a abcd abcdefg h hijk|trie
{a{,bcd{,efg}},h{,ijk}}
$ print a abcd abcdefg abcdxyz h hijk|trie
{a{,bcd{,efg,xyz}},h{,ijk}}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{a{,bcd{,efg,xyz}},h{,ijk,lm}}
$

--[ gen-compact-expr-bash-depth-0-base-ternary ]--------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=0 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{a}
$ print a b|trie
{a,b}
$ print a b c|trie
{a,b,c}
$ print a ab abc|trie
{a{,b{,c}}}
$ print a ab ac|trie
{a{,b,c}}
$ print a ab ac ad|trie
{a{,b,c,d}}
$ print a abd ac|trie
{a{,bd,c}}
$ print a ab ac acd|trie
{a{,b,c{,d}}}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print a bb ccc|trie
{a,bb,ccc}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print abc abd acde|trie
{a{b{c,d},cde}}
$ print abc abd acde ac|trie
{a{b{c,d},c{,de}}}
$ print abc abd acde acfg|trie
{a{b{c,d},c{de,fg}}}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c{de,fg{,x{,y{,z},zzz}}}}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c{fg{,x{,y{,z},zzz}},ge}}
$ print a abcd abcdefg h hijk|trie
{a{,bcd{,efg}},h{,ijk}}
$ print a abcd abcdefg abcdxyz h hijk|trie
{a{,bcd{,efg,xyz}},h{,ijk}}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{a{,bcd{,efg,xyz}},h{,ijk,lm}}
$

--[ gen-compact-expr-bash-depth-0-alphabets-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=0 --trie=array < alphabets.txt
{a{a,f,gq,k,m,r,s{,a,t},z{,_Cyrl}},b{as,e{,m,z},g,m,n,o,r{,x},s{,_Cyrl},yn},c{a,gg,hr,s,y},d{a{,v},e,je,ua,yo,z},e{bu,e,l,n,o,s,t,u,wo},f{a,f,i{,l},o,r,ur,y},g{a,d,l,sw,u{,z},v},h{a{,w},e,i,r,u,y},i{a,d,g,i,s,t},j{a,go,mc},k{a{,b,m},de,ea,hq,i,k{,j},l{,n},m,n,o{,k},s{b,f,h},w,y},l{ag,g,kt,n,o,t,u{,o,y},v},m{as,er,fe,g{,h,o},k,l,n,r,s,t,ua,y},n{aq,b,d,e,l,mg,n{,h},r,so,us,yn},o{m,r,s},p{a{,_Arab},l,s,t},r{m,n,o{,f},u,w{,k}},s{a{h,q},bp,e{,h,s},g,hi{,_Latn},i,k,l,n,o,q,r{,_Latn},s{,y},t,v,w{,c}},t{a,e{,o},g,h,i{,_ER,g},n,o,r,s,wq,zm},u{g,k,r,z{,_{Arab,Cyrl}}},v{ai_Latn,e,i,o,un},wa{e,l},x{h,og},y{av,o{,_BJ}},z{gh,h{,_Hant},u}}
$

--[ gen-compact-expr-bash-depth-0-alphabets-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=0 --trie=ternary < alphabets.txt
{a{a,f,gq,k,m,r,s{,a,t},z{,_Cyrl}},b{as,e{,m,z},g,m,n,o,r{,x},s{,_Cyrl},yn},c{a,gg,hr,s,y},d{a{,v},e,je,ua,yo,z},e{bu,e,l,n,o,s,t,u,wo},f{a,f,i{,l},o,r,ur,y},g{a,d,l,sw,u{,z},v},h{a{,w},e,i,r,u,y},i{a,d,g,i,s,t},j{a,go,mc},k{a{,b,m},de,ea,hq,i,k{,j},l{,n},m,n,o{,k},s{b,f,h},w,y},l{ag,g,kt,n,o,t,u{,o,y},v},m{as,er,fe,g{,h,o},k,l,n,r,s,t,ua,y},n{aq,b,d,e,l,mg,n{,h},r,so,us,yn},o{m,r,s},p{a{,_Arab},l,s,t},r{m,n,o{,f},u,w{,k}},s{a{h,q},bp,e{,h,s},g,hi{,_Latn},i,k,l,n,o,q,r{,_Latn},s{,y},t,v,w{,c}},t{a,e{,o},g,h,i{,_ER,g},n,o,r,s,wq,zm},u{g,k,r,z{,_{Arab,Cyrl}}},v{ai_Latn,e,i,o,un},wa{e,l},x{h,og},y{av,o{,_BJ}},z{gh,h{,_Hant},u}}
$

--[ gen-compact-expr-bash-depth-0-filenames-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=0 --trie=array --escape=/ < filenames.txt
{c++py-tree-demo\/{.src-{dirs,files},bin.patch,c++py{-tree{-{author.txt,demo.txt,readme.{pdf,t{ex,xt}}},.{pdf,t{ex,xt}}},\/{.src-{dirs,files},AUTHOR,Makefile,README}}}}
$

--[ gen-compact-expr-bash-depth-0-filenames-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=0 --trie=ternary --escape=/ < filenames.txt
{c++py-tree-demo\/{.src-{dirs,files},bin.patch,c++py{-tree{-{author.txt,demo.txt,readme.{pdf,t{ex,xt}}},.{pdf,t{ex,xt}}},\/{.src-{dirs,files},AUTHOR,Makefile,README}}}}
$

--[ gen-wide-expr-bash-depth-1-base0-array ]------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=1 --trie=array "$@"; }
$ print a|trie
{
    a
}
$ print a ab|trie
{
    a
}
$ print a ab abc|trie
{
    a
}
$ print a b|trie
{
    a ,
    b
}
$ print a b abc bac abd|trie
{
    a ,
    b
}
$ print a bb ba c|trie
{
    a ,
    b ,
    c
}
$ print a bb ba cc|trie
{
    a ,
    b ,
    cc
}
$ print a bb ba ccc|trie
{
    a ,
    b ,
    ccc
}
$ print a bb ba cde|trie
{
    a ,
    b ,
    cde
}
$ print a bb ba cdef|trie
{
    a ,
    b ,
    cdef
}
$ print a bb ba cdef cdefg|trie
{
    a ,
    b ,
    cdef
}
$ print a bb bac cdef|trie
{
    a ,
    b ,
    cdef
}
$ print a bbx ba ccc|trie
{
    a ,
    b ,
    ccc
}
$ print a bbx bay ccc|trie
{
    a ,
    b ,
    ccc
}
$ print a cde cdef|trie
{
    a ,
    cde
}
$ print a cde cdef cdefg|trie
{
    a ,
    cde
}
$ print a cde cdef cdefgh|trie
{
    a ,
    cde
}
$ print a cdef cdefg|trie
{
    a ,
    cdef
}
$ print ab|trie
{
    ab
}
$ print ab bb ba ccc|trie
{
    ab ,
    b ,
    ccc
}
$ print ab bb ba cde|trie
{
    ab ,
    b ,
    cde
}
$ print ab bbx ba ccc|trie
{
    ab ,
    b ,
    ccc
}
$ print ab c|trie
{
    ab ,
    c
}
$ print abc bb ba ccc|trie
{
    abc ,
    b ,
    ccc
}
$ print abcd abde abef|trie
{
    ab
}
$ print abg a abc ab abd|trie
{
    a
}
$ print ac ab|trie
{
    a
}
$ print aef ae abg a abc ab abd|trie
{
    a
}
$ print cde cdef cdefgh|trie
{
    cde
}
$ print cdef cdefg|trie
{
    cdef
}
$ print cdex cdfy cdgz cdhw|trie
{
    cd
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    c
}
$ print pot potato pottery tattoo tempo|trie
{
    pot ,
    t
}
$

--[ gen-wide-expr-bash-depth-1-base0-ternary ]----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=1 --trie=ternary "$@"; }
$ print a|trie
{
    a
}
$ print a ab|trie
{
    a
}
$ print a ab abc|trie
{
    a
}
$ print a b|trie
{
    a,
    b
}
$ print a b abc bac abd|trie
{
    a,
    b
}
$ print a bb ba c|trie
{
    a,
    b,
    c
}
$ print a bb ba cc|trie
{
    a,
    b,
    cc
}
$ print a bb ba ccc|trie
{
    a,
    b,
    ccc
}
$ print a bb ba cde|trie
{
    a,
    b,
    cde
}
$ print a bb ba cdef|trie
{
    a,
    b,
    cdef
}
$ print a bb ba cdef cdefg|trie
{
    a,
    b,
    cdef
}
$ print a bb bac cdef|trie
{
    a,
    b,
    cdef
}
$ print a bbx ba ccc|trie
{
    a,
    b,
    ccc
}
$ print a bbx bay ccc|trie
{
    a,
    b,
    ccc
}
$ print a cde cdef|trie
{
    a,
    cde
}
$ print a cde cdef cdefg|trie
{
    a,
    cde
}
$ print a cde cdef cdefgh|trie
{
    a,
    cde
}
$ print a cdef cdefg|trie
{
    a,
    cdef
}
$ print ab|trie
{
    ab
}
$ print ab bb ba ccc|trie
{
    ab,
    b,
    ccc
}
$ print ab bb ba cde|trie
{
    ab,
    b,
    cde
}
$ print ab bbx ba ccc|trie
{
    ab,
    b,
    ccc
}
$ print ab c|trie
{
    ab,
    c
}
$ print abc bb ba ccc|trie
{
    abc,
    b,
    ccc
}
$ print abcd abde abef|trie
{
    ab
}
$ print abg a abc ab abd|trie
{
    a
}
$ print ac ab|trie
{
    a
}
$ print aef ae abg a abc ab abd|trie
{
    a
}
$ print cde cdef cdefgh|trie
{
    cde
}
$ print cdef cdefg|trie
{
    cdef
}
$ print cdex cdfy cdgz cdhw|trie
{
    cd
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    c
}
$ print pot potato pottery tattoo tempo|trie
{
    pot,
    t
}
$

--[ gen-wide-expr-bash-depth-1-base ]-------------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=1 --no-dots "$@"; }
$ print a ab abc abd ac|trie
{
    a
}
$ print a ab abc abd ac|trie -t int
{
    a
}
$ print a ab abc abd ac|trie -t float
{
    a
}
$

--[ gen-wide-expr-bash-depth-1-base-array ]-------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=1 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{
.   a
}
$ print a b|trie
{
.   a ,
.   b
}
$ print a b c|trie
{
.   a ,
.   b ,
.   c
}
$ print a ab abc|trie
{
.   a
}
$ print a ab ac|trie
{
.   a
}
$ print a ab ac ad|trie
{
.   a
}
$ print a abd ac|trie
{
.   a
}
$ print a ab ac acd|trie
{
.   a
}
$ print a bb ba ccc|trie
{
.   a ,
.   b ,
.   ccc
}
$ print a bb ccc|trie
{
.   a ,
.   bb ,
.   ccc
}
$ print a bb ba ccc|trie
{
.   a ,
.   b ,
.   ccc
}
$ print abc abd acde|trie
{
.   a
}
$ print abc abd acde ac|trie
{
.   a
}
$ print abc abd acde acfg|trie
{
.   a
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c
}
$ print a abcd abcdefg h hijk|trie
{
.   a ,
.   h
}
$ print a abcd abcdefg abcdxyz h hijk|trie
{
.   a ,
.   h
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{
.   a ,
.   h
}
$

--[ gen-wide-expr-bash-depth-1-base-ternary ]-----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=1 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{
.   a
}
$ print a b|trie
{
.   a,
.   b
}
$ print a b c|trie
{
.   a,
.   b,
.   c
}
$ print a ab abc|trie
{
.   a
}
$ print a ab ac|trie
{
.   a
}
$ print a ab ac ad|trie
{
.   a
}
$ print a abd ac|trie
{
.   a
}
$ print a ab ac acd|trie
{
.   a
}
$ print a bb ba ccc|trie
{
.   a,
.   b,
.   ccc
}
$ print a bb ccc|trie
{
.   a,
.   bb,
.   ccc
}
$ print a bb ba ccc|trie
{
.   a,
.   b,
.   ccc
}
$ print abc abd acde|trie
{
.   a
}
$ print abc abd acde ac|trie
{
.   a
}
$ print abc abd acde acfg|trie
{
.   a
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c
}
$ print a abcd abcdefg h hijk|trie
{
.   a,
.   h
}
$ print a abcd abcdefg abcdxyz h hijk|trie
{
.   a,
.   h
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{
.   a,
.   h
}
$

--[ gen-wide-expr-bash-depth-1-alphabets-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=1 --trie=array < alphabets.txt
{
.   a ,
.   b ,
.   c ,
.   d ,
.   e ,
.   f ,
.   g ,
.   h ,
.   i ,
.   j ,
.   k ,
.   l ,
.   m ,
.   n ,
.   o ,
.   p ,
.   r ,
.   s ,
.   t ,
.   u ,
.   v ,
.   wa ,
.   x ,
.   y ,
.   z
}
$

--[ gen-wide-expr-bash-depth-1-alphabets-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=1 --trie=ternary < alphabets.txt
{
.   a,
.   b,
.   c,
.   d,
.   e,
.   f,
.   g,
.   h,
.   i,
.   j,
.   k,
.   l,
.   m,
.   n,
.   o,
.   p,
.   r,
.   s,
.   t,
.   u,
.   v,
.   wa,
.   x,
.   y,
.   z
}
$

--[ gen-wide-expr-bash-depth-1-filenames-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=1 --trie=array --escape=/ < filenames.txt
{
.   c++py-tree-demo\/
}
$

--[ gen-wide-expr-bash-depth-1-filenames-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=1 --trie=ternary --escape=/ < filenames.txt
{
.   c++py-tree-demo\/
}
$

--[ gen-compact-expr-bash-depth-1-base0-array ]---------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=1 --trie=array "$@"; }
$ print a|trie
{a}
$ print a ab|trie
{a}
$ print a ab abc|trie
{a}
$ print a b|trie
{a,b}
$ print a b abc bac abd|trie
{a,b}
$ print a bb ba c|trie
{a,b,c}
$ print a bb ba cc|trie
{a,b,cc}
$ print a bb ba ccc|trie
{a,b,ccc}
$ print a bb ba cde|trie
{a,b,cde}
$ print a bb ba cdef|trie
{a,b,cdef}
$ print a bb ba cdef cdefg|trie
{a,b,cdef}
$ print a bb bac cdef|trie
{a,b,cdef}
$ print a bbx ba ccc|trie
{a,b,ccc}
$ print a bbx bay ccc|trie
{a,b,ccc}
$ print a cde cdef|trie
{a,cde}
$ print a cde cdef cdefg|trie
{a,cde}
$ print a cde cdef cdefgh|trie
{a,cde}
$ print a cdef cdefg|trie
{a,cdef}
$ print ab|trie
{ab}
$ print ab bb ba ccc|trie
{ab,b,ccc}
$ print ab bb ba cde|trie
{ab,b,cde}
$ print ab bbx ba ccc|trie
{ab,b,ccc}
$ print ab c|trie
{ab,c}
$ print abc bb ba ccc|trie
{abc,b,ccc}
$ print abcd abde abef|trie
{ab}
$ print abg a abc ab abd|trie
{a}
$ print ac ab|trie
{a}
$ print aef ae abg a abc ab abd|trie
{a}
$ print cde cdef cdefgh|trie
{cde}
$ print cdef cdefg|trie
{cdef}
$ print cdex cdfy cdgz cdhw|trie
{cd}
$ print ce cdex cdfy cdgz cdhw|trie
{c}
$ print pot potato pottery tattoo tempo|trie
{pot,t}
$

--[ gen-compact-expr-bash-depth-1-base0-ternary ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=1 --trie=ternary "$@"; }
$ print a|trie
{a}
$ print a ab|trie
{a}
$ print a ab abc|trie
{a}
$ print a b|trie
{a,b}
$ print a b abc bac abd|trie
{a,b}
$ print a bb ba c|trie
{a,b,c}
$ print a bb ba cc|trie
{a,b,cc}
$ print a bb ba ccc|trie
{a,b,ccc}
$ print a bb ba cde|trie
{a,b,cde}
$ print a bb ba cdef|trie
{a,b,cdef}
$ print a bb ba cdef cdefg|trie
{a,b,cdef}
$ print a bb bac cdef|trie
{a,b,cdef}
$ print a bbx ba ccc|trie
{a,b,ccc}
$ print a bbx bay ccc|trie
{a,b,ccc}
$ print a cde cdef|trie
{a,cde}
$ print a cde cdef cdefg|trie
{a,cde}
$ print a cde cdef cdefgh|trie
{a,cde}
$ print a cdef cdefg|trie
{a,cdef}
$ print ab|trie
{ab}
$ print ab bb ba ccc|trie
{ab,b,ccc}
$ print ab bb ba cde|trie
{ab,b,cde}
$ print ab bbx ba ccc|trie
{ab,b,ccc}
$ print ab c|trie
{ab,c}
$ print abc bb ba ccc|trie
{abc,b,ccc}
$ print abcd abde abef|trie
{ab}
$ print abg a abc ab abd|trie
{a}
$ print ac ab|trie
{a}
$ print aef ae abg a abc ab abd|trie
{a}
$ print cde cdef cdefgh|trie
{cde}
$ print cdef cdefg|trie
{cdef}
$ print cdex cdfy cdgz cdhw|trie
{cd}
$ print ce cdex cdfy cdgz cdhw|trie
{c}
$ print pot potato pottery tattoo tempo|trie
{pot,t}
$

--[ gen-compact-expr-bash-depth-1-base ]----------------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=1 --no-dots "$@"; }
$ print a ab abc abd ac|trie
{a}
$ print a ab abc abd ac|trie -t int
{a}
$ print a ab abc abd ac|trie -t float
{a}
$

--[ gen-compact-expr-bash-depth-1-base-array ]----------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=1 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{a}
$ print a b|trie
{a,b}
$ print a b c|trie
{a,b,c}
$ print a ab abc|trie
{a}
$ print a ab ac|trie
{a}
$ print a ab ac ad|trie
{a}
$ print a abd ac|trie
{a}
$ print a ab ac acd|trie
{a}
$ print a bb ba ccc|trie
{a,b,ccc}
$ print a bb ccc|trie
{a,bb,ccc}
$ print a bb ba ccc|trie
{a,b,ccc}
$ print abc abd acde|trie
{a}
$ print abc abd acde ac|trie
{a}
$ print abc abd acde acfg|trie
{a}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c}
$ print a abcd abcdefg h hijk|trie
{a,h}
$ print a abcd abcdefg abcdxyz h hijk|trie
{a,h}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{a,h}
$

--[ gen-compact-expr-bash-depth-1-base-ternary ]--------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=1 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{a}
$ print a b|trie
{a,b}
$ print a b c|trie
{a,b,c}
$ print a ab abc|trie
{a}
$ print a ab ac|trie
{a}
$ print a ab ac ad|trie
{a}
$ print a abd ac|trie
{a}
$ print a ab ac acd|trie
{a}
$ print a bb ba ccc|trie
{a,b,ccc}
$ print a bb ccc|trie
{a,bb,ccc}
$ print a bb ba ccc|trie
{a,b,ccc}
$ print abc abd acde|trie
{a}
$ print abc abd acde ac|trie
{a}
$ print abc abd acde acfg|trie
{a}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c}
$ print a abcd abcdefg h hijk|trie
{a,h}
$ print a abcd abcdefg abcdxyz h hijk|trie
{a,h}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{a,h}
$

--[ gen-compact-expr-bash-depth-1-alphabets-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=1 --trie=array < alphabets.txt
{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,r,s,t,u,v,wa,x,y,z}
$

--[ gen-compact-expr-bash-depth-1-alphabets-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=1 --trie=ternary < alphabets.txt
{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,r,s,t,u,v,wa,x,y,z}
$

--[ gen-compact-expr-bash-depth-1-filenames-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=1 --trie=array --escape=/ < filenames.txt
{c++py-tree-demo\/}
$

--[ gen-compact-expr-bash-depth-1-filenames-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=1 --trie=ternary --escape=/ < filenames.txt
{c++py-tree-demo\/}
$

--[ gen-wide-expr-bash-depth-2-base0-array ]------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=2 --trie=array "$@"; }
$ print a|trie
{
    a
}
$ print a ab|trie
{
    a {,
        b
    }
}
$ print a ab abc|trie
{
    a {,
        b
    }
}
$ print a b|trie
{
    a ,
    b
}
$ print a b abc bac abd|trie
{
    a {,
        b
    } ,
    b {,
        ac
    }
}
$ print a bb ba c|trie
{
    a ,
    b {
        a ,
        b
    } ,
    c
}
$ print a bb ba cc|trie
{
    a ,
    b {
        a ,
        b
    } ,
    cc
}
$ print a bb ba ccc|trie
{
    a ,
    b {
        a ,
        b
    } ,
    ccc
}
$ print a bb ba cde|trie
{
    a ,
    b {
        a ,
        b
    } ,
    cde
}
$ print a bb ba cdef|trie
{
    a ,
    b {
        a ,
        b
    } ,
    cdef
}
$ print a bb ba cdef cdefg|trie
{
    a ,
    b {
        a ,
        b
    } ,
    cdef {,
        g
    }
}
$ print a bb bac cdef|trie
{
    a ,
    b {
        ac ,
        b
    } ,
    cdef
}
$ print a bbx ba ccc|trie
{
    a ,
    b {
        a ,
        bx
    } ,
    ccc
}
$ print a bbx bay ccc|trie
{
    a ,
    b {
        ay ,
        bx
    } ,
    ccc
}
$ print a cde cdef|trie
{
    a ,
    cde {,
        f
    }
}
$ print a cde cdef cdefg|trie
{
    a ,
    cde {,
        f
    }
}
$ print a cde cdef cdefgh|trie
{
    a ,
    cde {,
        f
    }
}
$ print a cdef cdefg|trie
{
    a ,
    cdef {,
        g
    }
}
$ print ab|trie
{
    ab
}
$ print ab bb ba ccc|trie
{
    ab ,
    b {
        a ,
        b
    } ,
    ccc
}
$ print ab bb ba cde|trie
{
    ab ,
    b {
        a ,
        b
    } ,
    cde
}
$ print ab bbx ba ccc|trie
{
    ab ,
    b {
        a ,
        bx
    } ,
    ccc
}
$ print ab c|trie
{
    ab ,
    c
}
$ print abc bb ba ccc|trie
{
    abc ,
    b {
        a ,
        b
    } ,
    ccc
}
$ print abcd abde abef|trie
{
    ab {
        cd ,
        de ,
        ef
    }
}
$ print abg a abc ab abd|trie
{
    a {,
        b
    }
}
$ print ac ab|trie
{
    a {
        b ,
        c
    }
}
$ print aef ae abg a abc ab abd|trie
{
    a {,
        b ,
        e
    }
}
$ print cde cdef cdefgh|trie
{
    cde {,
        f
    }
}
$ print cdef cdefg|trie
{
    cdef {,
        g
    }
}
$ print cdex cdfy cdgz cdhw|trie
{
    cd {
        ex ,
        fy ,
        gz ,
        hw
    }
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    c {
        d ,
        e
    }
}
$ print pot potato pottery tattoo tempo|trie
{
    pot {,
        ato ,
        tery
    } ,
    t {
        attoo ,
        empo
    }
}
$

--[ gen-wide-expr-bash-depth-2-base0-ternary ]----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=2 --trie=ternary "$@"; }
$ print a|trie
{
    a
}
$ print a ab|trie
{
    a {,
        b
    }
}
$ print a ab abc|trie
{
    a {,
        b
    }
}
$ print a b|trie
{
    a,
    b
}
$ print a b abc bac abd|trie
{
    a {,
        b
    },
    b {,
        ac
    }
}
$ print a bb ba c|trie
{
    a,
    b {
        a,
        b
    },
    c
}
$ print a bb ba cc|trie
{
    a,
    b {
        a,
        b
    },
    cc
}
$ print a bb ba ccc|trie
{
    a,
    b {
        a,
        b
    },
    ccc
}
$ print a bb ba cde|trie
{
    a,
    b {
        a,
        b
    },
    cde
}
$ print a bb ba cdef|trie
{
    a,
    b {
        a,
        b
    },
    cdef
}
$ print a bb ba cdef cdefg|trie
{
    a,
    b {
        a,
        b
    },
    cdef {,
        g
    }
}
$ print a bb bac cdef|trie
{
    a,
    b {
        ac,
        b
    },
    cdef
}
$ print a bbx ba ccc|trie
{
    a,
    b {
        a,
        bx
    },
    ccc
}
$ print a bbx bay ccc|trie
{
    a,
    b {
        ay,
        bx
    },
    ccc
}
$ print a cde cdef|trie
{
    a,
    cde {,
        f
    }
}
$ print a cde cdef cdefg|trie
{
    a,
    cde {,
        f
    }
}
$ print a cde cdef cdefgh|trie
{
    a,
    cde {,
        f
    }
}
$ print a cdef cdefg|trie
{
    a,
    cdef {,
        g
    }
}
$ print ab|trie
{
    ab
}
$ print ab bb ba ccc|trie
{
    ab,
    b {
        a,
        b
    },
    ccc
}
$ print ab bb ba cde|trie
{
    ab,
    b {
        a,
        b
    },
    cde
}
$ print ab bbx ba ccc|trie
{
    ab,
    b {
        a,
        bx
    },
    ccc
}
$ print ab c|trie
{
    ab,
    c
}
$ print abc bb ba ccc|trie
{
    abc,
    b {
        a,
        b
    },
    ccc
}
$ print abcd abde abef|trie
{
    ab {
        cd,
        de,
        ef
    }
}
$ print abg a abc ab abd|trie
{
    a {,
        b
    }
}
$ print ac ab|trie
{
    a {
        b,
        c
    }
}
$ print aef ae abg a abc ab abd|trie
{
    a {,
        b,
        e
    }
}
$ print cde cdef cdefgh|trie
{
    cde {,
        f
    }
}
$ print cdef cdefg|trie
{
    cdef {,
        g
    }
}
$ print cdex cdfy cdgz cdhw|trie
{
    cd {
        ex,
        fy,
        gz,
        hw
    }
}
$ print ce cdex cdfy cdgz cdhw|trie
{
    c {
        d,
        e
    }
}
$ print pot potato pottery tattoo tempo|trie
{
    pot {,
        ato,
        tery
    },
    t {
        attoo,
        empo
    }
}
$

--[ gen-wide-expr-bash-depth-2-base ]-------------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=2 --no-dots "$@"; }
$ print a ab abc abd ac|trie
{
    a {,
        b,
        c
    }
}
$ print a ab abc abd ac|trie -t int
{
    a {,
        b,
        c
    }
}
$ print a ab abc abd ac|trie -t float
{
    a {,
        b,
        c
    }
}
$

--[ gen-wide-expr-bash-depth-2-base-array ]-------------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=2 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{
.   a
}
$ print a b|trie
{
.   a ,
.   b
}
$ print a b c|trie
{
.   a ,
.   b ,
.   c
}
$ print a ab abc|trie
{
.   a {,
.   .   b
.   }
}
$ print a ab ac|trie
{
.   a {,
.   .   b ,
.   .   c
.   }
}
$ print a ab ac ad|trie
{
.   a {,
.   .   b ,
.   .   c ,
.   .   d
.   }
}
$ print a abd ac|trie
{
.   a {,
.   .   bd ,
.   .   c
.   }
}
$ print a ab ac acd|trie
{
.   a {,
.   .   b ,
.   .   c
.   }
}
$ print a bb ba ccc|trie
{
.   a ,
.   b {
.   .   a ,
.   .   b
.   } ,
.   ccc
}
$ print a bb ccc|trie
{
.   a ,
.   bb ,
.   ccc
}
$ print a bb ba ccc|trie
{
.   a ,
.   b {
.   .   a ,
.   .   b
.   } ,
.   ccc
}
$ print abc abd acde|trie
{
.   a {
.   .   b ,
.   .   cde
.   }
}
$ print abc abd acde ac|trie
{
.   a {
.   .   b ,
.   .   c
.   }
}
$ print abc abd acde acfg|trie
{
.   a {
.   .   b ,
.   .   c
.   }
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c {
.   .   de ,
.   .   fg
.   }
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c {
.   .   fg ,
.   .   ge
.   }
}
$ print a abcd abcdefg h hijk|trie
{
.   a {,
.   .   bcd
.   } ,
.   h {,
.   .   ijk
.   }
}
$ print a abcd abcdefg abcdxyz h hijk|trie
{
.   a {,
.   .   bcd
.   } ,
.   h {,
.   .   ijk
.   }
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{
.   a {,
.   .   bcd
.   } ,
.   h {,
.   .   ijk ,
.   .   lm
.   }
}
$

--[ gen-wide-expr-bash-depth-2-base-ternary ]-----------------------------------

$ trie() { ../src/trie --gen=wide --output=expr --expr=bash --depth=2 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{
.   a
}
$ print a b|trie
{
.   a,
.   b
}
$ print a b c|trie
{
.   a,
.   b,
.   c
}
$ print a ab abc|trie
{
.   a {,
.   .   b
.   }
}
$ print a ab ac|trie
{
.   a {,
.   .   b,
.   .   c
.   }
}
$ print a ab ac ad|trie
{
.   a {,
.   .   b,
.   .   c,
.   .   d
.   }
}
$ print a abd ac|trie
{
.   a {,
.   .   bd,
.   .   c
.   }
}
$ print a ab ac acd|trie
{
.   a {,
.   .   b,
.   .   c
.   }
}
$ print a bb ba ccc|trie
{
.   a,
.   b {
.   .   a,
.   .   b
.   },
.   ccc
}
$ print a bb ccc|trie
{
.   a,
.   bb,
.   ccc
}
$ print a bb ba ccc|trie
{
.   a,
.   b {
.   .   a,
.   .   b
.   },
.   ccc
}
$ print abc abd acde|trie
{
.   a {
.   .   b,
.   .   cde
.   }
}
$ print abc abd acde ac|trie
{
.   a {
.   .   b,
.   .   c
.   }
}
$ print abc abd acde acfg|trie
{
.   a {
.   .   b,
.   .   c
.   }
}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c {
.   .   de,
.   .   fg
.   }
}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{
.   c {
.   .   fg,
.   .   ge
.   }
}
$ print a abcd abcdefg h hijk|trie
{
.   a {,
.   .   bcd
.   },
.   h {,
.   .   ijk
.   }
}
$ print a abcd abcdefg abcdxyz h hijk|trie
{
.   a {,
.   .   bcd
.   },
.   h {,
.   .   ijk
.   }
}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{
.   a {,
.   .   bcd
.   },
.   h {,
.   .   ijk,
.   .   lm
.   }
}
$

--[ gen-wide-expr-bash-depth-2-alphabets-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=2 --trie=array < alphabets.txt
{
.   a {
.   .   a ,
.   .   f ,
.   .   gq ,
.   .   k ,
.   .   m ,
.   .   r ,
.   .   s ,
.   .   z
.   } ,
.   b {
.   .   as ,
.   .   e ,
.   .   g ,
.   .   m ,
.   .   n ,
.   .   o ,
.   .   r ,
.   .   s ,
.   .   yn
.   } ,
.   c {
.   .   a ,
.   .   gg ,
.   .   hr ,
.   .   s ,
.   .   y
.   } ,
.   d {
.   .   a ,
.   .   e ,
.   .   je ,
.   .   ua ,
.   .   yo ,
.   .   z
.   } ,
.   e {
.   .   bu ,
.   .   e ,
.   .   l ,
.   .   n ,
.   .   o ,
.   .   s ,
.   .   t ,
.   .   u ,
.   .   wo
.   } ,
.   f {
.   .   a ,
.   .   f ,
.   .   i ,
.   .   o ,
.   .   r ,
.   .   ur ,
.   .   y
.   } ,
.   g {
.   .   a ,
.   .   d ,
.   .   l ,
.   .   sw ,
.   .   u ,
.   .   v
.   } ,
.   h {
.   .   a ,
.   .   e ,
.   .   i ,
.   .   r ,
.   .   u ,
.   .   y
.   } ,
.   i {
.   .   a ,
.   .   d ,
.   .   g ,
.   .   i ,
.   .   s ,
.   .   t
.   } ,
.   j {
.   .   a ,
.   .   go ,
.   .   mc
.   } ,
.   k {
.   .   a ,
.   .   de ,
.   .   ea ,
.   .   hq ,
.   .   i ,
.   .   k ,
.   .   l ,
.   .   m ,
.   .   n ,
.   .   o ,
.   .   s ,
.   .   w ,
.   .   y
.   } ,
.   l {
.   .   ag ,
.   .   g ,
.   .   kt ,
.   .   n ,
.   .   o ,
.   .   t ,
.   .   u ,
.   .   v
.   } ,
.   m {
.   .   as ,
.   .   er ,
.   .   fe ,
.   .   g ,
.   .   k ,
.   .   l ,
.   .   n ,
.   .   r ,
.   .   s ,
.   .   t ,
.   .   ua ,
.   .   y
.   } ,
.   n {
.   .   aq ,
.   .   b ,
.   .   d ,
.   .   e ,
.   .   l ,
.   .   mg ,
.   .   n ,
.   .   r ,
.   .   so ,
.   .   us ,
.   .   yn
.   } ,
.   o {
.   .   m ,
.   .   r ,
.   .   s
.   } ,
.   p {
.   .   a ,
.   .   l ,
.   .   s ,
.   .   t
.   } ,
.   r {
.   .   m ,
.   .   n ,
.   .   o ,
.   .   u ,
.   .   w
.   } ,
.   s {
.   .   a ,
.   .   bp ,
.   .   e ,
.   .   g ,
.   .   hi ,
.   .   i ,
.   .   k ,
.   .   l ,
.   .   n ,
.   .   o ,
.   .   q ,
.   .   r ,
.   .   s ,
.   .   t ,
.   .   v ,
.   .   w
.   } ,
.   t {
.   .   a ,
.   .   e ,
.   .   g ,
.   .   h ,
.   .   i ,
.   .   n ,
.   .   o ,
.   .   r ,
.   .   s ,
.   .   wq ,
.   .   zm
.   } ,
.   u {
.   .   g ,
.   .   k ,
.   .   r ,
.   .   z
.   } ,
.   v {
.   .   ai_Latn ,
.   .   e ,
.   .   i ,
.   .   o ,
.   .   un
.   } ,
.   wa {
.   .   e ,
.   .   l
.   } ,
.   x {
.   .   h ,
.   .   og
.   } ,
.   y {
.   .   av ,
.   .   o
.   } ,
.   z {
.   .   gh ,
.   .   h ,
.   .   u
.   }
}
$

--[ gen-wide-expr-bash-depth-2-alphabets-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=2 --trie=ternary < alphabets.txt
{
.   a {
.   .   a,
.   .   f,
.   .   gq,
.   .   k,
.   .   m,
.   .   r,
.   .   s,
.   .   z
.   },
.   b {
.   .   as,
.   .   e,
.   .   g,
.   .   m,
.   .   n,
.   .   o,
.   .   r,
.   .   s,
.   .   yn
.   },
.   c {
.   .   a,
.   .   gg,
.   .   hr,
.   .   s,
.   .   y
.   },
.   d {
.   .   a,
.   .   e,
.   .   je,
.   .   ua,
.   .   yo,
.   .   z
.   },
.   e {
.   .   bu,
.   .   e,
.   .   l,
.   .   n,
.   .   o,
.   .   s,
.   .   t,
.   .   u,
.   .   wo
.   },
.   f {
.   .   a,
.   .   f,
.   .   i,
.   .   o,
.   .   r,
.   .   ur,
.   .   y
.   },
.   g {
.   .   a,
.   .   d,
.   .   l,
.   .   sw,
.   .   u,
.   .   v
.   },
.   h {
.   .   a,
.   .   e,
.   .   i,
.   .   r,
.   .   u,
.   .   y
.   },
.   i {
.   .   a,
.   .   d,
.   .   g,
.   .   i,
.   .   s,
.   .   t
.   },
.   j {
.   .   a,
.   .   go,
.   .   mc
.   },
.   k {
.   .   a,
.   .   de,
.   .   ea,
.   .   hq,
.   .   i,
.   .   k,
.   .   l,
.   .   m,
.   .   n,
.   .   o,
.   .   s,
.   .   w,
.   .   y
.   },
.   l {
.   .   ag,
.   .   g,
.   .   kt,
.   .   n,
.   .   o,
.   .   t,
.   .   u,
.   .   v
.   },
.   m {
.   .   as,
.   .   er,
.   .   fe,
.   .   g,
.   .   k,
.   .   l,
.   .   n,
.   .   r,
.   .   s,
.   .   t,
.   .   ua,
.   .   y
.   },
.   n {
.   .   aq,
.   .   b,
.   .   d,
.   .   e,
.   .   l,
.   .   mg,
.   .   n,
.   .   r,
.   .   so,
.   .   us,
.   .   yn
.   },
.   o {
.   .   m,
.   .   r,
.   .   s
.   },
.   p {
.   .   a,
.   .   l,
.   .   s,
.   .   t
.   },
.   r {
.   .   m,
.   .   n,
.   .   o,
.   .   u,
.   .   w
.   },
.   s {
.   .   a,
.   .   bp,
.   .   e,
.   .   g,
.   .   hi,
.   .   i,
.   .   k,
.   .   l,
.   .   n,
.   .   o,
.   .   q,
.   .   r,
.   .   s,
.   .   t,
.   .   v,
.   .   w
.   },
.   t {
.   .   a,
.   .   e,
.   .   g,
.   .   h,
.   .   i,
.   .   n,
.   .   o,
.   .   r,
.   .   s,
.   .   wq,
.   .   zm
.   },
.   u {
.   .   g,
.   .   k,
.   .   r,
.   .   z
.   },
.   v {
.   .   ai_Latn,
.   .   e,
.   .   i,
.   .   o,
.   .   un
.   },
.   wa {
.   .   e,
.   .   l
.   },
.   x {
.   .   h,
.   .   og
.   },
.   y {
.   .   av,
.   .   o
.   },
.   z {
.   .   gh,
.   .   h,
.   .   u
.   }
}
$

--[ gen-wide-expr-bash-depth-2-filenames-array ]--------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=2 --trie=array --escape=/ < filenames.txt
{
.   c++py-tree-demo\/ {
.   .   .src- ,
.   .   bin.patch ,
.   .   c++py
.   }
}
$

--[ gen-wide-expr-bash-depth-2-filenames-ternary ]------------------------------

$ ../src/trie --dots --gen=wide --output=expr --expr=bash --depth=2 --trie=ternary --escape=/ < filenames.txt
{
.   c++py-tree-demo\/ {
.   .   .src-,
.   .   bin.patch,
.   .   c++py
.   }
}
$

--[ gen-compact-expr-bash-depth-2-base0-array ]---------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=2 --trie=array "$@"; }
$ print a|trie
{a}
$ print a ab|trie
{a{,b}}
$ print a ab abc|trie
{a{,b}}
$ print a b|trie
{a,b}
$ print a b abc bac abd|trie
{a{,b},b{,ac}}
$ print a bb ba c|trie
{a,b{a,b},c}
$ print a bb ba cc|trie
{a,b{a,b},cc}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print a bb ba cde|trie
{a,b{a,b},cde}
$ print a bb ba cdef|trie
{a,b{a,b},cdef}
$ print a bb ba cdef cdefg|trie
{a,b{a,b},cdef{,g}}
$ print a bb bac cdef|trie
{a,b{ac,b},cdef}
$ print a bbx ba ccc|trie
{a,b{a,bx},ccc}
$ print a bbx bay ccc|trie
{a,b{ay,bx},ccc}
$ print a cde cdef|trie
{a,cde{,f}}
$ print a cde cdef cdefg|trie
{a,cde{,f}}
$ print a cde cdef cdefgh|trie
{a,cde{,f}}
$ print a cdef cdefg|trie
{a,cdef{,g}}
$ print ab|trie
{ab}
$ print ab bb ba ccc|trie
{ab,b{a,b},ccc}
$ print ab bb ba cde|trie
{ab,b{a,b},cde}
$ print ab bbx ba ccc|trie
{ab,b{a,bx},ccc}
$ print ab c|trie
{ab,c}
$ print abc bb ba ccc|trie
{abc,b{a,b},ccc}
$ print abcd abde abef|trie
{ab{cd,de,ef}}
$ print abg a abc ab abd|trie
{a{,b}}
$ print ac ab|trie
{a{b,c}}
$ print aef ae abg a abc ab abd|trie
{a{,b,e}}
$ print cde cdef cdefgh|trie
{cde{,f}}
$ print cdef cdefg|trie
{cdef{,g}}
$ print cdex cdfy cdgz cdhw|trie
{cd{ex,fy,gz,hw}}
$ print ce cdex cdfy cdgz cdhw|trie
{c{d,e}}
$ print pot potato pottery tattoo tempo|trie
{pot{,ato,tery},t{attoo,empo}}
$

--[ gen-compact-expr-bash-depth-2-base0-ternary ]-------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=2 --trie=ternary "$@"; }
$ print a|trie
{a}
$ print a ab|trie
{a{,b}}
$ print a ab abc|trie
{a{,b}}
$ print a b|trie
{a,b}
$ print a b abc bac abd|trie
{a{,b},b{,ac}}
$ print a bb ba c|trie
{a,b{a,b},c}
$ print a bb ba cc|trie
{a,b{a,b},cc}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print a bb ba cde|trie
{a,b{a,b},cde}
$ print a bb ba cdef|trie
{a,b{a,b},cdef}
$ print a bb ba cdef cdefg|trie
{a,b{a,b},cdef{,g}}
$ print a bb bac cdef|trie
{a,b{ac,b},cdef}
$ print a bbx ba ccc|trie
{a,b{a,bx},ccc}
$ print a bbx bay ccc|trie
{a,b{ay,bx},ccc}
$ print a cde cdef|trie
{a,cde{,f}}
$ print a cde cdef cdefg|trie
{a,cde{,f}}
$ print a cde cdef cdefgh|trie
{a,cde{,f}}
$ print a cdef cdefg|trie
{a,cdef{,g}}
$ print ab|trie
{ab}
$ print ab bb ba ccc|trie
{ab,b{a,b},ccc}
$ print ab bb ba cde|trie
{ab,b{a,b},cde}
$ print ab bbx ba ccc|trie
{ab,b{a,bx},ccc}
$ print ab c|trie
{ab,c}
$ print abc bb ba ccc|trie
{abc,b{a,b},ccc}
$ print abcd abde abef|trie
{ab{cd,de,ef}}
$ print abg a abc ab abd|trie
{a{,b}}
$ print ac ab|trie
{a{b,c}}
$ print aef ae abg a abc ab abd|trie
{a{,b,e}}
$ print cde cdef cdefgh|trie
{cde{,f}}
$ print cdef cdefg|trie
{cdef{,g}}
$ print cdex cdfy cdgz cdhw|trie
{cd{ex,fy,gz,hw}}
$ print ce cdex cdfy cdgz cdhw|trie
{c{d,e}}
$ print pot potato pottery tattoo tempo|trie
{pot{,ato,tery},t{attoo,empo}}
$

--[ gen-compact-expr-bash-depth-2-base ]----------------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=2 --no-dots "$@"; }
$ print a ab abc abd ac|trie
{a{,b,c}}
$ print a ab abc abd ac|trie -t int
{a{,b,c}}
$ print a ab abc abd ac|trie -t float
{a{,b,c}}
$

--[ gen-compact-expr-bash-depth-2-base-array ]----------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=2 --dots --trie=array "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{a}
$ print a b|trie
{a,b}
$ print a b c|trie
{a,b,c}
$ print a ab abc|trie
{a{,b}}
$ print a ab ac|trie
{a{,b,c}}
$ print a ab ac ad|trie
{a{,b,c,d}}
$ print a abd ac|trie
{a{,bd,c}}
$ print a ab ac acd|trie
{a{,b,c}}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print a bb ccc|trie
{a,bb,ccc}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print abc abd acde|trie
{a{b,cde}}
$ print abc abd acde ac|trie
{a{b,c}}
$ print abc abd acde acfg|trie
{a{b,c}}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c{de,fg}}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c{fg,ge}}
$ print a abcd abcdefg h hijk|trie
{a{,bcd},h{,ijk}}
$ print a abcd abcdefg abcdxyz h hijk|trie
{a{,bcd},h{,ijk}}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{a{,bcd},h{,ijk,lm}}
$

--[ gen-compact-expr-bash-depth-2-base-ternary ]--------------------------------

$ trie() { ../src/trie --gen=compact --output=expr --expr=bash --depth=2 --dots --trie=ternary "$@"; }
$ print|trie
trie: error: tries cannot contain empty keys
command failed: print|trie
$ print a|trie
{a}
$ print a b|trie
{a,b}
$ print a b c|trie
{a,b,c}
$ print a ab abc|trie
{a{,b}}
$ print a ab ac|trie
{a{,b,c}}
$ print a ab ac ad|trie
{a{,b,c,d}}
$ print a abd ac|trie
{a{,bd,c}}
$ print a ab ac acd|trie
{a{,b,c}}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print a bb ccc|trie
{a,bb,ccc}
$ print a bb ba ccc|trie
{a,b{a,b},ccc}
$ print abc abd acde|trie
{a{b,cde}}
$ print abc abd acde ac|trie
{a{b,c}}
$ print abc abd acde acfg|trie
{a{b,c}}
$ print cde cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c{de,fg}}
$ print cge cfg cfgx cfgxy cfgxyz cfgxzzz|trie
{c{fg,ge}}
$ print a abcd abcdefg h hijk|trie
{a{,bcd},h{,ijk}}
$ print a abcd abcdefg abcdxyz h hijk|trie
{a{,bcd},h{,ijk}}
$ print a abcd abcdefg abcdxyz h hijk hlm|trie
{a{,bcd},h{,ijk,lm}}
$

--[ gen-compact-expr-bash-depth-2-alphabets-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=2 --trie=array < alphabets.txt
{a{a,f,gq,k,m,r,s,z},b{as,e,g,m,n,o,r,s,yn},c{a,gg,hr,s,y},d{a,e,je,ua,yo,z},e{bu,e,l,n,o,s,t,u,wo},f{a,f,i,o,r,ur,y},g{a,d,l,sw,u,v},h{a,e,i,r,u,y},i{a,d,g,i,s,t},j{a,go,mc},k{a,de,ea,hq,i,k,l,m,n,o,s,w,y},l{ag,g,kt,n,o,t,u,v},m{as,er,fe,g,k,l,n,r,s,t,ua,y},n{aq,b,d,e,l,mg,n,r,so,us,yn},o{m,r,s},p{a,l,s,t},r{m,n,o,u,w},s{a,bp,e,g,hi,i,k,l,n,o,q,r,s,t,v,w},t{a,e,g,h,i,n,o,r,s,wq,zm},u{g,k,r,z},v{ai_Latn,e,i,o,un},wa{e,l},x{h,og},y{av,o},z{gh,h,u}}
$

--[ gen-compact-expr-bash-depth-2-alphabets-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=2 --trie=ternary < alphabets.txt
{a{a,f,gq,k,m,r,s,z},b{as,e,g,m,n,o,r,s,yn},c{a,gg,hr,s,y},d{a,e,je,ua,yo,z},e{bu,e,l,n,o,s,t,u,wo},f{a,f,i,o,r,ur,y},g{a,d,l,sw,u,v},h{a,e,i,r,u,y},i{a,d,g,i,s,t},j{a,go,mc},k{a,de,ea,hq,i,k,l,m,n,o,s,w,y},l{ag,g,kt,n,o,t,u,v},m{as,er,fe,g,k,l,n,r,s,t,ua,y},n{aq,b,d,e,l,mg,n,r,so,us,yn},o{m,r,s},p{a,l,s,t},r{m,n,o,u,w},s{a,bp,e,g,hi,i,k,l,n,o,q,r,s,t,v,w},t{a,e,g,h,i,n,o,r,s,wq,zm},u{g,k,r,z},v{ai_Latn,e,i,o,un},wa{e,l},x{h,og},y{av,o},z{gh,h,u}}
$

--[ gen-compact-expr-bash-depth-2-filenames-array ]-----------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=2 --trie=array --escape=/ < filenames.txt
{c++py-tree-demo\/{.src-,bin.patch,c++py}}
$

--[ gen-compact-expr-bash-depth-2-filenames-ternary ]---------------------------

$ ../src/trie --dots --gen=compact --output=expr --expr=bash --depth=2 --trie=ternary --escape=/ < filenames.txt
{c++py-tree-demo\/{.src-,bin.patch,c++py}}
$

--[ gen-func ]------------------------------------------------------------------

$ . ../commands.sh
$ print 'i int =integer' 'f float =floating_point' 's str string'|gen-func -h .. -f options_t::lookup_node -r node_type_t -v
bool options_t::lookup_node(const char* n, node_type_t& t)
{
    // pattern: f[loat]|i[nt]|s[tr[ing]]
    switch (*n ++) {
    case 'f':
        if (*n == 0) {
            // input: "f"
            t = node_type_t::floating_point;
            return true;
        }
        if (*n ++ == 'l' &&
            *n ++ == 'o' &&
            *n ++ == 'a' &&
            *n ++ == 't' &&
            *n == 0) {
            // input: "float"
            t = node_type_t::floating_point;
            return true;
        }
        return false;
    case 'i':
        if (*n == 0) {
            // input: "i"
            t = node_type_t::integer;
            return true;
        }
        if (*n ++ == 'n' &&
            *n ++ == 't' &&
            *n == 0) {
            // input: "int"
            t = node_type_t::integer;
            return true;
        }
        return false;
    case 's':
        if (*n == 0) {
            // input: "s"
            t = node_type_t::string;
            return true;
        }
        if (*n ++ == 't' &&
            *n ++ == 'r') {
            if (*n == 0) {
                // input: "str"
                t = node_type_t::string;
                return true;
            }
            if (*n ++ == 'i' &&
                *n ++ == 'n' &&
                *n ++ == 'g' &&
                *n == 0) {
                // input: "string"
                t = node_type_t::string;
                return true;
            }
        }
    }
    return false;
}
$ print 'a array' 't ternary'|gen-func -h .. -f options_t::lookup_trie -r trie_type_t -v
bool options_t::lookup_trie(const char* n, trie_type_t& t)
{
    // pattern: a[rray]|t[ernary]
    switch (*n ++) {
    case 'a':
        if (*n == 0) {
            // input: "a"
            t = trie_type_t::array;
            return true;
        }
        if (*n ++ == 'r' &&
            *n ++ == 'r' &&
            *n ++ == 'a' &&
            *n ++ == 'y' &&
            *n == 0) {
            // input: "array"
            t = trie_type_t::array;
            return true;
        }
        return false;
    case 't':
        if (*n == 0) {
            // input: "t"
            t = trie_type_t::ternary;
            return true;
        }
        if (*n ++ == 'e' &&
            *n ++ == 'r' &&
            *n ++ == 'n' &&
            *n ++ == 'a' &&
            *n ++ == 'r' &&
            *n ++ == 'y' &&
            *n == 0) {
            // input: "ternary"
            t = trie_type_t::ternary;
            return true;
        }
    }
    return false;
}
$ print 'o obj object' 'c c-code =c_code' 't trie' 'e expr'|gen-func -h .. -f options_t::lookup_output -r output_type_t -v
bool options_t::lookup_output(const char* n, output_type_t& t)
{
    // pattern: c[-code]|e[xpr]|o[bj[ect]]|t[rie]
    switch (*n ++) {
    case 'c':
        if (*n == 0) {
            // input: "c"
            t = output_type_t::c_code;
            return true;
        }
        if (*n ++ == '-' &&
            *n ++ == 'c' &&
            *n ++ == 'o' &&
            *n ++ == 'd' &&
            *n ++ == 'e' &&
            *n == 0) {
            // input: "c-code"
            t = output_type_t::c_code;
            return true;
        }
        return false;
    case 'e':
        if (*n == 0) {
            // input: "e"
            t = output_type_t::expr;
            return true;
        }
        if (*n ++ == 'x' &&
            *n ++ == 'p' &&
            *n ++ == 'r' &&
            *n == 0) {
            // input: "expr"
            t = output_type_t::expr;
            return true;
        }
        return false;
    case 'o':
        if (*n == 0) {
            // input: "o"
            t = output_type_t::object;
            return true;
        }
        if (*n ++ == 'b' &&
            *n ++ == 'j') {
            if (*n == 0) {
                // input: "obj"
                t = output_type_t::object;
                return true;
            }
            if (*n ++ == 'e' &&
                *n ++ == 'c' &&
                *n ++ == 't' &&
                *n == 0) {
                // input: "object"
                t = output_type_t::object;
                return true;
            }
        }
        return false;
    case 't':
        if (*n == 0) {
            // input: "t"
            t = output_type_t::trie;
            return true;
        }
        if (*n ++ == 'r' &&
            *n ++ == 'i' &&
            *n ++ == 'e' &&
            *n == 0) {
            // input: "trie"
            t = output_type_t::trie;
            return true;
        }
    }
    return false;
}
$ print 'c comp compact' 'w wide'|gen-func -h .. -f options_t::lookup_gen -r gen_type_t -v
bool options_t::lookup_gen(const char* n, gen_type_t& t)
{
    // pattern: c[omp[act]]|w[ide]
    switch (*n ++) {
    case 'c':
        if (*n == 0) {
            // input: "c"
            t = gen_type_t::compact;
            return true;
        }
        if (*n ++ == 'o' &&
            *n ++ == 'm' &&
            *n ++ == 'p') {
            if (*n == 0) {
                // input: "comp"
                t = gen_type_t::compact;
                return true;
            }
            if (*n ++ == 'a' &&
                *n ++ == 'c' &&
                *n ++ == 't' &&
                *n == 0) {
                // input: "compact"
                t = gen_type_t::compact;
                return true;
            }
        }
        return false;
    case 'w':
        if (*n == 0) {
            // input: "w"
            t = gen_type_t::wide;
            return true;
        }
        if (*n ++ == 'i' &&
            *n ++ == 'd' &&
            *n ++ == 'e' &&
            *n == 0) {
            // input: "wide"
            t = gen_type_t::wide;
            return true;
        }
    }
    return false;
}
$ print 'c cxxpy' 'p perl' 'b bash'|gen-func -h .. -f options_t::lookup_expr -r expr_type_t -v
bool options_t::lookup_expr(const char* n, expr_type_t& t)
{
    // pattern: b[ash]|c[xxpy]|p[erl]
    switch (*n ++) {
    case 'b':
        if (*n == 0) {
            // input: "b"
            t = expr_type_t::bash;
            return true;
        }
        if (*n ++ == 'a' &&
            *n ++ == 's' &&
            *n ++ == 'h' &&
            *n == 0) {
            // input: "bash"
            t = expr_type_t::bash;
            return true;
        }
        return false;
    case 'c':
        if (*n == 0) {
            // input: "c"
            t = expr_type_t::cxxpy;
            return true;
        }
        if (*n ++ == 'x' &&
            *n ++ == 'x' &&
            *n ++ == 'p' &&
            *n ++ == 'y' &&
            *n == 0) {
            // input: "cxxpy"
            t = expr_type_t::cxxpy;
            return true;
        }
        return false;
    case 'p':
        if (*n == 0) {
            // input: "p"
            t = expr_type_t::perl;
            return true;
        }
        if (*n ++ == 'e' &&
            *n ++ == 'r' &&
            *n ++ == 'l' &&
            *n == 0) {
            // input: "perl"
            t = expr_type_t::perl;
            return true;
        }
    }
    return false;
}
$

--[ gen-func2 ]-----------------------------------------------------------------

$ . ../commands.sh
$ print pot potato pottery tattoo tempo|gen-func -h .. -r- -Pe
int lookup(const char* p)
{
    switch (*p ++) {
    case 'p':
        if (*p ++ == 'o' &&
            *p ++ == 't') {
            if (*p == 0)
                return 1;
            switch (*p ++) {
            case 'a':
                if (*p ++ == 't' &&
                    *p ++ == 'o' &&
                    *p == 0)
                    return 2;
                return error;
            case 't':
                if (*p ++ == 'e' &&
                    *p ++ == 'r' &&
                    *p ++ == 'y' &&
                    *p == 0)
                    return 3;
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 't' &&
                *p ++ == 't' &&
                *p ++ == 'o' &&
                *p ++ == 'o' &&
                *p == 0)
                return 4;
            return error;
        case 'e':
            if (*p ++ == 'm' &&
                *p ++ == 'p' &&
                *p ++ == 'o' &&
                *p == 0)
                return 5;
        }
    }
    return error;
}
$ print pot potato pottery tattoo tempo|gen-func -h .. -r- -Pf
int lookup(const char* p)
{
    switch (*p ++) {
    case 'p':
        if (prefix("ot", p)) {
            p += 2;
            if (*p == 0)
                return 1;
            switch (*p ++) {
            case 'a':
                if (equal(p, "to"))
                    return 2;
                return error;
            case 't':
                if (equal(p, "ery"))
                    return 3;
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (equal(p, "ttoo"))
                return 4;
            return error;
        case 'e':
            if (equal(p, "mpo"))
                return 5;
        }
    }
    return error;
}
$ print pot potato pottery tattoo tempo|gen-func -h .. -r- -Pe -z
int lookup(const char* p)
{
    switch (*p ++) {
    case 'p':
        if (*p ++ == 'o' &&
            *p ++ == 't') {
            if (*p == 0)
                return 0;
            switch (*p ++) {
            case 'a':
                if (*p ++ == 't' &&
                    *p ++ == 'o' &&
                    *p == 0)
                    return 1;
                return error;
            case 't':
                if (*p ++ == 'e' &&
                    *p ++ == 'r' &&
                    *p ++ == 'y' &&
                    *p == 0)
                    return 2;
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (*p ++ == 't' &&
                *p ++ == 't' &&
                *p ++ == 'o' &&
                *p ++ == 'o' &&
                *p == 0)
                return 3;
            return error;
        case 'e':
            if (*p ++ == 'm' &&
                *p ++ == 'p' &&
                *p ++ == 'o' &&
                *p == 0)
                return 4;
        }
    }
    return error;
}
$ print pot potato pottery tattoo tempo|gen-func -h .. -r- -Pf -z
int lookup(const char* p)
{
    switch (*p ++) {
    case 'p':
        if (prefix("ot", p)) {
            p += 2;
            if (*p == 0)
                return 0;
            switch (*p ++) {
            case 'a':
                if (equal(p, "to"))
                    return 1;
                return error;
            case 't':
                if (equal(p, "ery"))
                    return 2;
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (equal(p, "ttoo"))
                return 3;
            return error;
        case 'e':
            if (equal(p, "mpo"))
                return 4;
        }
    }
    return error;
}
$ print pot potato pottery tattoo tempo|gen-func -h .. -r- -Pe -u
int lookup(const char* p)
{
    switch (*p ++) {
    case 'p':
        if (*p ++ == 'o' &&
            *p ++ == 't') {
            if (*p == 0)
                return 1;
            switch (*p ++) {
            case 'a':
                if ((*p == 0 || (*p ++ == 't' &&
                    (*p == 0 || (*p ++ == 'o' &&
                    (*p == 0))))))
                    return 2;
                return error;
            case 't':
                if ((*p == 0 || (*p ++ == 'e' &&
                    (*p == 0 || (*p ++ == 'r' &&
                    (*p == 0 || (*p ++ == 'y' &&
                    (*p == 0))))))))
                    return 3;
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 't' &&
                (*p == 0 || (*p ++ == 't' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0))))))))))
                return 4;
            return error;
        case 'e':
            if ((*p == 0 || (*p ++ == 'm' &&
                (*p == 0 || (*p ++ == 'p' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0))))))))
                return 5;
        }
    }
    return error;
}
$ print pot potato pottery tattoo tempo|gen-func -h .. -r- -Pf -u
int lookup(const char* p)
{
    switch (*p ++) {
    case 'p':
        if (prefix("ot", p)) {
            p += 2;
            if (*p == 0)
                return 1;
            switch (*p ++) {
            case 'a':
                if (prefix(p, "to"))
                    return 2;
                return error;
            case 't':
                if (prefix(p, "ery"))
                    return 3;
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (prefix(p, "ttoo"))
                return 4;
            return error;
        case 'e':
            if (prefix(p, "mpo"))
                return 5;
        }
    }
    return error;
}
$ print pot potato pottery tattoo tempo|gen-func -h .. -r- -Pe -uz
int lookup(const char* p)
{
    switch (*p ++) {
    case 'p':
        if (*p ++ == 'o' &&
            *p ++ == 't') {
            if (*p == 0)
                return 0;
            switch (*p ++) {
            case 'a':
                if ((*p == 0 || (*p ++ == 't' &&
                    (*p == 0 || (*p ++ == 'o' &&
                    (*p == 0))))))
                    return 1;
                return error;
            case 't':
                if ((*p == 0 || (*p ++ == 'e' &&
                    (*p == 0 || (*p ++ == 'r' &&
                    (*p == 0 || (*p ++ == 'y' &&
                    (*p == 0))))))))
                    return 2;
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if ((*p == 0 || (*p ++ == 't' &&
                (*p == 0 || (*p ++ == 't' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0))))))))))
                return 3;
            return error;
        case 'e':
            if ((*p == 0 || (*p ++ == 'm' &&
                (*p == 0 || (*p ++ == 'p' &&
                (*p == 0 || (*p ++ == 'o' &&
                (*p == 0))))))))
                return 4;
        }
    }
    return error;
}
$ print pot potato pottery tattoo tempo|gen-func -h .. -r- -Pf -uz
int lookup(const char* p)
{
    switch (*p ++) {
    case 'p':
        if (prefix("ot", p)) {
            p += 2;
            if (*p == 0)
                return 0;
            switch (*p ++) {
            case 'a':
                if (prefix(p, "to"))
                    return 1;
                return error;
            case 't':
                if (prefix(p, "ery"))
                    return 2;
            }
        }
        return error;
    case 't':
        switch (*p ++) {
        case 'a':
            if (prefix(p, "ttoo"))
                return 3;
            return error;
        case 'e':
            if (prefix(p, "mpo"))
                return 4;
        }
    }
    return error;
}
$

--[ gen-func3 ]-----------------------------------------------------------------

$ . ../commands.sh
# # meta command:
# $ for c in ']' '[' '{' '}' '(' ')' '^' '$' '|' '.' '?' '*' '+' '&' '/' '\'; do c="print 'a${c}b =ab'|gen-func -h .. -R"; echo "$ $c"; eval "$c 2>&1"; done
#
$ print 'a]b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\]b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a[b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\[b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a{b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\{b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a}b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\}b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a(b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\(b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a)b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\)b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a^b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\^b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a$b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\$b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a|b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\|b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a.b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\.b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a?b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\?b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a*b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\*b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a+b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\+b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a&b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\&b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a/b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\/b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$ print 'a\b =ab'|gen-func -h .. -R
            s/^(\t+)(\t)return\s*(\x22(a\\\\b)\x22);\s*$/\1\2t = result_t::ab;\n\1\2return true;\n\1}/
$

--[ gen-func4 ]-----------------------------------------------------------------

$ . ../commands.sh
# # meta command:
# $ for c in ']' '[' '{' '}' '(' ')' '^' '$' '|' '.' '?' '*' '+' '&' '/' '\'; do c="print 'a${c}b =ab'|gen-func -h .. -R"; echo "$ $c"; eval "$c 2>&1"; done
#
$ print 'a]b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a]b
    if (*n ++ == 'a' &&
        *n ++ == ']' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a[b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a[b
    if (*n ++ == 'a' &&
        *n ++ == '[' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a{b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a{b
    if (*n ++ == 'a' &&
        *n ++ == '{' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a}b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a}b
    if (*n ++ == 'a' &&
        *n ++ == '}' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a(b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a(b
    if (*n ++ == 'a' &&
        *n ++ == '(' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a)b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a)b
    if (*n ++ == 'a' &&
        *n ++ == ')' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a^b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a^b
    if (*n ++ == 'a' &&
        *n ++ == '^' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a$b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a$b
    if (*n ++ == 'a' &&
        *n ++ == '$' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a|b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a|b
    if (*n ++ == 'a' &&
        *n ++ == '|' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a.b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a.b
    if (*n ++ == 'a' &&
        *n ++ == '.' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a?b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a?b
    if (*n ++ == 'a' &&
        *n ++ == '?' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a*b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a*b
    if (*n ++ == 'a' &&
        *n ++ == '*' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a+b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a+b
    if (*n ++ == 'a' &&
        *n ++ == '+' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a&b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a&b
    if (*n ++ == 'a' &&
        *n ++ == '&' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a/b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a/b
    if (*n ++ == 'a' &&
        *n ++ == '/' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$ print 'a\b =ab'|gen-func -h ..
bool lookup(const char* n, result_t& t)
{
    // pattern: a\b
    if (*n ++ == 'a' &&
        *n ++ == '\\' &&
        *n ++ == 'b' &&
        *n == 0) {
        t = result_t::ab;
        return true;
    }
    return false;
}
$

--[ bugs ]----------------------------------------------------------------------

# [FIXED] BUG #1:
$ print aef ae abg a abc ab abd|../src/trie -gc -ot -ti
{
    "a": 4 {
        "b": 6 {
            "c": 5
            "d": 7
            "g": 3
        }
        "e": 2 {
            "f": 1
        }
    }
}
# [FIXED] BUG #2:
$ print abg a abc ab abd|../src/trie -gc -ot -ti
{
    "a": 2 {
        "b": 4 {
            "c": 3
            "d": 5
            "g": 1
        }
    }
}
# [FIXED] BUG #3:
$ print $'\x80'|../src/trie -gc -oc -Ta
    if (*p ++ == '\x80' &&
        *p == 0)
        return "\x80";
    return error;
# [FIXED] BUG #4:
$ print $'\x80'|../src/trie -gc -oc -Tt
    if (*p ++ == '\x80' &&
        *p == 0)
        return "\x80";
    return error;
# [FIXED] BUG #5:
$ print $'\x80'|../src/trie -gw -oc -Ta
    if (*p ++ == '\x80') {
        if (*p == 0)
            return "\x80";
    }
    return error;
# [FIXED] BUG #6:
$ print $'\x80'|../src/trie -gw -oc -Tt
    if (*p ++ == '\x80') {
        if (*p == 0)
            return "\x80";
    }
    return error;
$


