#!/bin/sh
#-*- mode: Tcl;time-stamp-start:"TimeStamp[ 	]+\\\\?[\"<]+";-*-
# the next line restarts using wish \
exec wish $0 -- $@
set TimeStamp "2008-09-11 20:14:21 poser"
#
# Copyright (C) 2003-2008 William J. Poser (billposer@alum.mit.edu)
# This program is free software; you can redistribute it and/or modify
# it under the terms of version 3 of the GNU General Public License
# as published by the Free Software Foundation.
#
# This program 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.
#
# A copy of the GNU General Public License is contained in the
# procedure "License" in this file.
# If it is not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
# or go to the web page:  http://www.gnu.org/licenses/gpl.txt.

set Version "8.26";
set DevP 0;				# Development stuff short of debugging?
set DebugP 0;				# General debugging? (settable from command line)
set FeatureTestDebugP 0;		# Debug program feature tests? (settable from command line)
package require Iwidgets
package require msgcat
proc _ {s} {return [::msgcat::mc $s]};	# Define shorthand for gettext
proc ProgramTimeDateStamp {} {
    set sts [split $::TimeStamp]
    return "[lindex $sts 0] [lindex $sts 1]"
}

#For debugging messages
proc dmsg {msg} {
    if {$::DebugP} {
	puts stderr $msg;
	flush stderr;
    }
}

#For dev messages
proc devmsg {msg} {
    if {$::DevP} {
	puts stderr $msg;
	flush stderr;
    }
}


#No op
proc nil {args} {
}

proc TraceGlobalArrayEntry {n m o} {
    set val [set ::${n}($m)]
    puts [format "%s(%s) <- %s" $n $m $val]
}

#Portability
#Figure out what system we are running on
if {[string equal $tcl_platform(platform) windows]} {
    set System MSWindows;
    dmsg "Running under MS Windows";
} elseif {[string equal $tcl_platform(platform) unix]} {
    if {[string equal $tcl_platform(os) Darwin]} {
	set System MacOSX;
	dmsg "Running under Mac OS X";
    } else {
	set System Unix;
	dmsg "Running under Unix";
    }
}

#Find out what our base graphics system is
if {[string match X11*  [winfo server .]]} {
    set AquaP 0
    set WindowSystem X11
} else {
    if {[string match $System MSWindows]} {
	set AquaP 0;
	set WindowSystem MSWindows;
    }
    if {[string match $System MacOSX]} {
	set AquaP 1
	set WindowSystem Aqua
    }
}

switch $System {
    Unix {
	event add <<B3>> <ButtonPress-3>
	event add <<B3Release>> <ButtonRelease-3>
    }
    MacOSX {
	event add <<B3>> <Control-ButtonPress-1>
	event add <<B3Release>> <Control-ButtonRelease-1>
    }
    MSWindows {
	event add <<B3>> <ButtonPress-3>
	event add <<B3Release>> <ButtonRelease-3>
	set InitFile "RedetInit";
	set HistoryFile "RedetHistory";
	set JournalFile "RedetLog";
	set ColorFile "RedetColors";
	set NonBinPath [file dirname [info script]];
	set ::env(CYGWIN) "";
    }
}

#Find out if we are running in Tcl/Tk 8.5 or greater
#This matters because fonts are bigger in 8.5+ under Linux
set TkEightFivePlusOnX11P 0
set VLevelList [split [info patchlevel] "."]
set Major [lindex $VLevelList 0]
set Minor [lindex $VLevelList 1]
if {$WindowSystem eq "X11"} {
    if {$Major > 8} {
	set TkEightFivePlusOnX11P 1
    } else {
	if {($Major == 8) && ($Minor >= 5)} {
	    set TkEightFivePlusOnX11P 1
	}
    } 
}

if {[info exists ::env(TMP)]} {
    set TempDir $::env(TMP);
} elseif {[info exists ::env(TEMP)]} {
    set TempDir $::env(TEMP);
} else {
    if {$tcl_platform(platform) == "windows"} {
	set TempDir "C:\tmp";
    } else {
	set TempDir "/tmp";
    }
}


# Set UseDiffP to zero to prevent testing for the presence of diff.
# which on some systems causes problems. The only consequence
# will be the unavailability of the popup showing the differences between
# actual output and comparison data.
set UseDiffP 1;

#If you are running this under MS Windows without using cygwin and
#wish, the Tcl/Tk windowing shell, will not work properly, try using tclsh.exe
#as the Tcl interpreter and uncomment the following line to import Tk.
#package require Tk

#trace add variable ColorSpecs(Messages,Background) write TraceGlobalArrayEntry

set InitFile     ".redetrc";
set HistoryFile  ".redethist";
set JournalFile  ".redetlog";
set ColorFile    ".redetcolors";
set NonBinPath [file join /usr local share Redet];

#Flags showing whether windows are editable
set INDEditableP 0;
set OUTEditableP 0;
set COMEditableP 0;


#These aliases for the various widgets facilitate making changes in the
#widget hierarchy.
set REG .rsf.re;
set SUB .rsf.sub;
set COM .dwf.comp;
set IND .dwf.in;
set OUT .dwf.out;
set INDSB .dwf.indsbar;
set OUTSB .dwf.outsbar;
set COMSB .dwf.comsbar;
set HISTF .hl.f
set PALF  .pal.f

#Limits
set ShellItemLimit 500
				
#Parameters
set MainWidth 65;
set MainHeight 10;
set PopupLines 15;
set InterfaceLocaleListHeight 15;		# Number of lines to display.
set HPWidth 60;				# Width of help popups.
set HPLines 10;				# Number of lines for help popups.
set PaletteHeightLimit 20

set DefaultBrowser xdg-open
set BrowserList [list firefox mozilla epiphany galeon konqueror dillo netscape opera]
set BrowserPIDS [list];
#Defaults

set CommandLineProgram "";
set BeginInSubstitutionModeP 0;
set DefaultProgram "tcl";
#set DefaultProgram "egrep";
set Program ""; #Capitalized version.
set program $DefaultProgram; #Lower-case version. 
#This is just for documentation. We actually set this just after reading
#the init file. We need to record the initial program so that we have
#something to default to if the user aborts a feature test.
set InitialProgram $DefaultProgram;
set FirstTestP 1;

set ButtonName "";

set LeftImplicitStar  "*";
set RightImplicitStar "*";

set ColorSpecs(AlertDismiss,Background)	"\#2200FF";
set ColorSpecs(AlertDismiss,Foreground)	"\#FFCC00";
set ColorSpecs(Alert,Background)		"\#c36176";
set ColorSpecs(Alert,Foreground)		"\#FFFFFF";
set ColorSpecs(Default,Background) \#FFD8B1
set ColorSpecs(IPAEntry,Background)		"\#FFFFFF";
set ColorSpecs(IPAEntry,Foreground)		"\#000000";
set ColorSpecs(IPAHeadings,Background)		"\#09ffb2";
set ColorSpecs(Match,Background)		white
set ColorSpecs(Menu,ActiveBackground)	        salmon
set ColorSpecs(Menu,ActiveForeground)	        black
set ColorSpecs(Menu,Background)			"\#FFC192"
set ColorSpecs(Menu,Foreground)			black
set ColorSpecs(Menu,Select)			blue
set ColorSpecs(ProgramMenu,TestedForeground)		black
set ColorSpecs(ProgramMenu,TestedBackground)		"\#D0D0FF"
set ColorSpecs(Menubar,Background)	 	"\#c36176";
set ColorSpecs(Menubar,Foreground)		"\#fee4a9";
set ColorSpecs(Menubar,ActiveBackground)	"\#fee4a9";
set ColorSpecs(Menubar,ActiveForeground)	"\#c36176";
set ColorSpecs(Messages,Background) 		"\#e9c4dc";
set ColorSpecs(Messages,Foreground) 		"\#000000";
set ColorSpecs(PopupWidgetDefault,Background)    "\#fee4a9";
set ColorSpecs(PopupWidgetDefault,Foreground)    black
set ColorSpecs(PopupWidgetButton,Background)    "\#FBAA9A"
set ColorSpecs(PopupWidgetButton,Foreground)    black
set ColorSpecs(PopupWidgetCheckbutton,Foreground)    black
set ColorSpecs(PopupWidgetEntry,Background)    "\#BBBBFF"
set ColorSpecs(PopupWidgetEntry,Foreground)    black
set ColorSpecs(PopupWidgetLabel,Background)    "\#FEE4A9";
set ColorSpecs(PopupWidgetLabel,Foreground)    black
set ColorSpecs(ProgramInfoPopup,Background)    "\#B5E1FF"
set ColorSpecs(ProgramInfoPopup,Foreground)    black;
#set ColorSpecs(ProgramSpecificControls,Background)	"\#FFBD9A"
set ColorSpecs(ProgramSpecificControls,Background)	grey
set ColorSpecs(ProgramSpecificControls,Foreground)	black;
set ColorSpecs(ProgramSpecificControls,ActiveBackground)	blue;
set ColorSpecs(ProgramSpecificControls,ActiveForeground)	yellow;
set ColorSpecs(ProgramSpecificControls,Select)	green;
set ColorSpecs(ProgramSpecificControls,EntryBackground)	white
set ColorSpecs(ProgramSpecificControls,EntryForeground)	black
set ColorSpecs(ProgramSpecificControls,DisabledEntryBackground)	coral;
set ColorSpecs(Regexp,Background)		"\#08ffb1";
set ColorSpecs(Regexp,Foreground)		"\#0c1816";
set ColorSpecs(Subexp,Background) 		"\#FFFFFF";
set ColorSpecs(Subexp,Foreground) 		"\#000000";
set ColorSpecs(TestData,Background) 		"\#e9c4dc";
set ColorSpecs(TestData,Foreground) 		"\#000000";
set ColorSpecs(Results,Background) 		"\#e6b483";
set ColorSpecs(Results,Foreground) 		"\#000000";
set ColorSpecs(ComparisonData,Background)		"\#a3d6a1";
set ColorSpecs(ComparisonData,Foreground)		"\#0c1816";
set ColorSpecs(PaletteGloss,Background)		"\#B5B5D9";
set ColorSpecs(PaletteGloss,Foreground)		"\#0c1816";
set ColorSpecs(PaletteNotation,Background)		"\#B5B5D9";
set ColorSpecs(PaletteNotation,Foreground)		"\#0c1816";
set ColorSpecs(PaletteScrollbarSlider,Highlight) salmon;
set ColorSpecs(PaletteSelectionGloss)     NavajoWhite
set ColorSpecs(PaletteSelectionRegexp)    NavajoWhite
set ColorSpecs(PaletteHighlight,Background)    	"\#E23A6C"
set ColorSpecs(PaletteHighlight,Foreground)    	yellow
set ColorSpecs(Palette,Variable) 	 "\#A4E9FF";
set ColorSpecs(Palette,Fixed)    	 wheat
set ColorSpecs(TextDisplay,Background) NavajoWhite
#set ColorSpecs(TextDisplay,Background) "\#E6EAF6"
set ColorSpecs(TextDisplay,Foreground) "\#000000"
set ColorSpecs(UserTextEntry,Background)	"\#FFFFFF";
set ColorSpecs(UserTextEntry,Foreground)	black
set ColorSpecs(ColorConfiguration,Background)	"\#B5B5D9";
set ColorSpecs(ColorConfiguration,Foreground)		"\#0c1816";
set ColorSpecs(HistoryList,Background)		"\#B5B5D9";
set ColorSpecs(HistoryList,Foreground)		"\#0c1816";
set ColorSpecs(Placard,Background)	"\#eeac99";
set ColorSpecs(Placard,Foreground)	"\#100e39";
set ColorSpecs(UserClassPalette,Background)	\#F5E8FF;
set ColorSpecs(UserClassPalette,Foreground)	black;
set ColorSpecs(UserPaletteEntry,Background)	"\#F88E1A"

#Initializations

set Pars(TestDataEncoding) utf-8
set Pars(ComparisonDataEncoding) utf-8
set Pars(ResultEncoding) utf-8
set UseScrollbarsP 1;
set ExecutionFlag Normal;		# This is used to forestall actual execution
					# when saving the command line etc.
set UpdateJavaByteCodeP 1;
set AutoClearRegexpP 0;
set StandardConfigurationP 1;
set UserClassesEnabledP 0;
set DoSubstitutionsP 0;
set OutputOnlyChangedLinesP 1;
set SideBySideLayoutP 0;
set RegSubSideBySideP 0;
set FeatureTestP 1;
set ComparisonDataFromWindowP 0;
set ComparisonWindowDisplayedP 0;
set InputDataFromWindowP 0;
set OutputFromWindowP 0;
set IPAAIsDisplayedP 0;
set IPACIsDisplayedP 0;
set IPAVIsDisplayedP 0;
set IPADIsDisplayedP 0;
set CharEntryByCodeIsDisplayedP 0;
set TwoCaseP 0;
set PaletteIsDisplayedP 0;
set PaletteToBeDisplayedP 0;
set PaletteFeatures 0;
set PipeP 0;
set BalloonHelpP 1;
set ReadHistoryFileP 1;
set ReadInitFileP 1;
set FocusFollowsMouseP 0;
set InitialTestInputDataFile "";
set TestingFeaturesP 0;
set SortUnicodeRangesByCodepointP 0;
set ShowActualRegexpP 0;
set PreviousActualRegexp "";
set CharentryMenuItems 6;
set AbortFeatureTestP 0;
set WhichFontToSet MainFont
set CharacterEntryMenuItems 0;
set FeatureFileList [list];


set Messages(CommandLineCaseInsensitiveFlagMSGStd) [_ "Match without regard to case?"]
set Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef) \
    [_ "Match without regard to case?\n(This flag has no effect on back references.)"]

set ProgList [lsort -dictionary [list \
agrep\
arena\
awk\
bash\
BusyBoxEgrep\
C\
cgrep\
ed\
egrep\
emacs\
euphoria\
expr\
fgrep\
fish\
frink\
gawk\
glark\
grep\
groovy\
guile\
ici\
icon\
java\
javascript\
jgrep\
judoscript\
ksh\
lua\
mawk\
minised\
mysql\
nawk\
nrgrep\
numgrep\
patmatch\
pcregrep\
perl\
php\
pike\
python\
rc\
rebol\
rep\
ruby\
sed\
sleep\
sleepwc\
ssed\
tcl\
tclglob\
tcsh\
tr\
vim\
wmagrep\
zsh]];
set DetailedProgList [lsort -dictionary [list \
agrep\
arena\
awk\
bash\
BusyBoxEgrep\
C\
cgrep\
ed\
egrep\
emacs\
euphoria\
expr\
fgrep\
fish\
frink\
gawk\
glark\
grep\
groovy\
guile\
ici\
icon\
java\
javascript\
jgrep\
judoscript\
ksh\
lua\
mawk\
minised\
mysql\
nawk\
nrgrep\
numgrep\
patmatch\
pcregrep\
perl\
php-mb\
php-pcre\
php-posix\
pike\
python\
rc\
rebol\
rep\
ruby\
sed\
sleep\
sleepwc\
ssed\
tcl\
tclglob\
tcsh\
tr\
vim\
wmagrep\
zsh]];


proc ListSupportedPrograms {fh} {
    puts $fh "Supported Programs:"
    foreach p $::DetailedProgList {
	if {!$::ProgramInfo($p,AvailableP)} {
	    puts $fh [format "%-20s\t \[not available\]" $p]
	} else {
	    puts $fh [format "%-20s" $p]
	}
    }
}

#Feature tests are executed in the order of this list
set PropertyList [list\
tested\
CposRange\
RegionDoubleDot\
dot\
UnderscoreAnySingle\
SingleOctet\
DotAnySingle\
XAnySingle\
NAnySingleNucleotide\
RAnySinglePurineBase\
YAnySinglePyramidineBase\
SBaseGC\
WBaseAT\
MBaseAC\
KBaseGT\
VBaseACG\
HBaseACT\
DBaseAGT\
BBaseCGT\
JResidueHydrophobic\
OResidueHydrophilic\
BResidueDN\
ZResidueEQ\
StarAny\
PercentAny\
StarPrev\
CrosshatchPrev\
DoubleCrosshatchPrev\
StarNext\
starclass\
PossStar\
SubReluctantStarPrevDollar\
SubReluctantStarPrevBackslash\
SubHyphenClass\
plusany\
plusprev\
plusprevbs\
plusclass\
PossPlus\
plusnext\
SubReluctantPlusPrevDollar\
SubReluctantPlusPrevBackslash\
crosshatchany\
atsignonenext\
qm1\
qm1bs\
qmopt\
qmoptbs\
EqualOptbs\
qmoptdbsnqq\
qmoptclass\
qmoptnext\
PossQMark\
SubReluctantQuestionMarkPrevDollar\
SubReluctantQuestionMarkPrevBackslash\
commaor\
semiand\
ampandbs\
pipe\
pipebs\
pipedbs\
pipebsall\
pipedbsall\
altcomma\
group\
GroupNoWildcards\
groupbs\
groupdbsnqq\
groupdbs\
ncgroup\
ncgroupdb\
NoCaptureGroupPercentbsall\
ObligatoryQuantifierGroup\
SelfishNoCaptureGroup\
SelfishNoCaptureGroupA\
SelfishNoCaptureGroupB\
SelfishNoCaptureGroupC\
taggedgroup\
taggedgroupsq\
taggedgroupref\
groupcomp\
backref\
backrefdbs\
backrefksh\
backrefper\
backrefbsall\
backrefdbsall\
backrefAtLeastTen\
backrefkshAtLeastTen\
backrefdbsAtLeastTen\
backrefperAtLeastTen\
backrefbsallAtLeastTen\
backrefdbsallAtLeastTen\
reprange\
reprangebs\
reprangelbs\
reprangedbs\
PossMToN\
repfixed\
repfixedbs\
repfixeddbs\
repmin\
repminbs\
repmindbs\
PossAtLeastM\
repmax\
repmaxlbs\
ZeroOrMoreCurly\
SubReluctantIntegerRangeDollar\
SubReluctantIntegerRangeBackslash\
ReluctantIntegerRangeVIMBackslash\
ReluctantAtLeastMVIMBackslash\
ReluctantAtMostNVIMBackslash\
ReluctantExactlyMVIMBackslash\
SubReluctantZeroOrMoreVIMBackslash\
ColumnSpecifier\
PreColumnSpecifier\
PostColumnSpecifier\
rangerebol\
piperebol\
lowerrebol\
upperrebol\
alpharebol\
digitrebol\
xdigitrebol\
alnumrebol\
IntegerMultiple\
IntegerFactor\
IntegerAlternative\
set\
setcomp\
setcomptilde\
setcompbang\
range\
multirange\
Range128\
Range129\
CrossUnicodeBlockP\
IntegerRange\
IntegerRangeDoubleDot\
CollationClass\
CollatingElementNamed\
CollatingElementMultichar\
baldlim\
NegativeCircumflex\
MatchNotMatchTilde\
W3CharClassSubtraction\
caret\
PercentCaretBS\
dollar\
PercentDollarBS\
LessThanBeginning\
GreaterThanEnd\
AbsoluteEndOfString\
pabegin\
pabegindb\
boslq\
pzendbs\
pzenddbs\
pZendbs\
pZenddbs\
eosrq\
langle\
rangle\
BeginWordm\
EndWordM\
WordBoundary\
WordBoundaryBs\
WordBoundaryybs\
WordBoundaryydbs\
NonWordBoundary\
NonWordBoundaryYbs\
alnum\
alpha\
BackspaceClass\
blank\
cntrl\
digit\
EscapeClass\
graph\
lower\
print\
mockprint\
perlprint\
punct\
space\
TabClass\
upper\
wordclass\
xdigit\
LangleClass\
RangleClass\
compposixclassinner\
compposixclassouter\
SubLower\
SubUpper\
SubDigit\
SubPunct\
SubCntrl\
SubAlnum\
SubAlpha\
SubBlank\
SubSpace\
SubGraph\
SubPrint\
SubXdigit\
jLower\
jLowerdb\
jLowerc\
jLowercdb\
jUpper\
jUpperdb\
jUpperc\
jUppercdb\
jDigit\
jDigitdb\
jDigitc\
jDigitcdb\
jPunct\
jPunctdb\
jPunctc\
jPunctcdb\
jCntrl\
jCntrldb\
jCntrlc\
jCntrlcdb\
jAlpha\
jAlphadb\
jAlphac\
jAlphacdb\
jXdigit\
jXdigitdb\
jXdigitc\
jXdigitcdb\
jAlnum\
jAlnumdb\
jAlnumc\
jAlnumcdb\
jGraph\
jGraphdb\
jGraphc\
jGraphcdb\
jPrint\
jPrintdb\
jPrintc\
jPrintcdb\
jBlank\
jBlankdb\
jBlankc\
jBlankcdb\
jSpace\
jSpacedb\
jSpacec\
jSpacecdb\
jAscii\
jAsciidb\
jAsciic\
jAsciicdb\
uname\
unamedb\
jUBlockIn\
jUBlockInc\
jUBlockIs\
jUBlockIsc\
jUBlockBare\
jUBlockBarec\
jUCat\
jUCatc\
jUCatIn\
jUCatcIn\
jUCatIs\
jUCatcIs\
jUBlockIndb\
jUBlockIncdb\
jUBlockIsdb\
jUBlockIscdb\
jUBlockBaredb\
jUBlockBarecdb\
jUCatdb\
jUCatcdb\
jUCatdbIn\
jUCatcdbIn\
jUCatdbIs\
jUCatcdbIs\
bsW\
bsWdb\
llower\
llowerc\
lupper\
lupperc\
ldigit\
ldigitc\
lpunct\
lpunctc\
lcntrl\
lcntrlc\
lalpha\
lalphac\
lalnum\
lalnumc\
lspace\
lspacec\
lxdigit\
lxdigitc\
pdigit\
pdigitc\
pspace\
pspacec\
pspacedb\
pspacedbc\
pdigitdb\
pdigitdbc\
W3Space\
W3Spacec\
xmldigit\
xmldigitc\
bsw\
pbsw\
pbbsw\
pbsW\
bell\
belldb\
backspace\
escape\
escapedb\
cr\
crdb\
tab\
tabdb\
controlc\
controlcdb\
LiteralMetachar\
octal\
octalo\
octaldb\
decimald\
hexl\
hexldb\
hexu\
hexudb\
HexWideCharCurly\
HTMLHexReference\
HTMLDecimalReference\
AlphaBSa\
AlphaBSAc\
UpperCaseBSu\
UpperCaseBSUc\
LowerCaseBSl\
LowerCaseBSLc\
WordBSw\
WordBSWc\
WordHeadBSh\
WordHeadBSHc\
XMLInitial\
XMLInitialc\
xdigitBSx\
xdigitBSxc\
odigitBSo\
odigitBSOc\
some\
any\
QuoteFollowingMetacharsQDot\
QuoteFollowingMetacharsMDot\
ShiftBackToMagicDot\
TerminateMetacharQuotingDot\
comment\
CaseInsensitiveFlagSmallI\
CaseInsensitiveFlagSmallIu\
CaseInsensitiveCrosshatch\
CaseInsensitiveFlagSmallIAsciiLiteral\
CaseInsensitiveFlagSmallINonAsciiLiteral\
CaseInsensitiveFlagSmallIuNonAsciiLiteral\
CaseInsensitiveFlagSmallIAsciiClass\
CaseInsensitiveFlagSmallINonAsciiClass\
CaseInsensitiveFlagSmallIuNonAsciiClass\
CaseInsensitiveFlagSmallIAsciiClassSymmetric\
CaseInsensitiveFlagSmallINonAsciiClassSymmetric\
CaseInsensitiveFlagSmallIuNonAsciiClassSymmetric\
CaseInsensitiveFlagSmallIOctal\
CaseInsensitiveFlagSmallIHex\
CaseInsensitiveCrosshatchAsciiLiteral\
CaseInsensitiveCrosshatchNonAsciiLiteral\
CaseInsensitiveCrosshatchuNonAsciiLiteral\
CaseInsensitiveCrosshatchAsciiClass\
CaseInsensitiveCrosshatchNonAsciiClass\
CaseInsensitiveCrosshatchuNonAsciiClass\
CaseInsensitiveCrosshatchAsciiClassSymmetric\
CaseInsensitiveCrosshatchNonAsciiClassSymmetric\
CaseInsensitiveCrosshatchuNonAsciiClassSymmetric\
CaseInsensitiveBSSmallCAsciiLiteral\
CaseInsensitiveBSSmallCNonAsciiLiteral\
CaseInsensitiveBSSmallCAsciiClass\
CaseInsensitiveBSSmallCNonAsciiClass\
CaseInsensitiveBSSmallCAsciiClassSymmetric\
CaseInsensitiveBSSmallCNonAsciiClassSymmetric\
CaseInsensitiveBSSmallCOctal\
CaseInsensitiveBSSmallCHex\
CaseInsensitiveAsciiLiteral\
CaseInsensitiveNonAsciiLiteral\
CaseInsensitiveAsciiClass\
CaseInsensitiveNonAsciiClass\
CaseInsensitiveAsciiClassSymmetric\
CaseInsensitiveNonAsciiClassSymmetric\
CaseInsensitiveOctal\
CaseInsensitiveHex\
flagCrosshatchICaseSensitive\
flagCrosshatchlAsymmetricCaseInsensitive\
CaseInsensitiveCrosshatchOctal\
CaseInsensitiveCrosshatchHex\
CaseInsensitiveCLFlagBackrefP\
CaseInsensitiveBSSmallC\
CaseSensitiveFlag\
CaseSensitiveBSBigC\
FlagQWideScope\
FlagCrosshatchWideScope\
FlagBSSmallCWideScope\
CaseInsensitiveFlagWideScope\
flagx\
flagb\
flage\
flagq\
UnsetFlag\
IgnoreCombiningCharactersBSZ\
jUnion\
jInter\
plookahead\
plookaheadAtSign\
plookback\
plookbackAtSign\
nlookahead\
nlookaheadAtSign\
nlookback\
nlookbackAtSign\
CondGroupSimple\
CondGroupElse\
CondLookaroundSimple\
CondLookaroundElse\
CondPosLookaheadSimple\
CondPosLookaheadElse\
CondNegLookaheadSimple\
CondNegLookaheadElse\
CondPosLookbackSimple\
CondPosLookbackElse\
CondNegLookbackSimple\
CondNegLookbackElse\
SubBackRefBare\
SubBackRefBareAtLeastTen\
SubBackReferenceDol\
SubBackReferenceDolAtLeastTen\
SubBackReferencePercent\
SubBackReferencePercentAtLeastTen\
SubBackRefbs\
SubBackRefParbs\
SubBackRefbsAtLeastTen\
SubBackRefParbsAtLeastTen\
SubBackRefdbs\
SubBackRefdbsAtLeastTen\
SubBackRefPardbsdbs\
SubBackRefPardbsdbsAtLeastTen\
SubEntBackRefZero\
SubBackReferenceDolZero\
SubBackReferencePercentZero\
SubBackRefdbsZero\
SubBackRefbsZero\
SubBackRefParbsZero\
SubBackRefPardbsdbsZero\
Subampentbackrefs\
Subampentbackrefsdbs\
SubampentbackrefsPardbsdbs\
SubDolAmpEntBackRef\
SubPreMatch\
SubPreMatchDol\
SubPostMatch\
SubPostMatchDol\
SubLastCapture\
SubLastCaptureDol\
SubPreMatchLit\
SubPostMatchLit\
SubRange\
SubCStarN\
SubCStar\
SubLitString\
SubDowncaseChar\
SubUpcaseChar\
SubDowncaseString\
SubUpcaseString\
SubEndCaseDomaine\
SubEndCaseDomainE\
SubDowncaseCharDollar\
SubUpcaseCharDollar\
SubDowncaseStringDollar\
SubUpcaseStringDollar\
SubEndCaseDomaineDollar\
SubEndCaseDomainEDollar\
SubNewline\
ExactMatchWD\
ExactMatchTRE\
ExactMatchCgrep\
TRECostSetting\
TotalErrorCrosshatchA\
embedding\
EmbeddingMatchOnly\
embeddingLeft\
embeddingRight\
unicodebmp\
unicodefull\
PossQMarkA\
PossQMarkB\
PossStarA\
PossStarB\
PossPlusA\
PossPlusB\
PossAtLeastMA\
PossAtLeastMB\
PossMToNA\
PossMToNB\
PossMToNC
];

array set Features {};		# Array indexed on feature, program, and locale.
				# Values are 1 if the program has that feature in that locale,
				# else 0, except for alttype, which is not boolean.
array set ProgramInfo {};	# This array is used to keep track of special features of
				# particular programs. It is indexed on program name
                                # and the various special features.
set ProgramInfo(agrep,BestResults) 0
set ProgramInfo(agrep,CaseInsensitiveP) 0
set ProgramInfo(agrep,TotalCost) 0
set ProgramInfo(agrep,DeletionCost) 0
set ProgramInfo(agrep,InsertionCost) 0
set ProgramInfo(agrep,SubstitutionCost) 0
set ProgramInfo(agrep,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(arena,CaseInsensitiveP) 0;
set ProgramInfo(arena,VerboseP) 0;

set ProgramInfo(bash,CaseInsensitiveGlobP) 0;
set ProgramInfo(bash,CaseInsensitiveMatchP) 0;
set ProgramInfo(bash,CaseInsensitiveCLFlagBackrefP) \
    [list CaseInsensitiveGlobP 1 CaseInsensitiveMatchP 1]
set ProgramInfo(bash,ExtendedP) 1;

set ProgramInfo(BusyBoxEgrep,CaseInsensitiveP) 0
set ProgramInfo(BusyBoxEgrep,Complement) 0

set ProgramInfo(cgrep,CaseInsensitiveP) 0
set ProgramInfo(cgrep,Complement) 0
set ProgramInfo(cgrep,ExtendedP) 1
set ProgramInfo(cgrep,TotalCost) 0
set ProgramInfo(cgrep,InsertionCost) 1
set ProgramInfo(cgrep,DeletionCost) 1
set ProgramInfo(cgrep,SubstitutionCost) 1
set ProgramInfo(cgrep,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(egrep,CaseInsensitiveP) 0
set ProgramInfo(egrep,EmitMatchOnly) 0;
set ProgramInfo(egrep,Complement) 0
set ProgramInfo(egrep,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(emacs,FoldCaseMatchP) 0
set ProgramInfo(emacs,FoldCaseReplaceP) 0
set ProgramInfo(emacs,CaseInsensitiveCLFlagBackrefP) [list FoldCaseMatchP 1]

set ProgramInfo(fgrep,CaseInsensitiveP) 0
set ProgramInfo(fgrep,Complement) 0
set ProgramInfo(fgrep,EmitMatchOnly) 0
set ProgramInfo(fgrep,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(flex,CaseInsensitiveP) 0;

set ProgramInfo(gawk,CaseInsensitiveP) 0;
set ProgramInfo(gawk,IntervalExpressions) 1;
set ProgramInfo(gawk,Notation) GNU;
set ProgramInfo(gawk,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(glark,CaseInsensitiveP) 0;
set ProgramInfo(glark,EmitMatchOnly) 0;
set ProgramInfo(glark,Complement) 0;
set ProgramInfo(glark,MatchEntireLine) 0;
set ProgramInfo(glark,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(grep,CaseInsensitiveP) 0
set ProgramInfo(grep,Notation) Basic;
set ProgramInfo(grep,EmitMatchOnly) 0;
set ProgramInfo(grep,Complement) 0
set ProgramInfo(grep,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(ici,CaseInsensitiveP) 0;
set ProgramInfo(ici,VerboseP) 0;
set ProgramInfo(ici,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(java,CanonEQ) 1;
set ProgramInfo(java,CaseInsensitiveP) 0;
set ProgramInfo(java,UnicodeCase) 0;
set ProgramInfo(java,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(jgrep,CaseInsensitiveP) 0;
set ProgramInfo(jgrep,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(mysql,RegexpP) 1;

set ProgramInfo(nrgrep,CaseInsensitiveP) 0
set ProgramInfo(nrgrep,ComplementP) 0
set ProgramInfo(nrgrep,TotalCost) 0
set ProgramInfo(nrgrep,InsertionsP) 1
set ProgramInfo(nrgrep,DeletionsP) 1
set ProgramInfo(nrgrep,SubstitutionsP) 1
set ProgramInfo(nrgrep,TranspositionsP) 1
set ProgramInfo(nrgrep,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(numgrep,OutputNumberByNumberP) 0;

set ProgramInfo(patmatch,MismatchNumber) 0;
set ProgramInfo(patmatch,MismatchTypes) ids;
set ProgramInfo(patmatch,ResidueType) n;
#Note that the specification of parameters only for the following
#four tests assumes that the other tests will be done with
#the default of n. The default for ResidueType cannot be
#changed without changing the settings here.
set ProgramInfo(patmatch,JResidueHydrophobic) [list ResidueType p]
set ProgramInfo(patmatch,OResidueHydrophilic) [list ResidueType p]
set ProgramInfo(patmatch,BResidueDN) [list ResidueType p]
set ProgramInfo(patmatch,ZResidueEQ) [list ResidueType p]

set ProgramInfo(pcregrep,CaseInsensitiveP) 0;
set ProgramInfo(pcregrep,EmitMatchOnly) 0;
set ProgramInfo(pcregrep,Complement) 0
set ProgramInfo(pcregrep,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(perl,UnicodeLocaleDependentP) 0;

set ProgramInfo(python,RawStringP) 1;

set ProgramInfo(sed,Which) othersed;#default
set ProgramInfo(sed,ExtendedRegexp) 0;

set ProgramInfo(sgrep,CaseInsensitiveP) 0;
set ProgramInfo(sgrep,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

#options: basic, extended, perl
set ProgramInfo(ssed,RegexpType) perl;
set ProgramInfo(ssed,POSIX) 0;

set ProgramInfo(tcl,CaseInsensitiveP) 0;
set ProgramInfo(tcl,EmitMatchOnlyP) 0
set ProgramInfo(tcl,ExpandedP) 0;
set ProgramInfo(tcl,CaseSensitiveFlag) [list CaseInsensitiveP 1]
set ProgramInfo(tcl,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(tr,Complement) 0;
set ProgramInfo(tr,Squeeze) 0;
set ProgramInfo(tr,Truncate) 0;
					
set ProgramInfo(vim,CaseInsensitiveP) 0
set ProgramInfo(vim,ListModeP) 0
set ProgramInfo(vim,SmartCaseP) 0
set ProgramInfo(vim,SubstitutionGlobalP) 1
set ProgramInfo(vim,CaseSensitiveBSBigC) [list CaseInsensitiveP 1]
set ProgramInfo(vim,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]

set ProgramInfo(wmagrep,BestResults) 0
set ProgramInfo(wmagrep,CaseInsensitiveP) 0
set ProgramInfo(wmagrep,TotalCost) 0
set ProgramInfo(wmagrep,DeletionCost) 0
set ProgramInfo(wmagrep,InsertionCost) 0
set ProgramInfo(wmagrep,SubstitutionCost) 0
set ProgramInfo(wmagrep,CaseInsensitiveCLFlagBackrefP) [list CaseInsensitiveP 1]


set ProgramInfo(zsh,ExtendedGlobP) 1;
set ProgramInfo(zsh,KornQuantifiersP) 1;

set LeftRubyStringDelimiter ";";
set RightRubyStringDelimiter ";";
array set PopupList {};
array set PopupList {};
array set CommandGlosses {};
array set Wlist {}; #Maps color palette indices to internal names.
set PaletteIndex 0; #Used by color configuration system.

set PHPPCRE 0;				# Perl style regexps in PHP
set PHPMB 0;				# Multibyte extension for PHP regexps?

set InData "";
set ComparisonData ""; 
set RegexpResult "";
set DiffPopup "";

set InterfaceLocale "";
set InterfaceLocaleText "";
set ProposedInterfaceLocale "";

set wret 0;

#File names
set ClassName [format "RedetComm%d" [pid]];# Used for Java files.
set CommandFile [file join $TempDir $ClassName];
set CSourceFile [file join $TempDir [format "Redet%d.c" [pid]]];
set JavaMatchClassName [format "%sMatch" $ClassName];
set JavaMatchClassFile [format "%sMatch.class" $CommandFile];
set JavaMatchFile [format "%sMatch.java" $CommandFile];
set JavaSubClassName [format "%sSub" $ClassName];
set JavaSubClassFile [format "%sSub.class" $CommandFile];
set JavaSubFile [format "%sSub.java" $CommandFile];
set TestFile [file join $TempDir  [format "RedetData%d" [pid]]];
set TempCompFile [file join $TempDir  [format "RedetComp%d" [pid]]];
set TempOutputFile [file join $TempDir  [format "RedetOut%d" [pid]]];
set TempSortFile [file join $TempDir  [format "RedetSort%d" [pid]]];
set TempGlobDir [file join $TempDir  [format "RedetDirr%d" [pid]]];
set DiffResultFile [file join $TempDir  [format "RedetDiff%d" [pid]]];
set EmacsOutputFile [file join $TempDir  [format "RedetEmacsout%d" [pid]]];
set EmacsWrapper [file join $TempDir  [format "RedetEmacswrapper%d" [pid]]];
set VersionFile [format "redet%dgetv.txt" [pid]];
set FeatureTestLogHandle "";

set PropertyUse(tested,TestP) 0;
set PropertyUse(BooleanAnd,TestP) 1;
set PropertyUse(group,TestP) 1;
set PropertyUse(GroupNoWildcards,TestP) 1;
set PropertyUse(groupbs,TestP) 1;
set PropertyUse(groupdbsnqq,TestP) 1;
set PropertyUse(groupdbs,TestP) 1;
set PropertyUse(ncgroup,TestP) 1;
set PropertyUse(ncgroupdb,TestP) 1;
set PropertyUse(NoCaptureGroupPercentbsall,TestP) 1;
set PropertyUse(ObligatoryQuantifierGroup,TestP) 0;
set PropertyUse(SelfishNoCaptureGroup,TestP) 0;
set PropertyUse(SelfishNoCaptureGroupA,TestP) 1;
set PropertyUse(SelfishNoCaptureGroupB,TestP) 1;
set PropertyUse(SelfishNoCaptureGroupC,TestP) 1;
set PropertyUse(taggedgroup,TestP) 1;
set PropertyUse(taggedgroupsq,TestP) 1;
set PropertyUse(taggedgroupref,TestP) 0;
set PropertyUse(groupcomp,TestP) 1;
set PropertyUse(dot,TestP) 1;
set PropertyUse(UnderscoreAnySingle,TestP) 1;
set PropertyUse(XAnySingle,TestP) 1;
set PropertyUse(DotAnySingle,TestP) 1;
set PropertyUse(SingleOctet,TestP) 1;
set PropertyUse(RAnySinglePurineBase,TestP) 1;
set PropertyUse(YAnySinglePyramidineBase,TestP) 1;
set PropertyUse(SBaseGC,TestP) 1;
set PropertyUse(WBaseAT,TestP) 1;
set PropertyUse(MBaseAC,TestP) 1;
set PropertyUse(KBaseGT,TestP) 1;
set PropertyUse(VBaseACG,TestP) 1;
set PropertyUse(HBaseACT,TestP) 1;
set PropertyUse(DBaseAGT,TestP) 1;
set PropertyUse(BBaseCGT,TestP) 1;
set PropertyUse(NAnySingleNucleotide,TestP) 1;
set PropertyUse(JResidueHydrophobic,TestP) 1;
set PropertyUse(OResidueHydrophilic,TestP) 1;
set PropertyUse(BResidueDN,TestP) 1;
set PropertyUse(ZResidueEQ,TestP) 1;
set PropertyUse(repmax,TestP) 1;
set PropertyUse(repmaxlbs,TestP) 1;
set PropertyUse(StarPrev,TestP) 1;
set PropertyUse(ZeroOrMoreCurly,TestP) 1;
set PropertyUse(CrosshatchPrev,TestP) 1;
set PropertyUse(DoubleCrosshatchPrev,TestP) 1;
set PropertyUse(StarNext,TestP) 1;
set PropertyUse(starclass,TestP) 1;
set PropertyUse(SubReluctantStarPrevDollar,TestP) 1;
set PropertyUse(SubReluctantStarPrevBackslash,TestP) 1;
set PropertyUse(SubHyphenClass,TestP) 1;
set PropertyUse(SubNewline,TestP) 1;
set PropertyUse(StarAny,TestP) 1;
set PropertyUse(PercentAny,TestP) 1;
set PropertyUse(plusprev,TestP) 1;
set PropertyUse(plusnext,TestP) 1;
set PropertyUse(plusprevbs,TestP) 1;
set PropertyUse(plusclass,TestP) 1;
set PropertyUse(SubReluctantPlusPrevDollar,TestP) 1;
set PropertyUse(SubReluctantPlusPrevBackslash,TestP) 1;
set PropertyUse(plusany,TestP) 1;
set PropertyUse(crosshatchany,TestP) 1;
set PropertyUse(atsignonenext,TestP) 1;
set PropertyUse(qmopt,TestP) 1;
set PropertyUse(qmoptnext,TestP) 1;
set PropertyUse(qmoptclass,TestP) 1;
set PropertyUse(qmoptbs,TestP) 1;
set PropertyUse(EqualOptbs,TestP) 1;
set PropertyUse(qmoptdbsnqq,TestP) 1;
set PropertyUse(qm1,TestP) 1;
set PropertyUse(qm1bs,TestP) 1;
set PropertyUse(SubReluctantQuestionMarkPrevDollar,TestP) 1;
set PropertyUse(SubReluctantQuestionMarkPrevBackslash,TestP) 1;
set PropertyUse(commaor,TestP) 1;
set PropertyUse(semiand,TestP) 1;
set PropertyUse(ampandbs,TestP) 1;
set PropertyUse(NegativeCircumflex,TestP) 1;
set PropertyUse(MatchNotMatchTilde,TestP) 1;
set PropertyUse(W3CharClassSubtraction,TestP) 1;
set PropertyUse(caret,TestP) 1;
set PropertyUse(PercentCaretBS,TestP) 1;
set PropertyUse(PercentDollarBS,TestP) 1;
set PropertyUse(pabegin,TestP) 1;
set PropertyUse(pabegindb,TestP) 1;
set PropertyUse(boslq,TestP) 1;
set PropertyUse(dollar,TestP) 1;
set PropertyUse(GreaterThanEnd,TestP) 1;
set PropertyUse(LessThanBeginning,TestP) 1;
set PropertyUse(LiteralMetachar,TestP) 1;
set PropertyUse(AbsoluteEndOfString,TestP) 1;
set PropertyUse(pzendbs,TestP) 1;
set PropertyUse(pzenddbs,TestP) 1;
set PropertyUse(pZendbs,TestP) 1;
set PropertyUse(pZenddbs,TestP) 1
set PropertyUse(eosrq,TestP) 1;;
set PropertyUse(langle,TestP) 1;
set PropertyUse(rangle,TestP) 1;
set PropertyUse(BeginWordm,TestP) 1;
set PropertyUse(EndWordM,TestP) 1;
set PropertyUse(LangleClass,TestP) 1;
set PropertyUse(RangleClass,TestP) 1;
set PropertyUse(WordBoundary,TestP) 1;
set PropertyUse(WordBoundaryBs,TestP) 1;
set PropertyUse(WordBoundaryybs,TestP) 1;
set PropertyUse(WordBoundaryydbs,TestP) 1;
set PropertyUse(NonWordBoundary,TestP) 1;
set PropertyUse(NonWordBoundaryYbs,TestP) 1;
set PropertyUse(pipe,TestP) 1;
set PropertyUse(pipebs,TestP) 1;
set PropertyUse(pipedbs,TestP) 1;
set PropertyUse(pipebsall,TestP) 1;
set PropertyUse(pipedbsall,TestP) 1;
set PropertyUse(altcomma,TestP) 1;
set PropertyUse(backref,TestP) 1;
set PropertyUse(backrefdbs,TestP) 1;
set PropertyUse(backrefper,TestP) 1;
set PropertyUse(backrefbsall,TestP) 1;
set PropertyUse(backrefdbsall,TestP) 1;
set PropertyUse(backrefAtLeastTen,TestP) 1;
set PropertyUse(backrefdbsAtLeastTen,TestP) 1;
set PropertyUse(backrefperAtLeastTen,TestP) 1;
set PropertyUse(backrefbsallAtLeastTen,TestP) 1;
set PropertyUse(backrefdbsallAtLeastTen,TestP) 1;
set PropertyUse(backrefksh,TestP) 1;
set PropertyUse(backrefkshAtLeastTen,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallIOctal,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallIHex,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchOctal,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchHex,TestP) 1;
set PropertyUse(CaseInsensitiveCLFlagBackrefP,TestP) 1;
set PropertyUse(repfixed,TestP) 1;
set PropertyUse(repfixedbs,TestP) 1;
set PropertyUse(repfixeddbs,TestP) 1;
set PropertyUse(repmin,TestP) 1;
set PropertyUse(repminbs,TestP) 1;
set PropertyUse(repmindbs,TestP) 1;
set PropertyUse(reprange,TestP) 1;
set PropertyUse(reprangebs,TestP) 1;
set PropertyUse(reprangelbs,TestP) 1;
set PropertyUse(reprangedbs,TestP) 1;
set PropertyUse(SubReluctantIntegerRangeDollar,TestP) 1;
set PropertyUse(SubReluctantIntegerRangeBackslash,TestP) 1;
set PropertyUse(ReluctantIntegerRangeVIMBackslash,TestP) 1;
set PropertyUse(ReluctantAtLeastMVIMBackslash,TestP) 1;
set PropertyUse(ReluctantAtMostNVIMBackslash,TestP) 1;
set PropertyUse(ReluctantExactlyMVIMBackslash,TestP) 1;
set PropertyUse(SubReluctantZeroOrMoreVIMBackslash,TestP) 1;
set PropertyUse(set,TestP) 1;
set PropertyUse(setcomp,TestP) 1;
set PropertyUse(setcomptilde,TestP) 1;
set PropertyUse(setcompbang,TestP) 1;
set PropertyUse(range,TestP) 1;
set PropertyUse(multirange,TestP) 1;
set PropertyUse(IntegerRange,TestP) 1;
set PropertyUse(IntegerRangeDoubleDot,TestP) 1;
set PropertyUse(IntegerMultiple,TestP) 1;
set PropertyUse(IntegerFactor,TestP) 1;
set PropertyUse(IntegerAlternative,TestP) 1;
set PropertyUse(baldlim,TestP) 1;
set PropertyUse(bsw,TestP) 1;
set PropertyUse(alnum,TestP) 1;
set PropertyUse(alnumrebol,TestP) 1;
set PropertyUse(pbsw,TestP) 1;
set PropertyUse(pbbsw,TestP) 1;
set PropertyUse(lalnumc,TestP) 1;
set PropertyUse(lalnum,TestP) 1;
set PropertyUse(bsW,TestP) 1;
set PropertyUse(bsWdb,TestP) 1;
set PropertyUse(pbsW,TestP) 1;
set PropertyUse(alpha,TestP) 1;
set PropertyUse(alpharebol,TestP) 1;
set PropertyUse(lalpha,TestP) 1;
set PropertyUse(lalphac,TestP) 1;
set PropertyUse(upper,TestP) 1;
set PropertyUse(upperrebol,TestP) 1;
set PropertyUse(lupper,TestP) 1;
set PropertyUse(lupperc,TestP) 1;
set PropertyUse(lower,TestP) 1;
set PropertyUse(lowerrebol,TestP) 1;
set PropertyUse(llower,TestP) 1;
set PropertyUse(llowerc,TestP) 1;
set PropertyUse(punct,TestP) 1;
set PropertyUse(lpunct,TestP) 1;
set PropertyUse(lpunctc,TestP) 1;
set PropertyUse(space,TestP) 1;
set PropertyUse(lspace,TestP) 1;
set PropertyUse(pspace,TestP) 1;
set PropertyUse(pspacedb,TestP) 1;
set PropertyUse(lspacec,TestP) 1;
set PropertyUse(pspacec,TestP) 1;
set PropertyUse(pspacedbc,TestP) 1;
set PropertyUse(W3Space,TestP) 1;
set PropertyUse(W3Spacec,TestP) 1;
set PropertyUse(blank,TestP) 1;
set PropertyUse(graph,TestP) 1;
set PropertyUse(print,TestP) 1;
set PropertyUse(mockprint,TestP) 1;
set PropertyUse(perlprint,TestP) 1;
set PropertyUse(cntrl,TestP) 1;
set PropertyUse(lcntrl,TestP) 1;
set PropertyUse(lcntrlc,TestP) 1;
set PropertyUse(digit,TestP) 1;
set PropertyUse(digitrebol,TestP) 1;
set PropertyUse(ldigit,TestP) 1;
set PropertyUse(pdigit,TestP) 1;
set PropertyUse(xmldigit,TestP) 1;
set PropertyUse(pdigitdb,TestP) 1;
set PropertyUse(ldigitc,TestP) 1;
set PropertyUse(pdigitc,TestP) 1;
set PropertyUse(xmldigitc,TestP) 1;
set PropertyUse(pdigitdbc,TestP) 1;
set PropertyUse(xdigit,TestP) 1;
set PropertyUse(xdigitrebol,TestP) 1;
set PropertyUse(lxdigit,TestP) 1;
set PropertyUse(lxdigitc,TestP) 1;
set PropertyUse(wordclass,TestP) 1;
set PropertyUse(compposixclassinner,TestP) 1;
set PropertyUse(compposixclassouter,TestP) 1;
set PropertyUse(octal,TestP) 1;
set PropertyUse(octalo,TestP) 1;
set PropertyUse(octaldb,TestP) 1;
set PropertyUse(decimald,TestP) 1;
set PropertyUse(hexl,TestP) 1;
set PropertyUse(hexldb,TestP) 1;
set PropertyUse(hexu,TestP) 1;
set PropertyUse(hexudb,TestP) 1;
set PropertyUse(HexWideCharCurly,TestP) 1;
set PropertyUse(HTMLHexReference,TestP) 1;
set PropertyUse(HTMLDecimalReference,TestP) 1;
set PropertyUse(AlphaBSa,TestP) 1;
set PropertyUse(AlphaBSAc,TestP) 1;
set PropertyUse(UpperCaseBSu,TestP) 1;
set PropertyUse(UpperCaseBSUc,TestP) 1;
set PropertyUse(LowerCaseBSl,TestP) 1;
set PropertyUse(LowerCaseBSLc,TestP) 1;
set PropertyUse(WordBSw,TestP) 1;
set PropertyUse(WordBSWc,TestP) 1;
set PropertyUse(WordHeadBSh,TestP) 1;
set PropertyUse(WordHeadBSHc,TestP) 1;
set PropertyUse(XMLInitial,TestP) 1;
set PropertyUse(XMLInitialc,TestP) 1;
set PropertyUse(xdigitBSx,TestP) 1;
set PropertyUse(xdigitBSxc,TestP) 1;
set PropertyUse(odigitBSo,TestP) 1;
set PropertyUse(odigitBSOc,TestP) 1;
set PropertyUse(bell,TestP) 1;
set PropertyUse(belldb,TestP) 1;
set PropertyUse(backspace,TestP) 1;
set PropertyUse(escape,TestP) 1;
set PropertyUse(escapedb,TestP) 1;
set PropertyUse(cr,TestP) 1;
set PropertyUse(crdb,TestP) 1;
set PropertyUse(tab,TestP) 1;
set PropertyUse(tabdb,TestP) 1;
set PropertyUse(TabClass,TestP) 1;
set PropertyUse(EscapeClass,TestP) 1;
set PropertyUse(BackspaceClass,TestP) 1;
set PropertyUse(controlc,TestP) 1;
set PropertyUse(controlcdb,TestP) 1;
set PropertyUse(some,TestP) 1;
set PropertyUse(any,TestP) 1;
set PropertyUse(rangerebol,TestP) 1;
set PropertyUse(piperebol,TestP) 1;
set PropertyUse(comment,TestP) 1;
set PropertyUse(QuoteFollowingMetacharsQDot,TestP) 1;
set PropertyUse(QuoteFollowingMetacharsMDot,TestP) 1;
set PropertyUse(ShiftBackToMagicDot,TestP) 1;
set PropertyUse(TerminateMetacharQuotingDot,TestP) 1;
set PropertyUse(CaseSensitiveFlag,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallI,TestP) 0;
set PropertyUse(CaseInsensitiveBSSmallC,TestP) 0;
set PropertyUse(CaseSensitiveBSBigC,TestP) 1;
set PropertyUse(flagCrosshatchICaseSensitive,TestP) 1;
set PropertyUse(flagCrosshatchlAsymmetricCaseInsensitive,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatch,TestP) 0;
set PropertyUse(CaseInsensitiveFlagSmallIu,TestP) 0;
set PropertyUse(CaseInsensitiveFlagSmallIAsciiLiteral,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallINonAsciiLiteral,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallIuNonAsciiLiteral,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallIAsciiClass,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallINonAsciiClass,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallIuNonAsciiClass,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallIAsciiClassSymmetric,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallINonAsciiClassSymmetric,TestP) 1;
set PropertyUse(CaseInsensitiveFlagSmallIuNonAsciiClassSymmetric,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchAsciiLiteral,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchNonAsciiLiteral,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchuNonAsciiLiteral,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchAsciiClass,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchNonAsciiClass,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchuNonAsciiClass,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchAsciiClassSymmetric,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchNonAsciiClassSymmetric,TestP) 1;
set PropertyUse(CaseInsensitiveCrosshatchuNonAsciiClassSymmetric,TestP) 1;
set PropertyUse(CaseInsensitiveBSSmallCAsciiLiteral,TestP) 1;
set PropertyUse(CaseInsensitiveBSSmallCNonAsciiLiteral,TestP) 1;
set PropertyUse(CaseInsensitiveBSSmallCAsciiClass,TestP) 1;
set PropertyUse(CaseInsensitiveBSSmallCNonAsciiClass,TestP) 1;
set PropertyUse(CaseInsensitiveBSSmallCAsciiClassSymmetric,TestP) 1;
set PropertyUse(CaseInsensitiveBSSmallCNonAsciiClassSymmetric,TestP) 1;
set PropertyUse(CaseInsensitiveBSSmallCOctal,TestP) 1;
set PropertyUse(CaseInsensitiveBSSmallCHex,TestP) 1;
set PropertyUse(CaseInsensitiveAsciiLiteral,TestP) 0;
set PropertyUse(CaseInsensitiveNonAsciiLiteral,TestP) 0;
set PropertyUse(CaseInsensitiveAsciiClass,TestP) 0;
set PropertyUse(CaseInsensitiveNonAsciiClass,TestP) 0;
set PropertyUse(CaseInsensitiveAsciiClassSymmetric,TestP) 0;
set PropertyUse(CaseInsensitiveNonAsciiClassSymmetric,TestP) 0;
set PropertyUse(CaseInsensitiveOctal,TestP) 0;
set PropertyUse(CaseInsensitiveHex,TestP) 0;
set PropertyUse(flagx,TestP) 1;
set PropertyUse(flagb,TestP) 1;
set PropertyUse(flage,TestP) 1;
set PropertyUse(flagq,TestP) 1;
set PropertyUse(UnsetFlag,TestP) 1;
set PropertyUse(FlagQWideScope,TestP) 1;
set PropertyUse(FlagCrosshatchWideScope,TestP) 1;
set PropertyUse(FlagBSSmallCWideScope,TestP) 1;
set PropertyUse(CaseInsensitiveFlagWideScope,TestP) 0;
set PropertyUse(jLower,TestP) 1;
set PropertyUse(jLowerdb,TestP) 1;
set PropertyUse(jLowerc,TestP) 1;
set PropertyUse(jLowercdb,TestP) 1;
set PropertyUse(jUpper,TestP) 1;
set PropertyUse(jUpperdb,TestP) 1;
set PropertyUse(jUpperc,TestP) 1;
set PropertyUse(jUppercdb,TestP) 1;
set PropertyUse(jAscii,TestP) 1;
set PropertyUse(jAsciidb,TestP) 1;
set PropertyUse(jAsciic,TestP) 1;
set PropertyUse(jAsciicdb,TestP) 1;
set PropertyUse(jAlpha,TestP) 1;
set PropertyUse(jAlphadb,TestP) 1;
set PropertyUse(jAlphac,TestP) 1;
set PropertyUse(jAlphacdb,TestP) 1;
set PropertyUse(jDigit,TestP) 1;
set PropertyUse(jDigitdb,TestP) 1;
set PropertyUse(jDigitc,TestP) 1;
set PropertyUse(jDigitcdb,TestP) 1;
set PropertyUse(jXdigit,TestP) 1;
set PropertyUse(jXdigitdb,TestP) 1;
set PropertyUse(jXdigitc,TestP) 1;
set PropertyUse(jXdigitcdb,TestP) 1;
set PropertyUse(jAlnum,TestP) 1;
set PropertyUse(jAlnumdb,TestP) 1;
set PropertyUse(jAlnumc,TestP) 1;
set PropertyUse(jAlnumcdb,TestP) 1;
set PropertyUse(jPunct,TestP) 1;
set PropertyUse(jPunctdb,TestP) 1;
set PropertyUse(jPunctc,TestP) 1;
set PropertyUse(jPunctcdb,TestP) 1;
set PropertyUse(jGraph,TestP) 1;
set PropertyUse(jGraphdb,TestP) 1;
set PropertyUse(jGraphc,TestP) 1;
set PropertyUse(jGraphcdb,TestP) 1;
set PropertyUse(jPrint,TestP) 1;
set PropertyUse(jPrintdb,TestP) 1;
set PropertyUse(jPrintc,TestP) 1;
set PropertyUse(jPrintcdb,TestP) 1;
set PropertyUse(jBlank,TestP) 1;
set PropertyUse(jBlankdb,TestP) 1;
set PropertyUse(jBlankc,TestP) 1;
set PropertyUse(jBlankcdb,TestP) 1;
set PropertyUse(jSpace,TestP) 1;
set PropertyUse(jSpacedb,TestP) 1;
set PropertyUse(jSpacec,TestP) 1;
set PropertyUse(jSpacecdb,TestP) 1;
set PropertyUse(jCntrl,TestP) 1;
set PropertyUse(jCntrldb,TestP) 1;
set PropertyUse(jCntrlc,TestP) 1;
set PropertyUse(jCntrlcdb,TestP) 1;
set PropertyUse(uname,TestP) 1;
set PropertyUse(unamedb,TestP) 1;
set PropertyUse(jUBlockIn,TestP) 1;
set PropertyUse(jUBlockInc,TestP) 1;
set PropertyUse(jUBlockIs,TestP) 1;
set PropertyUse(jUBlockIsc,TestP) 1;
set PropertyUse(jUBlockBare,TestP) 1;
set PropertyUse(jUBlockBarec,TestP) 1;
set PropertyUse(jUCat,TestP) 1;
set PropertyUse(jUCatc,TestP) 1;
set PropertyUse(jUCatIn,TestP) 1;
set PropertyUse(jUCatcIn,TestP) 1;
set PropertyUse(jUCatIs,TestP) 1;
set PropertyUse(jUCatcIs,TestP) 1;
set PropertyUse(jUBlockIndb,TestP) 1;
set PropertyUse(jUBlockIncdb,TestP) 1;
set PropertyUse(jUBlockIsdb,TestP) 1;
set PropertyUse(jUBlockIscdb,TestP) 1;
set PropertyUse(jUBlockBaredb,TestP) 1;
set PropertyUse(jUBlockBarecdb,TestP) 1;
set PropertyUse(jUCatdb,TestP) 1;
set PropertyUse(jUCatcdb,TestP) 1;
set PropertyUse(jUCatdbIn,TestP) 1;
set PropertyUse(jUCatcdbIn,TestP) 1;
set PropertyUse(jUCatdbIs,TestP) 1;
set PropertyUse(jUCatcdbIs,TestP) 1;
set PropertyUse(jUnion,TestP) 1;
set PropertyUse(jInter,TestP) 1;
set PropertyUse(plookahead,TestP) 1;
set PropertyUse(plookaheadAtSign,TestP) 1;
set PropertyUse(plookback,TestP) 1;
set PropertyUse(plookbackAtSign,TestP) 1;
set PropertyUse(nlookahead,TestP) 1;
set PropertyUse(nlookaheadAtSign,TestP) 1;
set PropertyUse(nlookback,TestP) 1;
set PropertyUse(nlookbackAtSign,TestP) 1;
set PropertyUse(CondGroupSimple,TestP) 1;
set PropertyUse(CondGroupElse,TestP) 1;
set PropertyUse(CondLookaroundSimple,TestP) 1;
set PropertyUse(CondLookaroundElse,TestP) 1;
set PropertyUse(ColumnSpecifier,TestP) 1;
set PropertyUse(PreColumnSpecifier,TestP) 1;
set PropertyUse(PostColumnSpecifier,TestP) 1;
set PropertyUse(SubBackRefBare,TestP) 1;
set PropertyUse(SubBackRefBareAtLeastTen,TestP) 1;
set PropertyUse(SubEntBackRefZero,TestP) 1;
set PropertyUse(SubBackReferenceDol,TestP) 1;
set PropertyUse(SubBackReferenceDolAtLeastTen,TestP) 1;
set PropertyUse(SubBackReferenceDolZero,TestP) 1;
set PropertyUse(SubBackReferencePercent,TestP) 1;
set PropertyUse(SubBackReferencePercentAtLeastTen,TestP) 1;
set PropertyUse(SubBackReferencePercentZero,TestP) 1;
set PropertyUse(SubBackRefbs,TestP) 1;
set PropertyUse(SubBackRefParbs,TestP) 1;
set PropertyUse(SubBackRefbsAtLeastTen,TestP) 1;
set PropertyUse(SubBackRefParbsAtLeastTen,TestP) 1;
set PropertyUse(SubBackRefbsZero,TestP) 1;
set PropertyUse(SubBackRefParbsZero,TestP) 1;
set PropertyUse(SubBackRefdbs,TestP) 1;
set PropertyUse(SubBackRefdbsAtLeastTen,TestP) 1;
set PropertyUse(SubBackRefdbsZero,TestP) 1;
set PropertyUse(SubBackRefPardbsdbs,TestP) 1;
set PropertyUse(SubBackRefPardbsdbsAtLeastTen,TestP) 1;
set PropertyUse(SubBackRefPardbsdbsZero,TestP) 1;
set PropertyUse(Subampentbackrefs,TestP) 1;
set PropertyUse(Subampentbackrefsdbs,TestP) 1;
set PropertyUse(SubampentbackrefsPardbsdbs,TestP) 1;
set PropertyUse(SubDolAmpEntBackRef,TestP) 1;
set PropertyUse(SubPreMatch,TestP) 1;
set PropertyUse(SubPreMatchDol,TestP) 1;
set PropertyUse(SubPostMatch,TestP) 1;
set PropertyUse(SubPostMatchDol,TestP) 1;
set PropertyUse(SubLastCapture,TestP) 1;
set PropertyUse(SubLastCaptureDol,TestP) 1;
set PropertyUse(SubPreMatchLit,TestP) 1;
set PropertyUse(SubPostMatchLit,TestP) 1;
set PropertyUse(SubRange,TestP) 1;
set PropertyUse(SubAlnum,TestP) 1;
set PropertyUse(SubAlpha,TestP) 1;
set PropertyUse(SubBlank,TestP) 1;
set PropertyUse(SubCntrl,TestP) 1;
set PropertyUse(SubDigit,TestP) 1;
set PropertyUse(SubGraph,TestP) 1;
set PropertyUse(SubLower,TestP) 1;
set PropertyUse(SubPrint,TestP) 1;
set PropertyUse(SubPunct,TestP) 1;
set PropertyUse(SubSpace,TestP) 1;
set PropertyUse(SubUpper,TestP) 1;
set PropertyUse(SubXdigit,TestP) 1;
set PropertyUse(SubCStarN,TestP) 1;
set PropertyUse(SubCStar,TestP) 1;
set PropertyUse(SubLitString,TestP) 1;
set PropertyUse(SubDowncaseChar,TestP) 1;
set PropertyUse(SubUpcaseChar,TestP) 1;
set PropertyUse(SubDowncaseString,TestP) 1;
set PropertyUse(SubUpcaseString,TestP) 1;
set PropertyUse(SubEndCaseDomaine,TestP) 1;
set PropertyUse(SubEndCaseDomainE,TestP) 1;
set PropertyUse(SubDowncaseCharDollar,TestP) 1;
set PropertyUse(SubUpcaseCharDollar,TestP) 1;
set PropertyUse(SubDowncaseStringDollar,TestP) 1;
set PropertyUse(SubUpcaseStringDollar,TestP) 1;
set PropertyUse(SubEndCaseDomaineDollar,TestP) 1;
set PropertyUse(SubEndCaseDomainEDollar,TestP) 1;
set PropertyUse(ExactMatchWD,TestP) 1;
set PropertyUse(ExactMatchTRE,TestP) 1;
set PropertyUse(ExactMatchCgrep,TestP) 1;
set PropertyUse(TRECostSetting,TestP) 1;
set PropertyUse(TotalErrorCrosshatchA,TestP) 1;
set PropertyUse(PossStar,TestP) 0;
set PropertyUse(PossPlus,TestP) 0;
set PropertyUse(PossQMark,TestP) 0;
set PropertyUse(PossAtLeastM,TestP) 0;
set PropertyUse(PossMToN,TestP) 0;
set PropertyUse(CondPosLookaheadSimple,TestP) 0;
set PropertyUse(CondPosLookaheadElse,TestP) 0;
set PropertyUse(CondNegLookaheadSimple,TestP) 0;
set PropertyUse(CondNegLookaheadElse,TestP) 0;
set PropertyUse(CondPosLookbackSimple,TestP) 0;
set PropertyUse(CondPosLookbackElse,TestP) 0;
set PropertyUse(CondNegLookbackSimple,TestP) 0;
set PropertyUse(CondNegLookbackElse,TestP) 0;
set PropertyUse(embedding,TestP) 1;
set PropertyUse(EmbeddingMatchOnly,TestP) 1;
set PropertyUse(embeddingLeft,TestP) 1;
set PropertyUse(embeddingRight,TestP) 1;
set PropertyUse(unicodebmp,TestP) 1;
set PropertyUse(unicodefull,TestP) 1;
set PropertyUse(PossQMarkA,TestP) 1;
set PropertyUse(PossQMarkB,TestP) 1;
set PropertyUse(PossStarA,TestP) 1;
set PropertyUse(PossStarB,TestP) 1;
set PropertyUse(PossPlusA,TestP) 1;
set PropertyUse(PossPlusB,TestP) 1;
set PropertyUse(PossAtLeastMA,TestP) 1;
set PropertyUse(PossAtLeastMB,TestP) 1;
set PropertyUse(PossMToNA,TestP) 1;
set PropertyUse(PossMToNB,TestP) 1;
set PropertyUse(PossMToNC,TestP) 1; 
set PropertyUse(CollationClass,TestP) 1; 
set PropertyUse(CollatingElementMultichar,TestP) 1; 
set PropertyUse(CollatingElementNamed,TestP) 1; 
#set PropertyUse(ReluctantStar,TestP) 1;
#set PropertyUse(GreedyDoubleStar,TestP) 1;
set PropertyUse(RegionDoubleDot,TestP)  0;# Debug
set PropertyUse(CposRange,TestP)  1;
set PropertyUse(IgnoreCombiningCharactersBSZ,TestP)  1;
set PropertyUse(Range128,TestP) 1;
set PropertyUse(Range129,TestP) 1;
set PropertyUse(CrossUnicodeBlockP,TestP) 1;

set PropertyUse(tested,PaletteP) 0;
set PropertyUse(BooleanAnd,PaletteP) 1;
set PropertyUse(group,PaletteP) 1;
set PropertyUse(GroupNoWildcards,PaletteP) 1;
set PropertyUse(groupbs,PaletteP) 1;
set PropertyUse(groupdbsnqq,PaletteP) 1;
set PropertyUse(ObligatoryQuantifierGroup,PaletteP) 1;
set PropertyUse(groupdbs,PaletteP) 1;
set PropertyUse(ncgroup,PaletteP) 1;
set PropertyUse(NoCaptureGroupPercentbsall,PaletteP) 1;
set PropertyUse(ncgroupdb,PaletteP) 1;
set PropertyUse(SelfishNoCaptureGroup,PaletteP) 1;
set PropertyUse(SelfishNoCaptureGroupA,PaletteP) 0;
set PropertyUse(SelfishNoCaptureGroupB,PaletteP) 0;
set PropertyUse(SelfishNoCaptureGroupC,PaletteP) 0;
set PropertyUse(taggedgroup,PaletteP) 1;
set PropertyUse(taggedgroupsq,PaletteP) 1;
set PropertyUse(taggedgroupref,PaletteP) 1;
set PropertyUse(groupcomp,PaletteP) 1;
set PropertyUse(dot,PaletteP) 1;
set PropertyUse(UnderscoreAnySingle,PaletteP) 1;
set PropertyUse(XAnySingle,PaletteP) 1;
set PropertyUse(DotAnySingle,PaletteP) 1;
set PropertyUse(SingleOctet,PaletteP) 1;
set PropertyUse(repmax,PaletteP) 1;
set PropertyUse(repmaxlbs,PaletteP) 1;
set PropertyUse(RAnySinglePurineBase,PaletteP) 1;
set PropertyUse(YAnySinglePyramidineBase,PaletteP) 1;
set PropertyUse(SBaseGC,PaletteP) 1;
set PropertyUse(WBaseAT,PaletteP) 1;
set PropertyUse(MBaseAC,PaletteP) 1;
set PropertyUse(KBaseGT,PaletteP) 1;
set PropertyUse(VBaseACG,PaletteP) 1;
set PropertyUse(HBaseACT,PaletteP) 1;
set PropertyUse(DBaseAGT,PaletteP) 1;
set PropertyUse(BBaseCGT,PaletteP) 1;
set PropertyUse(JResidueHydrophobic,PaletteP) 1;
set PropertyUse(OResidueHydrophilic,PaletteP) 1;
set PropertyUse(BResidueDN,PaletteP) 1;
set PropertyUse(ZResidueEQ,PaletteP) 1;
set PropertyUse(NAnySingleNucleotide,PaletteP) 1;
set PropertyUse(StarPrev,PaletteP) 1;
set PropertyUse(ZeroOrMoreCurly,PaletteP) 1;
set PropertyUse(CrosshatchPrev,PaletteP) 1;
set PropertyUse(DoubleCrosshatchPrev,PaletteP) 1;
set PropertyUse(StarNext,PaletteP) 1;
set PropertyUse(starclass,PaletteP) 1;
set PropertyUse(SubReluctantStarPrevDollar,PaletteP) 1;
set PropertyUse(SubReluctantStarPrevBackslash,PaletteP) 1;
set PropertyUse(SubHyphenClass,PaletteP) 1;
set PropertyUse(SubNewline,PaletteP) 1;
set PropertyUse(StarAny,PaletteP) 1;
set PropertyUse(PercentAny,PaletteP) 1;
set PropertyUse(plusprev,PaletteP) 1;
set PropertyUse(plusnext,PaletteP) 1;
set PropertyUse(plusprevbs,PaletteP) 1;
set PropertyUse(plusclass,PaletteP) 1;
set PropertyUse(SubReluctantPlusPrevDollar,PaletteP) 1;
set PropertyUse(SubReluctantPlusPrevBackslash,PaletteP) 1;
set PropertyUse(plusany,PaletteP) 1;
set PropertyUse(crosshatchany,PaletteP) 1;
set PropertyUse(atsignonenext,PaletteP) 1;
set PropertyUse(qmopt,PaletteP) 1;
set PropertyUse(qmoptnext,PaletteP) 1;
set PropertyUse(qmoptclass,PaletteP) 1;
set PropertyUse(qmoptbs,PaletteP) 1;
set PropertyUse(qmoptdbsnqq,PaletteP) 1;
set PropertyUse(qm1,PaletteP) 1;
set PropertyUse(qm1bs,PaletteP) 1;
set PropertyUse(EqualOptbs,PaletteP) 1;
set PropertyUse(SubReluctantQuestionMarkPrevDollar,PaletteP) 1;
set PropertyUse(SubReluctantQuestionMarkPrevBackslash,PaletteP) 1;
set PropertyUse(commaor,PaletteP) 1;
set PropertyUse(semiand,PaletteP) 1;
set PropertyUse(ampandbs,PaletteP) 1;
set PropertyUse(caret,PaletteP) 1;
set PropertyUse(PercentCaretBS,PaletteP) 1;
set PropertyUse(PercentDollarBS,PaletteP) 1;
set PropertyUse(NegativeCircumflex,PaletteP) 1;
set PropertyUse(MatchNotMatchTilde,PaletteP) 1;
set PropertyUse(W3CharClassSubtraction,PaletteP) 1;
set PropertyUse(pabegin,PaletteP) 1;
set PropertyUse(pabegindb,PaletteP) 1;
set PropertyUse(boslq,PaletteP) 1;
set PropertyUse(dollar,PaletteP) 1;
set PropertyUse(GreaterThanEnd,PaletteP) 1;
set PropertyUse(LessThanBeginning,PaletteP) 1;
set PropertyUse(LiteralMetachar,PaletteP) 1;
set PropertyUse(AbsoluteEndOfString,PaletteP) 0;
set PropertyUse(pzendbs,PaletteP) 1;
set PropertyUse(pzenddbs,PaletteP) 1;
set PropertyUse(pZendbs,PaletteP) 1;
set PropertyUse(pZenddbs,PaletteP) 1;
set PropertyUse(eosrq,PaletteP) 1;
set PropertyUse(langle,PaletteP) 1;
set PropertyUse(rangle,PaletteP) 1;
set PropertyUse(BeginWordm,PaletteP) 1;
set PropertyUse(EndWordM,PaletteP) 1;
set PropertyUse(LangleClass,PaletteP) 1;
set PropertyUse(RangleClass,PaletteP) 1;
set PropertyUse(WordBoundary,PaletteP) 1;
set PropertyUse(WordBoundaryybs,PaletteP) 1;
set PropertyUse(WordBoundaryydbs,PaletteP) 1;
set PropertyUse(WordBoundaryBs,PaletteP) 1;
set PropertyUse(NonWordBoundary,PaletteP) 1;
set PropertyUse(NonWordBoundaryYbs,PaletteP) 1;
set PropertyUse(pipe,PaletteP) 1;
set PropertyUse(pipebs,PaletteP) 1;
set PropertyUse(pipedbs,PaletteP) 1;
set PropertyUse(pipebsall,PaletteP) 1;
set PropertyUse(pipedbsall,PaletteP) 1;
set PropertyUse(altcomma,PaletteP) 1;
set PropertyUse(backref,PaletteP) 1;
set PropertyUse(backrefdbs,PaletteP) 1;
set PropertyUse(backrefper,PaletteP) 1;
set PropertyUse(backrefbsall,PaletteP) 1;
set PropertyUse(backrefdbsall,PaletteP) 1;
set PropertyUse(repfixed,PaletteP) 1;
set PropertyUse(backrefAtLeastTen,PaletteP) 0;
set PropertyUse(backrefdbsAtLeastTen,PaletteP) 0;
set PropertyUse(backrefperAtLeastTen,PaletteP) 0;
set PropertyUse(backrefbsallAtLeastTen,PaletteP) 0;
set PropertyUse(backrefdbsallAtLeastTen,PaletteP) 0;
set PropertyUse(backrefksh,PaletteP) 1;
set PropertyUse(backrefkshAtLeastTen,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagSmallIOctal,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagSmallIHex,PaletteP) 0;
set PropertyUse(CaseInsensitiveCLFlagBackrefP,PaletteP) 0;
set PropertyUse(repfixedbs,PaletteP) 1;
set PropertyUse(repfixeddbs,PaletteP) 1;
set PropertyUse(repmin,PaletteP) 1;
set PropertyUse(repminbs,PaletteP) 1;
set PropertyUse(repmindbs,PaletteP) 1;
set PropertyUse(reprange,PaletteP) 1;
set PropertyUse(reprangebs,PaletteP) 1;
set PropertyUse(reprangelbs,PaletteP) 1;
set PropertyUse(reprangedbs,PaletteP) 1;
set PropertyUse(SubReluctantIntegerRangeDollar,PaletteP) 1;
set PropertyUse(SubReluctantIntegerRangeBackslash,PaletteP) 1;
set PropertyUse(ReluctantIntegerRangeVIMBackslash,PaletteP) 1;
set PropertyUse(ReluctantAtLeastMVIMBackslash,PaletteP) 1;
set PropertyUse(ReluctantAtMostNVIMBackslash,PaletteP) 1;
set PropertyUse(ReluctantExactlyMVIMBackslash,PaletteP) 1;
set PropertyUse(SubReluctantZeroOrMoreVIMBackslash,PaletteP) 1;
set PropertyUse(set,PaletteP) 1;
set PropertyUse(setcomp,PaletteP) 1;
set PropertyUse(setcomptilde,PaletteP) 1;
set PropertyUse(setcompbang,PaletteP) 1;
set PropertyUse(range,PaletteP) 1;
set PropertyUse(multirange,PaletteP) 1;
set PropertyUse(IntegerRange,PaletteP) 1;
set PropertyUse(IntegerRangeDoubleDot,PaletteP) 1;
set PropertyUse(IntegerMultiple,PaletteP) 1;
set PropertyUse(IntegerFactor,PaletteP) 1;
set PropertyUse(IntegerAlternative,PaletteP) 1;
set PropertyUse(baldlim,PaletteP) 1;
set PropertyUse(bsw,PaletteP) 1;
set PropertyUse(alnum,PaletteP) 1;
set PropertyUse(alnumrebol,PaletteP) 1;
set PropertyUse(pbsw,PaletteP) 1;
set PropertyUse(pbbsw,PaletteP) 1;
set PropertyUse(lalnumc,PaletteP) 1;
set PropertyUse(lalnum,PaletteP) 1;
set PropertyUse(bsW,PaletteP) 1;
set PropertyUse(bsWdb,PaletteP) 1;
set PropertyUse(pbsW,PaletteP) 1;
set PropertyUse(alpha,PaletteP) 1;
set PropertyUse(alpharebol,PaletteP) 1;
set PropertyUse(lalpha,PaletteP) 1;
set PropertyUse(lalphac,PaletteP) 1;
set PropertyUse(upper,PaletteP) 1;
set PropertyUse(upperrebol,PaletteP) 1;
set PropertyUse(lupper,PaletteP) 1;
set PropertyUse(lupperc,PaletteP) 1;
set PropertyUse(lower,PaletteP) 1;
set PropertyUse(lowerrebol,PaletteP) 1;
set PropertyUse(llower,PaletteP) 1;
set PropertyUse(llowerc,PaletteP) 1;
set PropertyUse(punct,PaletteP) 1;
set PropertyUse(lpunct,PaletteP) 1;
set PropertyUse(lpunctc,PaletteP) 1;
set PropertyUse(space,PaletteP) 1;
set PropertyUse(lspace,PaletteP) 1;
set PropertyUse(pspace,PaletteP) 1;
set PropertyUse(pspacedb,PaletteP) 1;
set PropertyUse(lspacec,PaletteP) 1;
set PropertyUse(pspacec,PaletteP) 1;
set PropertyUse(pspacedbc,PaletteP) 1;
set PropertyUse(W3Space,PaletteP) 1;
set PropertyUse(W3Spacec,PaletteP) 1;
set PropertyUse(blank,PaletteP) 1;
set PropertyUse(graph,PaletteP) 1;
set PropertyUse(print,PaletteP) 1;
set PropertyUse(mockprint,PaletteP) 1;
set PropertyUse(perlprint,PaletteP) 1;
set PropertyUse(cntrl,PaletteP) 1;
set PropertyUse(lcntrl,PaletteP) 1;
set PropertyUse(lcntrlc,PaletteP) 1;
set PropertyUse(digit,PaletteP) 1;
set PropertyUse(digitrebol,PaletteP) 1;
set PropertyUse(ldigit,PaletteP) 1;
set PropertyUse(pdigit,PaletteP) 1;
set PropertyUse(xmldigit,PaletteP) 1;
set PropertyUse(pdigitdb,PaletteP) 1;
set PropertyUse(ldigitc,PaletteP) 1;
set PropertyUse(pdigitc,PaletteP) 1;
set PropertyUse(xmldigitc,PaletteP) 1;
set PropertyUse(pdigitdbc,PaletteP) 1;
set PropertyUse(xdigit,PaletteP) 1;
set PropertyUse(xdigitrebol,PaletteP) 1;
set PropertyUse(lxdigit,PaletteP) 1;
set PropertyUse(lxdigitc,PaletteP) 1;
set PropertyUse(wordclass,PaletteP) 1;
set PropertyUse(compposixclassinner,PaletteP) 1;
set PropertyUse(compposixclassouter,PaletteP) 1;
set PropertyUse(octal,PaletteP) 1;
set PropertyUse(octalo,PaletteP) 1;
set PropertyUse(decimald,PaletteP) 1;
set PropertyUse(octaldb,PaletteP) 1;
set PropertyUse(hexl,PaletteP) 1;
set PropertyUse(hexldb,PaletteP) 1;
set PropertyUse(hexu,PaletteP) 1;
set PropertyUse(hexudb,PaletteP) 1;
set PropertyUse(HexWideCharCurly,PaletteP) 1;
set PropertyUse(HTMLHexReference,PaletteP) 1;
set PropertyUse(HTMLDecimalReference,PaletteP) 1;
set PropertyUse(AlphaBSa,PaletteP) 1;
set PropertyUse(AlphaBSAc,PaletteP) 1;
set PropertyUse(UpperCaseBSu,PaletteP) 1;
set PropertyUse(UpperCaseBSUc,PaletteP) 1;
set PropertyUse(LowerCaseBSl,PaletteP) 1;
set PropertyUse(LowerCaseBSLc,PaletteP) 1;
set PropertyUse(WordBSw,PaletteP) 1;
set PropertyUse(WordBSWc,PaletteP) 1;
set PropertyUse(WordHeadBSh,PaletteP) 1;
set PropertyUse(WordHeadBSHc,PaletteP) 1
set PropertyUse(XMLInitial,PaletteP) 1;
set PropertyUse(XMLInitialc,PaletteP) 1;
set PropertyUse(xdigitBSx,PaletteP) 1;
set PropertyUse(xdigitBSxc,PaletteP) 1;
set PropertyUse(odigitBSo,PaletteP) 1;
set PropertyUse(odigitBSOc,PaletteP) 1;
set PropertyUse(bell,PaletteP) 1;
set PropertyUse(belldb,PaletteP) 1;
set PropertyUse(backspace,PaletteP) 1;
set PropertyUse(escape,PaletteP) 1;
set PropertyUse(escapedb,PaletteP) 1;
set PropertyUse(cr,PaletteP) 1;
set PropertyUse(crdb,PaletteP) 1;
set PropertyUse(tab,PaletteP) 1;
set PropertyUse(tabdb,PaletteP) 1;
set PropertyUse(TabClass,PaletteP) 1;
set PropertyUse(EscapeClass,PaletteP) 1;
set PropertyUse(BackspaceClass,PaletteP) 1;
set PropertyUse(controlc,PaletteP) 1;
set PropertyUse(controlcdb,PaletteP) 1;
set PropertyUse(some,PaletteP) 1;
set PropertyUse(any,PaletteP) 1;
set PropertyUse(rangerebol,PaletteP) 1;
set PropertyUse(piperebol,PaletteP) 1;
set PropertyUse(comment,PaletteP) 1;
set PropertyUse(QuoteFollowingMetacharsQDot,PaletteP) 1;
set PropertyUse(QuoteFollowingMetacharsMDot,PaletteP) 1;
set PropertyUse(ShiftBackToMagicDot,PaletteP) 1;
set PropertyUse(TerminateMetacharQuotingDot,PaletteP) 1;
set PropertyUse(CaseSensitiveFlag,PaletteP) 1;
set PropertyUse(CaseInsensitiveFlagSmallI,PaletteP) 1;
set PropertyUse(CaseInsensitiveBSSmallC,PaletteP) 1;
set PropertyUse(CaseSensitiveBSBigC,PaletteP) 1;
set PropertyUse(flagCrosshatchlAsymmetricCaseInsensitive,PaletteP) 1;
set PropertyUse(flagCrosshatchICaseSensitive,PaletteP) 1;
set PropertyUse(CaseInsensitiveCrosshatch,PaletteP) 1;
set PropertyUse(CaseInsensitiveFlagSmallIu,PaletteP) 1;
set PropertyUse(CaseInsensitiveFlagSmallIAsciiLiteral,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagSmallINonAsciiLiteral,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagSmallIuNonAsciiLiteral,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagSmallIAsciiClass,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagSmallINonAsciiClass,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagSmallIuNonAsciiClass,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagSmallIAsciiClassSymmetric,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagSmallINonAsciiClassSymmetric,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagSmallIuNonAsciiClassSymmetric,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchAsciiLiteral,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchNonAsciiLiteral,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchuNonAsciiLiteral,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchAsciiClass,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchNonAsciiClass,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchuNonAsciiClass,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchAsciiClassSymmetric,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchNonAsciiClassSymmetric,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchuNonAsciiClassSymmetric,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchOctal,PaletteP) 0;
set PropertyUse(CaseInsensitiveCrosshatchHex,PaletteP) 0;
set PropertyUse(CaseInsensitiveBSSmallCAsciiLiteral,PaletteP) 0;
set PropertyUse(CaseInsensitiveBSSmallCNonAsciiLiteral,PaletteP) 0;
set PropertyUse(CaseInsensitiveBSSmallCAsciiClass,PaletteP) 0;
set PropertyUse(CaseInsensitiveBSSmallCNonAsciiClass,PaletteP) 0;
set PropertyUse(CaseInsensitiveBSSmallCAsciiClassSymmetric,PaletteP) 0;
set PropertyUse(CaseInsensitiveBSSmallCNonAsciiClassSymmetric,PaletteP) 0;
set PropertyUse(CaseInsensitiveBSSmallCOctal,PaletteP) 0;
set PropertyUse(CaseInsensitiveBSSmallCHex,PaletteP) 0;
set PropertyUse(CaseInsensitiveAsciiLiteral,PaletteP) 0;
set PropertyUse(CaseInsensitiveNonAsciiLiteral,PaletteP) 0;
set PropertyUse(CaseInsensitiveAsciiClass,PaletteP) 0;
set PropertyUse(CaseInsensitiveNonAsciiClass,PaletteP) 0;
set PropertyUse(CaseInsensitiveAsciiClassSymmetric,PaletteP) 0;
set PropertyUse(CaseInsensitiveNonAsciiClassSymmetric,PaletteP) 0;
set PropertyUse(CaseInsensitiveOctal,PaletteP) 0;
set PropertyUse(CaseInsensitiveHex,PaletteP) 0;
set PropertyUse(flagx,PaletteP) 1;
set PropertyUse(flagb,PaletteP) 1;
set PropertyUse(flage,PaletteP) 1;
set PropertyUse(flagq,PaletteP) 1;
set PropertyUse(UnsetFlag,PaletteP) 1;
set PropertyUse(FlagQWideScope,PaletteP) 0;
set PropertyUse(FlagCrosshatchWideScope,PaletteP) 0;
set PropertyUse(FlagBSSmallCWideScope,PaletteP) 0;
set PropertyUse(CaseInsensitiveFlagWideScope,PaletteP) 0;
set PropertyUse(jLower,PaletteP) 1;
set PropertyUse(jLowerdb,PaletteP) 1;
set PropertyUse(jLowerc,PaletteP) 1;
set PropertyUse(jLowercdb,PaletteP) 1;
set PropertyUse(jUpper,PaletteP) 1;
set PropertyUse(jUpperdb,PaletteP) 1;
set PropertyUse(jUpperc,PaletteP) 1;
set PropertyUse(jUppercdb,PaletteP) 1;
set PropertyUse(jAscii,PaletteP) 1;
set PropertyUse(jAsciidb,PaletteP) 1;
set PropertyUse(jAsciic,PaletteP) 1;
set PropertyUse(jAsciicdb,PaletteP) 1;
set PropertyUse(jAlpha,PaletteP) 1;
set PropertyUse(jAlphadb,PaletteP) 1;
set PropertyUse(jAlphac,PaletteP) 1;
set PropertyUse(jAlphacdb,PaletteP) 1;
set PropertyUse(jDigit,PaletteP) 1;
set PropertyUse(jDigitdb,PaletteP) 1;
set PropertyUse(jDigitc,PaletteP) 1;
set PropertyUse(jDigitcdb,PaletteP) 1;
set PropertyUse(jXdigit,PaletteP) 1;
set PropertyUse(jXdigitdb,PaletteP) 1;
set PropertyUse(jXdigitc,PaletteP) 1;
set PropertyUse(jXdigitcdb,PaletteP) 1;
set PropertyUse(jAlnum,PaletteP) 1;
set PropertyUse(jAlnumdb,PaletteP) 1;
set PropertyUse(jAlnumc,PaletteP) 1;
set PropertyUse(jAlnumcdb,PaletteP) 1;
set PropertyUse(jPunct,PaletteP) 1;
set PropertyUse(jPunctdb,PaletteP) 1;
set PropertyUse(jPunctc,PaletteP) 1;
set PropertyUse(jPunctcdb,PaletteP) 1;
set PropertyUse(jGraph,PaletteP) 1;
set PropertyUse(jGraphdb,PaletteP) 1;
set PropertyUse(jGraphc,PaletteP) 1;
set PropertyUse(jGraphcdb,PaletteP) 1;
set PropertyUse(jPrint,PaletteP) 1;
set PropertyUse(jPrintdb,PaletteP) 1;
set PropertyUse(jPrintc,PaletteP) 1;
set PropertyUse(jPrintcdb,PaletteP) 1;
set PropertyUse(jBlank,PaletteP) 1;
set PropertyUse(jBlankdb,PaletteP) 1;
set PropertyUse(jBlankc,PaletteP) 1;
set PropertyUse(jBlankcdb,PaletteP) 1;
set PropertyUse(jSpace,PaletteP) 1;
set PropertyUse(jSpacedb,PaletteP) 1;
set PropertyUse(jSpacec,PaletteP) 1;
set PropertyUse(jSpacecdb,PaletteP) 1;
set PropertyUse(jCntrl,PaletteP) 1;
set PropertyUse(jCntrldb,PaletteP) 1;
set PropertyUse(jCntrlc,PaletteP) 1;
set PropertyUse(jCntrlcdb,PaletteP) 1;
set PropertyUse(uname,PaletteP) 1;
set PropertyUse(unamedb,PaletteP) 1;
set PropertyUse(jUBlockIn,PaletteP) 1;
set PropertyUse(jUBlockInc,PaletteP) 1;
set PropertyUse(jUBlockIs,PaletteP) 1;
set PropertyUse(jUBlockIsc,PaletteP) 1;
set PropertyUse(jUBlockBare,PaletteP) 1;
set PropertyUse(jUBlockBarec,PaletteP) 1;
set PropertyUse(jUCat,PaletteP) 1;
set PropertyUse(jUCatc,PaletteP) 1;
set PropertyUse(jUCatIn,PaletteP) 1;
set PropertyUse(jUCatcIn,PaletteP) 1;
set PropertyUse(jUCatIs,PaletteP) 1;
set PropertyUse(jUCatcIs,PaletteP) 1;
set PropertyUse(jUBlockIndb,PaletteP) 1;
set PropertyUse(jUBlockIncdb,PaletteP) 1;
set PropertyUse(jUBlockIsdb,PaletteP) 1;
set PropertyUse(jUBlockIscdb,PaletteP) 1;
set PropertyUse(jUBlockBaredb,PaletteP) 1;
set PropertyUse(jUBlockBarecdb,PaletteP) 1;
set PropertyUse(jUCatdb,PaletteP) 1;
set PropertyUse(jUCatcdb,PaletteP) 1;
set PropertyUse(jUCatdbIn,PaletteP) 1;
set PropertyUse(jUCatcdbIn,PaletteP) 1;
set PropertyUse(jUCatdbIs,PaletteP) 1;
set PropertyUse(jUCatcdbIs,PaletteP) 1;
set PropertyUse(jUnion,PaletteP) 1;
set PropertyUse(jInter,PaletteP) 1;
set PropertyUse(plookahead,PaletteP) 1;
set PropertyUse(plookaheadAtSign,PaletteP) 1;
set PropertyUse(plookback,PaletteP) 1;
set PropertyUse(plookbackAtSign,PaletteP) 1;
set PropertyUse(nlookahead,PaletteP) 1;
set PropertyUse(nlookaheadAtSign,PaletteP) 1;
set PropertyUse(nlookback,PaletteP) 1;
set PropertyUse(nlookbackAtSign,PaletteP) 1;
set PropertyUse(CondGroupSimple,PaletteP) 1;
set PropertyUse(CondGroupElse,PaletteP) 1;
set PropertyUse(CondLookaroundSimple,PaletteP) 0;
set PropertyUse(CondLookaroundElse,PaletteP) 0;
set PropertyUse(ColumnSpecifier,PaletteP) 1;
set PropertyUse(PreColumnSpecifier,PaletteP) 1;
set PropertyUse(PostColumnSpecifier,PaletteP) 1;
set PropertyUse(SubBackRefBare,PaletteP) 1;
set PropertyUse(SubBackRefBareAtLeastTen,PaletteP) 0;
set PropertyUse(SubBackReferenceDol,PaletteP) 1;
set PropertyUse(SubBackReferenceDolAtLeastTen,PaletteP) 0;
set PropertyUse(SubBackReferenceDolZero,PaletteP) 1;
set PropertyUse(SubBackReferencePercent,PaletteP) 1;
set PropertyUse(SubBackReferencePercentAtLeastTen,PaletteP) 0;
set PropertyUse(SubBackReferencePercentZero,PaletteP) 1;
set PropertyUse(SubBackRefbs,PaletteP) 1;
set PropertyUse(SubBackRefParbs,PaletteP) 1;
set PropertyUse(SubBackRefbsAtLeastTen,PaletteP) 0;
set PropertyUse(SubBackRefParbsAtLeastTen,PaletteP) 0;
set PropertyUse(SubBackRefbsZero,PaletteP) 1;
set PropertyUse(SubBackRefParbsZero,PaletteP) 1;
set PropertyUse(SubBackRefdbs,PaletteP) 1;
set PropertyUse(SubBackRefdbsAtLeastTen,PaletteP) 0;
set PropertyUse(SubBackRefdbsZero,PaletteP) 1;
set PropertyUse(SubBackRefPardbsdbs,PaletteP) 1;
set PropertyUse(SubBackRefPardbsdbsAtLeastTen,PaletteP) 0;
set PropertyUse(SubBackRefPardbsdbsZero,PaletteP) 1;
set PropertyUse(SubEntBackRefZero,PaletteP) 1;
set PropertyUse(Subampentbackrefs,PaletteP) 1;
set PropertyUse(Subampentbackrefsdbs,PaletteP) 1;
set PropertyUse(SubampentbackrefsPardbsdbs,PaletteP) 1;
set PropertyUse(SubDolAmpEntBackRef,PaletteP) 1;
set PropertyUse(SubPreMatch,PaletteP) 1;
set PropertyUse(SubPreMatchDol,PaletteP) 1;
set PropertyUse(SubPostMatch,PaletteP) 1;
set PropertyUse(SubPostMatchDol,PaletteP) 1;
set PropertyUse(SubLastCapture,PaletteP) 1;
set PropertyUse(SubLastCaptureDol,PaletteP) 1;
set PropertyUse(SubPreMatchLit,PaletteP) 1;
set PropertyUse(SubPostMatchLit,PaletteP) 1;
set PropertyUse(SubRange,PaletteP) 1;
set PropertyUse(SubAlnum,PaletteP) 1;
set PropertyUse(SubAlpha,PaletteP) 1;
set PropertyUse(SubBlank,PaletteP) 1;
set PropertyUse(SubCntrl,PaletteP) 1;
set PropertyUse(SubDigit,PaletteP) 1;
set PropertyUse(SubGraph,PaletteP) 1;
set PropertyUse(SubLower,PaletteP) 1;
set PropertyUse(SubPrint,PaletteP) 1;
set PropertyUse(SubPunct,PaletteP) 1;
set PropertyUse(SubSpace,PaletteP) 1;
set PropertyUse(SubUpper,PaletteP) 1;
set PropertyUse(SubXdigit,PaletteP) 1;
set PropertyUse(SubCStarN,PaletteP) 1;
set PropertyUse(SubCStar,PaletteP) 1;
set PropertyUse(SubLitString,PaletteP) 1;
set PropertyUse(SubDowncaseChar,PaletteP) 1;
set PropertyUse(SubUpcaseChar,PaletteP) 1;
set PropertyUse(SubDowncaseString,PaletteP) 1;
set PropertyUse(SubUpcaseString,PaletteP) 1;
set PropertyUse(SubEndCaseDomaine,PaletteP) 1;
set PropertyUse(SubEndCaseDomainE,PaletteP) 1;
set PropertyUse(SubDowncaseCharDollar,PaletteP) 1;
set PropertyUse(SubUpcaseCharDollar,PaletteP) 1;
set PropertyUse(SubDowncaseStringDollar,PaletteP) 1;
set PropertyUse(SubUpcaseStringDollar,PaletteP) 1;
set PropertyUse(SubEndCaseDomaineDollar,PaletteP) 1;
set PropertyUse(SubEndCaseDomainEDollar,PaletteP) 1;
set PropertyUse(ExactMatchWD,PaletteP) 1;
set PropertyUse(ExactMatchTRE,PaletteP) 1;
set PropertyUse(ExactMatchCgrep,PaletteP) 1;
set PropertyUse(TRECostSetting,PaletteP) 1;
set PropertyUse(TotalErrorCrosshatchA,PaletteP) 1;
set PropertyUse(PossStar,PaletteP) 1;
set PropertyUse(PossPlus,PaletteP) 1;
set PropertyUse(PossQMark,PaletteP) 1;
set PropertyUse(PossAtLeastM,PaletteP) 1;
set PropertyUse(PossMToN,PaletteP) 1;
set PropertyUse(CondPosLookaheadSimple,PaletteP) 1;
set PropertyUse(CondPosLookaheadElse,PaletteP) 1;
set PropertyUse(CondNegLookaheadSimple,PaletteP) 1;
set PropertyUse(CondNegLookaheadElse,PaletteP) 1;
set PropertyUse(CondPosLookbackSimple,PaletteP) 1;
set PropertyUse(CondPosLookbackElse,PaletteP) 1;
set PropertyUse(CondNegLookbackSimple,PaletteP) 1;
set PropertyUse(CondNegLookbackElse,PaletteP) 1;
set PropertyUse(embedding,PaletteP) 0;
set PropertyUse(EmbeddingMatchOnly,PaletteP) 0;
set PropertyUse(embeddingLeft,PaletteP) 0;
set PropertyUse(embeddingRight,PaletteP) 0;
set PropertyUse(unicodebmp,PaletteP) 0;
set PropertyUse(unicodefull,PaletteP) 0;
set PropertyUse(PossQMarkA,PaletteP) 0;
set PropertyUse(PossQMarkB,PaletteP) 0;
set PropertyUse(PossStarA,PaletteP) 0;
set PropertyUse(PossStarB,PaletteP) 0;
set PropertyUse(PossPlusA,PaletteP) 0;
set PropertyUse(PossPlusB,PaletteP) 0;
set PropertyUse(PossAtLeastMA,PaletteP) 0;
set PropertyUse(PossAtLeastMB,PaletteP) 0;
set PropertyUse(PossMToNA,PaletteP) 0;
set PropertyUse(PossMToNB,PaletteP) 0;
set PropertyUse(PossMToNC,PaletteP) 0;
set PropertyUse(CollationClass,PaletteP) 1; 
set PropertyUse(CollatingElementMultichar,PaletteP) 1; 
set PropertyUse(CollatingElementNamed,PaletteP) 1; 
#set PropertyUse(ReluctantStar,PaletteP) 1;
#set PropertyUse(GreedyDoubleStar,PaletteP) 1;
set PropertyUse(RegionDoubleDot,PaletteP)  0;# Debug
set PropertyUse(CposRange,PaletteP)  1;
set PropertyUse(IgnoreCombiningCharactersBSZ,PaletteP)  1;
set PropertyUse(Range128,PaletteP) 0;
set PropertyUse(Range129,PaletteP) 0;
set PropertyUse(CrossUnicodeBlockP,PaletteP) 0;

#Certain tests hang certain programs so we have to skip them.
#Here we list the combinations to be skipped.
set ProgramTestSkipList(emacs,Range128) 1;
set ProgramTestSkipList(emacs,Range129) 1;
set ProgramTestSkipList(emacs,PossQMarkA) 1;
set ProgramTestSkipList(emacs,PossQMarkB) 1;
set ProgramTestSkipList(emacs,PossStarA) 1;
set ProgramTestSkipList(emacs,PossStarB) 1;
set ProgramTestSkipList(emacs,PossPlusA) 1;
set ProgramTestSkipList(emacs,PossPlusB) 1;
set ProgramTestSkipList(emacs,PossAtLeastMA) 1;
set ProgramTestSkipList(emacs,PossAtLeastMB) 1;
set ProgramTestSkipList(emacs,PossMToNA) 1;
set ProgramTestSkipList(emacs,PossMToNB) 1;
set ProgramTestSkipList(emacs,PossMToNC) 1;
set ProgramTestSkipList(mawk,PossQMarkA) 1;
set ProgramTestSkipList(mawk,PossQMarkB) 1;
set ProgramTestSkipList(mawk,PossStarA) 1;
set ProgramTestSkipList(mawk,PossStarB) 1;
set ProgramTestSkipList(mawk,PossPlusA) 1;
set ProgramTestSkipList(mawk,PossPlusB) 1;
set ProgramTestSkipList(mawk,PossAtLeastMA) 1;
set ProgramTestSkipList(mawk,PossAtLeastMB) 1;
set ProgramTestSkipList(mawk,PossMToNA) 1;
set ProgramTestSkipList(mawk,PossMToNB) 1;
set ProgramTestSkipList(mawk,PossMToNC) 1;
set ProgramTestSkipList(numgrep,range) 1;
set ProgramTestSkipList(python,SubBackRefbsAtLeastTen) 1;

#These are for debugging flex. They can likely be eliminated eventually.
set ProgramTestSkipList(flex,jUBlockIn) 1;
set ProgramTestSkipList(flex,jUBlockInc) 1;
set ProgramTestSkipList(flex,jUBlockIs) 1;
set ProgramTestSkipList(flex,jUBlockIsc) 1;
set ProgramTestSkipList(flex,jUBlockBare) 1;
set ProgramTestSkipList(flex,jUBlockBarec) 1;
set ProgramTestSkipList(flex,jUCat) 1;
set ProgramTestSkipList(flex,jUCatc) 1;
set ProgramTestSkipList(flex,jUCatIn) 1;
set ProgramTestSkipList(flex,jUCatcIn) 1;
set ProgramTestSkipList(flex,jUCatIs) 1;
set ProgramTestSkipList(flex,jUCatcIs) 1;
set ProgramTestSkipList(flex,jUBlockIndb) 1;
set ProgramTestSkipList(flex,jUBlockIncdb) 1;
set ProgramTestSkipList(flex,jUBlockIsdb) 1;
set ProgramTestSkipList(flex,jUBlockIscdb) 1;
set ProgramTestSkipList(flex,jUBlockBaredb) 1;
set ProgramTestSkipList(flex,jUBlockBarecdb) 1;
set ProgramTestSkipList(flex,jUCatdb) 1;
set ProgramTestSkipList(flex,jUCatcdb) 1;
set ProgramTestSkipList(flex,jUCatdbIn) 1;
set ProgramTestSkipList(flex,jUCatcdbIn) 1;
set ProgramTestSkipList(flex,jUCatdbIs) 1;
set ProgramTestSkipList(flex,jUCatcdbIs) 1;


#Here begin the palette entries
#We need this to be a procedure so that we can reset the glosses when we change locale.
proc SetPalette {} {
    global Palette

    set Palette(BooleanAnd,gloss)   [_ "and"]
    set Palette(BooleanAnd,re)  	[list {{-a 0 } F} {{X Y} V}]
    set Palette(BooleanAnd,link)	[list BooleanAnd]

    set Palette(dot,gloss)         [_ "any single character"]
    set Palette(dot,re)    	[list {. F}]
    set Palette(dot,link)    [list Dot]

    set Palette(SingleOctet,gloss)         [_ "a single octet"]
    set Palette(SingleOctet,re)    	[list {\\C F}]
    set Palette(SingleOctet,link)    [list SingleOctet]

    set Palette(XAnySingle,gloss)         [_ "any single nucleodtide or residue"]
    set Palette(XAnySingle,re)    	[list {X F}]
    set Palette(XAnySingle,link)    [list XAnySingle]

    set Palette(DotAnySingle,gloss)         [_ "any single nucleotide or residue"]
    set Palette(DotAnySingle,re)    	[list {. F}]
    set Palette(DotAnySingle,link)    [list DotAnySingle]

    set Palette(NAnySingleNucleotide,gloss)         [_ "any single nucleotide"]
    set Palette(NAnySingleNucleotide,re)    	[list {N F}]
    set Palette(NAnySingleNucleotide,link)    [list NAnySingleNucleotide]

    set Palette(RAnySinglePurineBase,gloss)         [_ "any single purine base (A or G)"]
    set Palette(RAnySinglePurineBase,re)    	[list {R F}]
    set Palette(RAnySinglePurineBase,link)    [list RAnySinglePurineBase]

    set Palette(YAnySinglePyramidineBase,gloss)         [_ "any single pyramidine base (C or T)"]
    set Palette(YAnySinglePyramidineBase,re)    	[list {Y F}]
    set Palette(YAnySinglePyramidineBase,link)    [list YAnySinglePyramidineBase]

    set Palette(SBaseGC,gloss)         [_ "either Guanine or Cytosine"]
    set Palette(SBaseGC,re)    	[list {S F}]
    set Palette(SBaseGC,link)    [list SBaseGC]

    set Palette(WBaseAT,gloss)   [_ "either Adenine or Tyrosine"]
    set Palette(WBaseAT,re)      [list {W F}]
    set Palette(WBaseAT,link)    [list WBaseAT]

    set Palette(MBaseAC,gloss)   [_ "either Adenine or Cytosine"]
    set Palette(MBaseAC,re)      [list {M F}]
    set Palette(MBaseAC,link)    [list MBaseAC]

    set Palette(KBaseGT,gloss)   [_ "either Guanine or Tyrosine"]
    set Palette(KBaseGT,re)      [list {K F}]
    set Palette(KBaseGT,link)    [list KBaseGT]

    set Palette(VBaseACG,gloss)   [_ "one of Adenine, Cytosine or Guanine"]
    set Palette(VBaseACG,re)      [list {V F}]
    set Palette(VBaseACG,link)    [list VBaseACG]

    set Palette(HBaseACT,gloss)   [_ "one of Adenine, Cytosine or Tyrosine"]
    set Palette(HBaseACT,re)      [list {H F}]
    set Palette(HBaseACT,link)    [list HBaseACT]

    set Palette(DBaseAGT,gloss)   [_ "one of Adenine, Guanine or Tyrosine"]
    set Palette(DBaseAGT,re)      [list {D F}]
    set Palette(DBaseAGT,link)    [list DBaseAGT]

    set Palette(BBaseCGT,gloss)   [_ "one of Cytosine, Guanine or Tyrosine"]
    set Palette(BBaseCGT,re)      [list {B F}]
    set Palette(BBaseCGT,link)    [list BBaseCGT]

    set Palette(BResidueDN,gloss)   [_ "either Asparagine (N) or Aspartate (D)"]
    set Palette(BResidueDN,re)      [list {B F}]
    set Palette(BResidueDN,link)    [list BResidueDN]

    set Palette(ZResidueEQ,gloss)   [_ "either Glutamate (E) or Glutamine (Q)"]
    set Palette(ZResidueEQ,re)      [list {Z F}]
    set Palette(ZResidueEQ,link)    [list ZResidueEQ]

    set Palette(JResidueHydrophobic,gloss) [_ "any hydrophobic residue (ACFGILMVWY)"]
    set Palette(JResidueHydrophobic,re) [list {J F}]
    set Palette(JResidueHydrophobic,link) [list JResidueHydrophobic]

    set Palette(OResidueHydrophilic,gloss) [_ "any hydrophilic residue (DEHKNQRST)"]
    set Palette(OResidueHydrophilic,re) [list {O F}]
    set Palette(OResidueHydrophilic,link) [list OResidueHydrophilic]

    set Palette(UnderscoreAnySingle,gloss)  [_ "any single character"]
    set Palette(UnderscoreAnySingle,re)    	[list {_ F}]
    set Palette(UnderscoreAnySingle,link)   [list UnderscoreAnySingle]

    set Palette(StarPrev,gloss)    [_ "0 or more of preceding"]
    set Palette(StarPrev,re)	[list {* F} ]
    set Palette(StarPrev,link)  	[list Star]

    set Palette(CrosshatchPrev,gloss)  [_ "0 or more of preceding"]
    set Palette(CrosshatchPrev,re)	[list {\# F}]
    set Palette(CrosshatchPrev,link)  	[list CrosshatchPrev]

    set Palette(DoubleCrosshatchPrev,gloss)  [_ "1 or more of preceding"]
    set Palette(DoubleCrosshatchPrev,re)	[list {\#\# F}]
    set Palette(DoubleCrosshatchPrev,link)  	[list DoubleCrosshatchPrev]

    set Palette(StarNext,gloss)    [_ "0 or more of the parenthesized group"]
    set Palette(StarNext,re)	[list {*( F} {abc V} {) F}]
    set Palette(StarNext,link)  	[list StarNext]

    set Palette(starclass,gloss)    [_ "0 or more of preceding class"]
    set Palette(starclass,re)	[list {* F}]
    set Palette(starclass,link)  	[list StarClass]

    set Palette(PossStar,gloss)    [_ "0 or more of preceding (selfish)"]
    set Palette(PossStar,re)    [list {*+ F}]
    set Palette(PossStar,link)   [list SelfishQuantifier Star]

    set Palette(SubReluctantStarPrevDollar,gloss)  [_ "0 or more of preceding (reluctant)"]
    set Palette(SubReluctantStarPrevDollar,re)    [list {*? F}]
    set Palette(SubReluctantStarPrevDollar,link)   [list ReluctantQuantifier Star]

    set Palette(SubReluctantStarPrevBackslash,gloss)  [_ "0 or more of preceding (reluctant)"]
    set Palette(SubReluctantStarPrevBackslash,re)	[list {*? F}]
    set Palette(SubReluctantStarPrevBackslash,link)   [list ReluctantQuantifier Star]

    set Palette(SubHyphenClass,gloss)  [_ "0 or more of preceding class (reluctant)"]
    set Palette(SubHyphenClass,re)     [list {- F}];
    set Palette(SubHyphenClass,link)     [list HyphenClass ReluctantQuantifier]

    set Palette(any,gloss)         [_ {0 or more of following character or block}]
    set Palette(any,re)          [list {{any "} F}  {a V} {{"} F}]
    set Palette(any,link)          [list Any]

    set Palette(StarAny,gloss)     [_ "0 or more of any character"]
    set Palette(StarAny,re)	  [list {* F}]
    set Palette(StarAny,link)	  [list StarAny]

    set Palette(PercentAny,gloss)     [_ "0 or more of any character"]
    set Palette(PercentAny,re)	  [list {% F}]
    set Palette(PercentAny,link)	  [list PercentAny]

    set Palette(plusprev,gloss)   [_ "1 or more of preceding"]
    set Palette(plusprev,re)    [list {+ F}];
    set Palette(plusprev,link)    [list Plus]

    set Palette(plusprevbs,gloss)   [_ "1 or more of preceding"]
    set Palette(plusprevbs,re)    [list {\\+ F}];
    set Palette(plusprevbs,link)    [list Plus]

    set Palette(plusclass,gloss)   [_ "1 or more of preceding class"]
    set Palette(plusclass,re)    [list {+ F}];
    set Palette(plusclass,link)    [list PlusClass]

    set Palette(PossPlus,gloss)   [_ "1 or more of preceding (selfish)"]
    set Palette(PossPlus,re)   			   [list {++ F}];
    set Palette(PossPlus,link)   	[list Plus SelfishQuantifier]

    set Palette(plusnext,gloss)    [_ "1 or more of the parenthesized group"]
    set Palette(plusnext,re)	[list {+( F} {abc V} {) F}]
    set Palette(plusnext,link)  	[list PlusNext]

    set Palette(atsignonenext,gloss)    [_ "one of the alternatives in the parenthesized group"]
    set Palette(atsignonenext,re)	[list {@( F} {ab V} {| F} {cd V} {) F}]
    set Palette(atsignonenext,link)  [list AtSignOneNext]

    set Palette(SubReluctantPlusPrevDollar,gloss)   [_ "1 or more of preceding (reluctant)"]
    set Palette(SubReluctantPlusPrevDollar,re)	   [list {+? F}];
    set Palette(SubReluctantPlusPrevDollar,link)	   [list Plus ReluctantQuantifier]

    set Palette(SubReluctantPlusPrevBackslash,gloss)  [_ "1 or more of preceding (reluctant)"]
    set Palette(SubReluctantPlusPrevBackslash,re)    [list {+? F}];
    set Palette(SubReluctantPlusPrevBackslash,link)    [list Plus ReluctantQuantifier]

    set Palette(some,gloss)        [_ {1 or more of following character or block}]
    set Palette(some,re)         [list {{some "} F}  {a V} {{"} F}]

    set Palette(plusany,gloss)     [_ "1 or more of any character"]
    set Palette(plusany,re)     [list {+ F}];
    set Palette(plusany,link)     [list PlusAny]

    set Palette(crosshatchany,gloss)  [_ {1 or more of preceding character}]
    set Palette(crosshatchany,re)     [list {\# F}];
    set Palette(crosshatchany,link)     [list CrosshatchAny]

    set Palette(qmopt,gloss)       [_ "0 or 1 of preceding"];
    set Palette(qmopt,re)       [list {? F}];;
    set Palette(qmopt,link)       [list ZeroOneQMark]

    set Palette(qmoptclass,gloss)       [_ "0 or 1 of preceding class"];
    set Palette(qmoptclass,re)       [list {? F}];;
    set Palette(qmoptclass,link)       [list ZeroOneQMarkClass]

    set Palette(qmoptnext,gloss)       [_ "0 or 1 of the parenthesized group"];
    set Palette(qmoptnext,re)       [list {?( F} {ab V} {) F}];
    set Palette(qmoptnext,link)       [list ZeroOneQMarkNext]

    set Palette(PossQMark,gloss)   [_ "0 or 1 of preceding (selfish)"]
    set Palette(PossQMark,re)   [list {?+ F}];
    set Palette(PossQMark,link)   [list ZeroOneQMark SelfishQuantifier]

    set Palette(SubReluctantQuestionMarkPrevDollar,gloss)       [_ "0 or 1 of preceding (reluctant)"]
    set Palette(SubReluctantQuestionMarkPrevDollar,re)       [list {?? F}];
    set Palette(SubReluctantQuestionMarkPrevDollar,link)       [list ZeroOneQMark ReluctantQuantifier]

    set Palette(SubReluctantQuestionMarkPrevBackslash,gloss)    [_ "0 or 1 of preceding (reluctant)"]
    set Palette(SubReluctantQuestionMarkPrevBackslash,re)       [list {?? F}];
    set Palette(SubReluctantQuestionMarkPrevBackslash,link)    [list ZeroOneQMark ReluctantQuantifier]

    set Palette(qmoptbs,gloss)     [_ "0 or 1 of preceding"]
    set Palette(qmoptbs,re)     [list {{\?} F}];
    set Palette(qmoptbs,link)     [list ZeroOneQMark]

    set Palette(EqualOptbs,gloss)     [_ "0 or 1 of preceding"]
    set Palette(EqualOptbs,re)     [list {{\=} F}];
    set Palette(EqualOptbs,link)     [list ZeroOneEqual]

    set Palette(qmoptdbsnqq,gloss)     [_ "0 or 1 of preceding"]
    set Palette(qmoptdbsnqq,re)     [list {? F}];
    set Palette(qmoptdbsnqq,link)     [list ZeroOneQMark]

    set Palette(qm1,gloss)         [_ "any single character"]
    set Palette(qm1,re)         [list {? F}];
    set Palette(qm1,link)         [list Dot]

    set Palette(qm1bs,gloss)       [_ "any single character"]
    set Palette(qm1bs,re)       [list {{\?} F}];
    set Palette(qm1bs,link)         [list Dot]

    set Palette(commaor,gloss)  [_ {"abc" or "def"}]
    set Palette(commaor,re)     [list {abc V} {, F} {def V}];
    set Palette(commaor,link)     [list OrString]

    set Palette(semiand,gloss)     [_ {"abc" and "def"}];
    set Palette(semiand,re)     [list {abc V} {; F} {def V}];
    set Palette(semiand,link)     [list AndString]

    set Palette(ampandbs,gloss)     [_ {"abc" and "def"}];
    set Palette(ampandbs,re)     [list {abc V} {\\& F} {def V}];
    set Palette(ampandbs,link)     [list AmpersandAnd]

    set Palette(NegativeCircumflex,gloss) [_ "anything that does not match x"]
    set Palette(NegativeCircumflex,re) [list {^( F} {x V} {) F}];
    set Palette(NegativeCircumflex,link)	[list NegativeCircumflex]

    #The expression x~y does not match x, though on a literal reading of the documentation
    #it should. ?~y does match x, as does [[:alnum:]]~y.
    #It looks like the tilde operator means ' match(A) - match(B) such that the 
    #match(B) is a subset of match(A).
    set Palette(MatchNotMatchTilde,gloss) [_ "anything that matches x and does not match y"]
    set Palette(MatchNotMatchTilde,re) [list {x V} {~ F} {y V}];
    set Palette(MatchNotMatchTilde,link)	[list MatchNotMatchTilde]

    set Palette(W3CharClassSubtraction,gloss)  [_ {a character in A and not in B}];
    set Palette(W3CharClassSubtraction,re)       [list {A V} {- F} {\[B\] V}];
    set Palette(W3CharClassSubtraction,link)  [list W3CharClassSubtraction]

    set Palette(caret,gloss)       [_ {beginning of string}];
    set Palette(caret,re)       [list {^ F}];
    set Palette(caret,link)       [list BeginningOfString]

    set Palette(PercentCaretBS,gloss)       [_ {beginning of file/string}];
    set Palette(PercentCaretBS,re)       [list {\\%^ F}];
    set Palette(PercentCaretBS,link)       [list BeginningOfFile]

    set Palette(PercentDollarBS,gloss)       [_ {end of file/string}];
    set Palette(PercentDollarBS,re)       [list {\\%$ F}];
    set Palette(PercentDollarBS,link)       [list EndOfFile]

    set Palette(pabegin,gloss)     [_ {beginning of string}]
    set Palette(pabegin,re)     [list {\\A F}];
    set Palette(pabegin,link)       [list BeginningOfString]

    set Palette(pabegindb,gloss)   [_ {beginning of string}];
    set Palette(pabegindb,re)   [list {\\A F} ];
    set Palette(pabegindb,link)       [list BeginningOfString]

    set Palette(boslq,gloss)     [_ {beginning of string}]
    set Palette(boslq,re)     [list {\` F}];
    set Palette(boslq,link)       [list BeginningOfString]

    set Palette(dollar,gloss)      [_ "end of string"]
    set Palette(dollar,re)      [list {$ F}];
    set Palette(dollar,link)      [list EndOfString]

    set Palette(GreaterThanEnd,gloss)  [_ "C-terminus/3'-end"]
    set Palette(GreaterThanEnd,re)     [list {> F}];
    set Palette(GreaterThanEnd,link)     [list GreaterThanEnd]

    set Palette(LessThanBeginning,gloss)  [_ "N-terminus/5'-end"]
    set Palette(LessThanBeginning,re)     [list {< F}];
    set Palette(LessThanBeginning,link)     [list LessThanBeginning]

    set Palette(pzendbs,gloss)     [_ "end of string"]
    set Palette(pzendbs,re)     [list {{\z} F}];
    set Palette(pzendbs,link)      [list EndOfString]

    set Palette(pZendbs,gloss)     [_ {end of string}]
    set Palette(pZendbs,re)     [list {\\Z F}];
    set Palette(pZendbs,link)      [list EndOfString]

    set Palette(pzenddbs,gloss)    [_ {end of string}];
    set Palette(pzenddbs,re)    [list {\\z F}];
    set Palette(pzenddbs,link)      [list EndOfString]

    set Palette(pZenddbs,gloss)    [_ {end of string}];
    set Palette(pZenddbs,re)    [list {\\\\Z F}];
    set Palette(pZenddbs,link)      [list EndOfString]

    set Palette(eosrq,gloss)     [_ {end of string}]
    set Palette(eosrq,re)     [list {\' F}];
    set Palette(eosrq,link)       [list EndOfString]

    set Palette(BeginWordm,gloss)      [_ {beginning of word}];
    set Palette(BeginWordm,re)      [list {\\m F}];
    set Palette(BeginWordm,link)      [list BeginningOfWord]

    set Palette(langle,gloss)      [_ {beginning of word}];
    set Palette(langle,re)      [list {\\< F}];
    set Palette(langle,link)      [list BeginningOfWord]

    set Palette(LangleClass,gloss)      [_ {beginning of word}];
    set Palette(LangleClass,re)      [list {[[:<:]] F}];
    set Palette(LangleClass,link)      [list BeginningOfWord]

    set Palette(EndWordM,gloss)      [_ {end of word}];
    set Palette(EndWordM,re)      [list {\\M F}];
    set Palette(EndWordM,link)      [list EndOfWord];

    set Palette(rangle,gloss)      [_ {end of word}];
    set Palette(rangle,re)      [list {\\> F}];
    set Palette(rangle,link)      [list EndOfWord];

    set Palette(RangleClass,gloss)      [_ {end of word}];
    set Palette(RangleClass,re)      [list {[[:>:]] F}];
    set Palette(RangleClass,link)      [list EndOfWord];

    set Palette(WordBoundary,gloss) [_ "word boundary"]
    set Palette(WordBoundary,re) [list {\b F}]
    set Palette(WordBoundary,link) [list WordBoundary]

    set Palette(WordBoundaryybs,gloss) [_ "word boundary"]
    set Palette(WordBoundaryybs,re) [list {\\y F}]
    set Palette(WordBoundaryybs,link) [list WordBoundary]

    set Palette(WordBoundaryydbs,gloss) [_ "word boundary"]
    set Palette(WordBoundaryydbs,re) [list {\\y F}]
    set Palette(WordBoundaryydbs,link) [list WordBoundary]

    set Palette(WordBoundaryBs,gloss) [_ "word boundary"]
    set Palette(WordBoundaryBs,re) [list {\\b F}]
    set Palette(WordBoundaryBs,link) [list WordBoundary]

    set Palette(NonWordBoundary,gloss) [_ "non-word boundary"]
    set Palette(NonWordBoundary,re) [list {\\B F}]
    set Palette(NonWordBoundary,link) [list NonWordBoundary]

    set Palette(NonWordBoundaryYbs,gloss) [_ "non-word boundary"]
    set Palette(NonWordBoundaryYbs,re) [list {\\Y F}]
    set Palette(NonWordBoundaryYbs,link) [list NonWordBoundary]

    set Palette(set,gloss)         [_ "any character in the set"]
    set Palette(set,re)            [list {[ F} {abc V} {] F}]
    set Palette(set,link)            [list Set]

    set Palette(setcomp,gloss)     [_ {any character not in the set}];
    set Palette(setcomp,re)     [list {[^ F} {abc V} {] F}];
    set Palette(setcomp,link)     [list SetComplement]

    set Palette(setcomptilde,gloss)     [_ {any character not in the set}];
    set Palette(setcomptilde,re)     [list {[~ F} {abc V} {] F}];
    set Palette(setcomptilde,link)     [list SetComplement]

    set Palette(setcompbang,gloss)     [_ {any character not in the set}];
    set Palette(setcompbang,re)     [list {[! F} {abc V} {] F}];
    set Palette(setcompbang,link)     [list SetComplement]

    set Palette(range,gloss)       [_ {any character from a through d}];
    set Palette(range,re)       [list {[ F} {a V} {- F} {d V} {] F}];
    set Palette(range,link)       [list Range]

    set Palette(multirange,gloss)       [_ {any character from a through d or w through z} ];
    set Palette(multirange,re)       [list {[ F} {a V} {- F} {d V} {w V} {- F} {z V} {] F}];
    set Palette(multirange,link)       [list MultiRange]

    set Palette(IntegerRange,gloss)       [_ "any integer k such that m \u2264 k \u2264 n"];
    set Palette(IntegerRange,re)       [list {< F} {m V} {- F} {n V} {> F}];
    set Palette(IntegerRange,link)       [list IntegerRange]

    set Palette(IntegerRangeDoubleDot,gloss)       [_ "any integer k such that m \u2264 k \u2264 n"];
    set Palette(IntegerRangeDoubleDot,re)       [list {m V} {.. F} {n V}];
    set Palette(IntegerRangeDoubleDot,link)       [list IntegerRangeDoubleDot]

    set Palette(IntegerMultiple,gloss)       [_ "any integral multiple of p"];
    set Palette(IntegerMultiple,re)       [list {m F} {p V}];
    set Palette(IntegerMultiple,link)       [list IntegerMultiple]

    set Palette(IntegerFactor,gloss)       [_ "any integral factor of p"];
    set Palette(IntegerFactor,re)       [list {f F} {p V}];
    set Palette(IntegerFactor,link)       [list IntegerFactor]

    set Palette(IntegerAlternative,gloss)       [_ "j or k or l"];
    set Palette(IntegerAlternative,re)       [list {j V} {, F} {k V} {, F} {l V}];
    set Palette(IntegerAlternative,link)       [list IntegerAlternative]

    set Palette(group,gloss)       [_ {group}];
    set Palette(group,re)       [list {( F} {abc V} {) F}];
    set Palette(group,link)       [list Group]

    set Palette(GroupNoWildcards,gloss)       [_ {group}];
    set Palette(GroupNoWildcards,re)       [list {( F} {abc V} {) F}];
    set Palette(GroupNoWildcards,link)       [list GroupNoWildcards]

    set Palette(groupbs,gloss)     [_ {group}];
    set Palette(groupbs,re)     [list {\\( F} {abc V} {\\) F}];
    set Palette(groupbs,link)       [list Group]

    set Palette(groupdbsnqq,gloss)     [_ {group}];
    set Palette(groupdbsnqq,re)     [list {\\\\( F} {abc V} {\\\\) F}];
    set Palette(groupdbsnqq,link)       [list Group]

    set Palette(ObligatoryQuantifierGroup,gloss)     [_ {obligatorily quantified group}];
    set Palette(ObligatoryQuantifierGroup,re)     [list {\( F} {abc V} {\) F}];
    set Palette(ObligatoryQuantifierGroup,link)       [list ObligatoryQuantifierGroup]

    set Palette(groupdbs,gloss)    [_ {group}];
    set Palette(groupdbs,re)    [list {\\\\( F} {abc V} {\\\\) F}];
    set Palette(groupdbs,link)       [list Group]

    set Palette(ncgroup,gloss)     [_ {no capture group}];
    set Palette(ncgroup,re)     [list {(?: F} {abc V} {) F}];
    set Palette(ncgroup,link)     [list NoCaptureGroup]

    set Palette(NoCaptureGroupPercentbsall,gloss)     [_ {no capture group}];
    set Palette(NoCaptureGroupPercentbsall,re)     [list {\\%\\( F} {abc V} {\\) F}];
    set Palette(NoCaptureGroupPercentbsall,link)     [list NoCaptureGroup]

    set Palette(ncgroupdb,gloss)   [_ {no capture group}];
    set Palette(ncgroupdb,re)   [list {(?: F} {abc V} {) F} ];
    set Palette(ncgroupdb,link)     [list NoCaptureGroup]

    set Palette(groupcomp,gloss)   [_ {complement of group}];
    set Palette(groupcomp,re)   [list {!( F} {abc V} {) F} ];
    set Palette(groupcomp,link)     [list GroupComplement]

    set Palette(repfixed,gloss)    [_ "n copies of preceding re"];
    set Palette(repfixed,re)    [list {\{ F} {n V} {\} F}];
    set Palette(repfixed,link)    [list NCopies]

    set Palette(repfixedbs,gloss)  [_ "n copies of preceding re"];
    set Palette(repfixedbs,re)  [list {\\\{ F} {n V} {\\\} F}];
    set Palette(repfixedbs,link)  [list NCopies]

    set Palette(repfixeddbs,gloss)  [_ "n copies of preceding re"];
    set Palette(repfixeddbs,re)  [list {\\\\\{ F} {n V} {\\\\\} F}]
    set Palette(repfixeddbs,link)  [list NCopies]

    set Palette(repmin,gloss)      [_ "at least m copies of preceding re"];
    set Palette(repmin,re)      [list {\{ F} {m V} {,\} F}];
    set Palette(repmin,link)      [list MNAtLeast]

    set Palette(repmax,gloss)      [_ "at most n copies of preceding re"];
    set Palette(repmax,re)      [list {\{, F} {n V} {\} F}];
    set Palette(repmax,link)      [list MNAtMost]

    set Palette(repmaxlbs,gloss)      [_ "at most n copies of preceding re"];
    set Palette(repmaxlbs,re)      [list {\\\{, F} {n V} {\} F}];
    set Palette(repmaxlbs,link)      [list MNAtMost]

    set Palette(PossAtLeastM,gloss) [_ "at least n copies of preceding re (selfish)"];
    set Palette(PossAtLeastM,re) [list {\{ F} {n V} {,\}+ F}];
    set Palette(PossAtLeastM,link) [list MNAtLeast SelfishQuantifier]

    set Palette(repminbs,gloss)    [_ "at least n copies of preceding re"];
    set Palette(repminbs,re)    [list {\\\{ F}  {n V}  {,\\\} F} ];
    set Palette(repminbs,link) [list MNAtLeast]

    set Palette(ZeroOrMoreCurly,gloss)    [_ "zero or more copies of preceding re"];
    set Palette(ZeroOrMoreCurly,re)    [list {\\\{ F} {\} F} ];
    set Palette(ZeroOrMoreCurly,link) [list ZeroOrMoreCurly]

    set Palette(repmindbs,gloss)    [_ "at least n copies of preceding re"];
    set Palette(repmindbs,re)    [list {\\\\\{ F}   {n V}  {,\\\\\} F} ];
    set Palette(repmindbs,link) [list MNAtLeast]

    set Palette(reprange,gloss)    [_ {from m to n of preceding re}];
    set Palette(reprange,re)    [list {\{ F} {m V} {, F} {n V} {\} F}];
    set Palette(reprange,link)    [list MNRange]

    set Palette(PossMToN,gloss)    [_ {from m to n of preceding re (selfish)}];
    set Palette(PossMToN,re)    [list {\{ F} {m V} {, F} {n V} {\}+ F}];
    set Palette(PossMToN,link)    [list MNRange SelfishQuantifier]

    set Palette(SubReluctantIntegerRangeDollar,gloss)    [_ {from m to n of preceding re (reluctant)}];
    set Palette(SubReluctantIntegerRangeDollar,re)      [list {\{ F} {m V} {, F} {n V} {\}? F}];
    set Palette(SubReluctantIntegerRangeDollar,link)      [list MNRange ReluctantQuantifier]

    set Palette(SubReluctantIntegerRangeBackslash,gloss)    [_ {from m to n of preceding re (reluctant)}];
    set Palette(SubReluctantIntegerRangeBackslash,re)   [list {\{ F} {m V} {, F} {n V} {\}? F}];
    set Palette(SubReluctantIntegerRangeBackslash,link)      [list MNRange ReluctantQuantifier]

    set Palette(ReluctantIntegerRangeVIMBackslash,gloss)    [_ {from m to n of preceding re (reluctant)}];
    set Palette(ReluctantIntegerRangeVIMBackslash,re)   [list {\\\{- F} {m V} {, F} {n V} {\} F}];
    set Palette(ReluctantIntegerRangeVIMBackslash,link)      [list MNRange ReluctantQuantifier]

    set Palette(ReluctantAtLeastMVIMBackslash,gloss)    [_ {at least m of preceding re (reluctant)}];
    set Palette(ReluctantAtLeastMVIMBackslash,re)   [list {\\\{- F} {m V} {, F} {\} F}];
    set Palette(ReluctantAtLeastMVIMBackslash,link)      [list MNAtLeast ReluctantQuantifier]

    set Palette(ReluctantAtMostNVIMBackslash,gloss)    [_ {at most n of preceding re (reluctant)}];
    set Palette(ReluctantAtMostNVIMBackslash,re)   [list {\\\{- F} {, F} {n V} {\} F}];
    set Palette(ReluctantAtMostNVIMBackslash,link)      [list MNAtMost ReluctantQuantifier]

    set Palette(ReluctantExactlyMVIMBackslash,gloss)    [_ {exactly m of preceding re (reluctant)}];
    set Palette(ReluctantExactlyMVIMBackslash,re)   [list {\\\{- F} {m V} {\} F}];
    set Palette(ReluctantExactlyMVIMBackslash,link)      [list NCopies ReluctantQuantifier]

    set Palette(SubReluctantZeroOrMoreVIMBackslash,gloss)  [_ {zero or more of preceding re (reluctant)}];
    set Palette(SubReluctantZeroOrMoreVIMBackslash,re)   [list {\\\{-\} F}];
    set Palette(SubReluctantZeroOrMoreVIMBackslash,link)  [list ZeroOrMoreCurly ReluctantQuantifier]

    set Palette(reprangebs,gloss)  [_ {from m to n of preceding re}];
    set Palette(reprangebs,re)  [list  {\\\{ F} {m V} {, F} {n V} {\\\} F} ];
    set Palette(reprangebs,link)  [list  MNRange]

    set Palette(reprangelbs,gloss)  [_ {from m to n of preceding re}];
    set Palette(reprangelbs,re)  [list  {\\\{ F} {m V} {, F} {n V} {\} F} ];
    set Palette(reprangelbs,link)  [list  MNRange]

    set Palette(reprangedbs,gloss) [_ {from m to n of preceding re}];
    set Palette(reprangedbs,re)  [list  {\\\\\{ F} {m V} {, F} {n V} {\\\\\} F} ];
    set Palette(reprangedbs,link)  [list  MNRange]

    set Palette(rangerebol,gloss)  [_ {from m to n of following}];
    set Palette(rangerebol,re)  [list {\[ F} {m V} {{ } F} {n V} {\" F} {ab V} {\"\] F}];

    set Palette(pipe,gloss)         [_ {a or b}];
    set Palette(pipe,re)         [list {( F} {a V} {| F} {b V} {) F}];
    set Palette(pipe,link)         [list OrString]

    set Palette(pipebs,gloss)       [_ {a or b}];
    set Palette(pipebs,re)       [list  {( F} {a V} {\\| F} {b V} {) F} ];
    set Palette(pipebs,link)         [list OrString]

    set Palette(pipedbs,gloss)      [_ {a or b}];
    set Palette(pipedbs,re)   [list  {( F} {a V} {\\\\| F} {b V} {) F} ];
    set Palette(pipedbs,link)         [list OrString]

    set Palette(pipebsall,gloss)   [_ {a or b}];
    set Palette(pipebsall,re)   [list  {\\( F} {a V} {\\| F} {b V} {\\) F} ];
    set Palette(pipebsall,link)         [list OrString]

    set Palette(pipedbsall,gloss)   [_ {a or b}];
    set Palette(pipedbsall,re)   [list  {\\\\( F} {a V} {\\\\| F} {b V} {\\\\) F} ];
    set Palette(pipedbsall,link)         [list OrString]

    set Palette(piperebol,gloss)  [_ {a or b}];
    set Palette(piperebol,re)  [list {\[\" F} {a V} {\"|\" F} {b V} {\"\] F}];
    set Palette(piperebol,link)         [list OrString]

    set Palette(altcomma,gloss)   [_ {string ab or cd or ef}];
    set Palette(altcomma,re)   [list {\{ F} {{ab} V} {, F} {{cd} V} {, F} {ef V} {\} F}];
    set Palette(altcomma,link)         [list OrString]

    set Palette(backref,gloss)    [_ {match what is matched by kth subexpression}];
    set Palette(backref,re)    [list {\\ F} {k V}];
    set Palette(backref,link)    [list BackReferenceMatch]

    set Palette(backrefksh,gloss)    [_ {match what is matched by kth subexpression}];
    set Palette(backrefksh,re)    [list {\\ F} {k V}];
    set Palette(backrefksh,link)    [list BackReferenceMatch]

    set Palette(backrefper,gloss) [_ {match what is matched by kth subexpression}];
    set Palette(backrefper,re) [list {% F} {k V}];
    set Palette(backrefper,link) [list BackReferenceMatch]

    set Palette(backrefdbs,gloss) [_ {match what is matched by kth subexpression}];
    set Palette(backrefdbs,re) [list {\\\\ F} {k V}];
    set Palette(backrefdbs,link) [list BackReferenceMatch]

    set Palette(backrefbsall,gloss) [_ {match what is matched by kth subexpression}];
    set Palette(backrefbsall,re) [list {\\ F} {k V}];
    set Palette(backrefbsall,link) [list BackReferenceMatch]

    set Palette(backrefdbsall,gloss) [_ {match what is matched by kth subexpression}];
    set Palette(backrefdbsall,re) [list {\\\\ F} {k V}];
    set Palette(backrefdbsall,link) [list BackReferenceMatch]

    set Palette(baldlim,gloss)    [_ {a string beginning with x and ending with y}];
    set Palette(baldlim,re)    [list {%b F} {xy V}];
    set Palette(baldlim,link)    [list XYPair]

    set Palette(alnum,gloss)      [_ {any alphanumeric character}];
    set Palette(alnum,re)      [list {[[:alnum:]] F}];
    set Palette(alnum,link)    [list AlphaNumWord]

    set Palette(alnumrebol,gloss) [_ {any alphanumeric character}];
    set Palette(alnumrebol,re) [list {alnum F}];
    set Palette(alnumrebol,link)    [list AlphaNumWord]

    set Palette(lalnum,gloss)     [_ {any alphanumeric character}];
    set Palette(lalnum,re)     [list {%w F}];
    set Palette(lalnum,link)    [list AlphaNumWord]

    set Palette(lalnumc,gloss)    [_ {any non-alphanumeric character}];
    set Palette(lalnumc,re)    [list {%W F}];
    set Palette(lalnum,link)    [list AlphaNumWord]

    set Palette(alpha,gloss)      [_ {any alphabetic character}];
    set Palette(alpha,re)      [list {[[:alpha:]] F}];
    set Palette(alpha,link)      [list Alpha]

    set Palette(alpharebol,gloss) [_ {any alphabetic character}];
    set Palette(alpharebol,re) [list {alpha F}];
    set Palette(alpharebol,link)      [list Alpha]

    set Palette(lalpha,gloss)     [_ {any alphabetic character}];
    set Palette(lalpha,re)     [list {%a F}];
    set Palette(lalpha,link)      [list Alpha]

    set Palette(lalphac,gloss)    [_ {any non-alphabetic character}];
    set Palette(lalphac,re)    [list {%A F}];
    set Palette(lalphac,link)      [list Alpha]

    set Palette(blank,gloss)      [_ {any space or tab character}];
    set Palette(blank,re)      [list {[[:blank:]] F}];
    set Palette(blank,link)      [list Blank];

    set Palette(cntrl,gloss)      [_ {any control character}];
    set Palette(cntrl,re)      [list {[[:cntrl:]] F}];
    set Palette(cntrl,link)    [list ControlCharacter]

    set Palette(lcntrl,gloss)     [_ {any control character}];
    set Palette(lcntrl,re)     [list {%c F}];
    set Palette(lcntrl,link)    [list ControlCharacter]

    set Palette(lcntrlc,gloss)    [_ {any non control character}];
    set Palette(lcntrlc,re)    [list {%C F}];
    set Palette(lcntrlc,link)    [list ControlCharacter]

    set Palette(graph,gloss)      [_ {any visible character}];
    set Palette(graph,re)      [list {[[:graph:]] F}];
    set Palette(graph,link)      [list Visible];

    set Palette(print,gloss)      [_ {any printable character}];
    set Palette(print,re)      [list {[[:print:]] F}];
    set Palette(print,link)      [list Visible]

    set Palette(mockprint,gloss)      [_ {one alphanumeric character}];
    set Palette(mockprint,re)      [list {[[:print:]] F}];
    set Palette(mockprint,link)      [list MockPrint]

    set Palette(perlprint,gloss)      "\[:alnum:\] \u222A \[:punct:\] \u222A \[:space:\]";
    set Palette(perlprint,re)      [list {[[:print:]] F}];
    set Palette(perlprint,link)      [list PerlPrint]

    set Palette(space,gloss)      [_ {any space character}];
    set Palette(space,re)      [list {[[:space:]] F}];
    set Palette(space,link)      [list Whitespace]

    set Palette(TabClass,gloss)      [_ {the tabulation character (U+0009)}];
    set Palette(TabClass,re)      [list {[[:tab:]] F}];

    set Palette(EscapeClass,gloss)      [_ {the escape character (U+001B)}];
    set Palette(EscapeClass,re)      [list {[[:escape:]] F}];

    set Palette(BackspaceClass,gloss)      [_ {the backspace character (U+0008)}];
    set Palette(BackspaceClass,re)      [list {[[:backspace:]] F}];

    set Palette(lspace,gloss)     [_ {any space character}];
    set Palette(lspace,re)     [list {%s F}];
    set Palette(lspace,link)      [list Whitespace]

    set Palette(pspace,gloss)     [_ {any space character}];
    set Palette(pspace,re)     [list {\\s F}];
    set Palette(pspace,link)     [list Space Whitespace]

    set Palette(pspacedb,gloss)   [_ {one space character}];
    set Palette(pspacedb,re)   [list {\\\\s F}];
    set Palette(pspacedb,link)   [list Whitespace]

    set Palette(lspacec,gloss)    [_ {one non space character}];
    set Palette(lspacec,re)    [list {%S F}];
    set Palette(lspacec,link)    [list Whitespace]

    set Palette(pspacec,gloss)    [_ {one non-space character}];
    set Palette(pspacec,re)    [list {\\S F}];
    set Palette(pspacec,link)    [list Space Whitespace]

    set Palette(pspacedbc,gloss)  [_ {one non-space character}];
    set Palette(pspacedbc,re)  [list {\\\\S F}];
    set Palette(pspacedbc,link)  [list Whitespace]

    set Palette(W3Space,gloss)     [_ {a space character}];
    set Palette(W3Space,re)     [list {\\s F}];
    set Palette(W3Space,link)     [list W3Space]

    set Palette(W3Spacec,gloss)     [_ {a non-space character}];
    set Palette(W3Spacec,re)     [list {\\S F}];
    set Palette(W3Spacec,link)     [list W3Space]

    set Palette(punct,gloss)      [_ {one punctuation symbol}];
    set Palette(punct,re)      [list {[[:punct:]] F}];
    set Palette(punct,link)      [list Punctuation]

    set Palette(lpunct,gloss)     [_ {one punctuation symbol}];
    set Palette(lpunct,re)     [list {%p F}];
    set Palette(lpunct,link)     [list Punctuation]

    set Palette(lpunctc,gloss)    [_ {one non-punctuation symbol}];
    set Palette(lpunctc,re)    [list {%P F}];
    set Palette(lpunctc,link)    [list Punctuation]

    set Palette(lower,gloss)      [_ {one lower-case alphabetic character}];
    set Palette(lower,re)      [list {[[:lower:]] F}];
    set Palette(lower,link)      [list LowerCaseLetter]

    set Palette(lowerrebol,gloss) [_ {one lower-case alphabetic character}];
    set Palette(lowerrebol,re) [list {lower F}];
    set Palette(lowerrebol,link)      [list LowerCaseLetter]

    set Palette(llower,gloss)     [_ {one lower-case alphabetic character}];
    set Palette(llower,re)     [list {%l F}];
    set Palette(llower,link)      [list LowerCaseLetter]

    set Palette(llowerc,gloss)    [_ {one non lower-case alphabetic character}];
    set Palette(llowerc,re)    [list {%L F}];
    set Palette(llowerc,link)      [list LowerCaseLetter]

    set Palette(upper,gloss)      [_ {one upper-case alphabetic character}];
    set Palette(upper,re)      [list {[[:upper:]] F}];
    set Palette(upper,link)      [list UpperCaseLetter]

    set Palette(upperrebol,gloss) [_ {one upper-case alphabetic character}];
    set Palette(upperrebol,re) [list {upper F}];
    set Palette(upperrebol,link)      [list UpperCaseLetter]

    set Palette(lupper,gloss)     [_ {one upper-case alphabetic character}];
    set Palette(lupper,re)     [list {%u F}];
    set Palette(lupper,link)      [list UpperCaseLetter]

    set Palette(lupperc,gloss)    [_ {one non upper-case alphabetic character}];
    set Palette(lupperc,re)    [list {%U F}];
    set Palette(lupperc,link)      [list UpperCaseLetter]

    set Palette(digit,gloss)      [_ {one digit}];
    set Palette(digit,re)      [list {[[:digit:]] F}];
    set Palette(digit,link)    [list Digit]

    set Palette(digitrebol,gloss) [_ {one digit}];
    set Palette(digitrebol,re) [list {digit F}];
    set Palette(digitrebol,link)    [list Digit]

    set Palette(compposixclassinner,gloss)      [_ {complement of named class foo}];
    set Palette(compposixclassinner,re)      [list {[[:^  F} {foo V} {:]] F}];
    set Palette(compposixclassinner,link)      [list ClassComplement]

    set Palette(compposixclassouter,gloss)      [_ {complement of named class foo}];
    set Palette(compposixclassouter,re)      [list {[^[:  F} {foo V} {:]] F}];
    set Palette(compposixclassouter,link)      [list ClassComplement]

    set Palette(ldigit,gloss)     [_ {one digit}];
    set Palette(ldigit,re)     [list {%d F}];
    set Palette(ldigit,link)    [list Digit]

    set Palette(pdigit,gloss)     [_ {one digit}];
    set Palette(pdigit,re)     [list {\\d F}];
    set Palette(pdigit,link)    [list Digit]

    set Palette(xmldigit,gloss)     [_ {one digit}];
    set Palette(xmldigit,re)     [list {\\d F}];
    set Palette(xmldigit,link)    [list Digit]

    set Palette(pdigitdb,gloss)   [_ {one digit}];
    set Palette(pdigitdb,re)   [list {\\\\d F}];
    set Palette(pdigitdb,link)    [list Digit]

    set Palette(ldigitc,gloss)    [_ {one non-digit}];
    set Palette(ldigitc,re)    [list {%D F}];
    set Palette(ldigitc,link)    [list Digit]

    set Palette(pdigitc,gloss)    [_ {one non-digit}];
    set Palette(pdigitc,re)    [list {\\D F}];
    set Palette(pdigitc,link)    [list Digit]

    set Palette(xmldigitc,gloss)    [_ {one non-digit}];
    set Palette(xmldigitc,re)    [list {\\D F}];
    set Palette(xmldigitc,link)    [list Digit]

    set Palette(pdigitdbc,gloss)  [_ {one non-digit}];
    set Palette(pdigitdbc,re)  [list {\\\\D F}];
    set Palette(pdigitcdb,link)    [list Digit]

    set Palette(xdigit,gloss)     [_ {one hex digit}];
    set Palette(xdigit,re)     [list {[[:xdigit:]] F}];
    set Palette(xdigit,link)    [list HexDigit]

    set Palette(xdigitrebol,gloss) [_ {one hex digit}];
    set Palette(xdigitrebol,re) [list {xdigit F}];
    set Palette(xdigitrebol,link)    [list HexDigit]

    set Palette(lxdigit,gloss)    [_ {one hex digit}];
    set Palette(lxdigit,re)    [list {%x F}];
    set Palette(lxdigit,link)    [list HexDigit]

    set Palette(lxdigitc,gloss)   [_ {one non hex digit}];
    set Palette(lxdigitc,re)   [list {%X F}];
    set Palette(lxdigitc,link)    [list HexDigit]

    set Palette(AlphaBSa,gloss)    [_ {one alphabetic character}];
    set Palette(AlphaBSa,re)    [list {\\a F}];
    set Palette(AlphaBSa,link)    [list Alpha]

    set Palette(AlphaBSAc,gloss)    [_ {one non-alphabetic character}];
    set Palette(AlphaBSAc,re)    [list {\\A F}];
    set Palette(AlphaBSAc,link)    [list Alpha]

    set Palette(WordBSh,gloss)    [_ {one word charcter}];
    set Palette(WordBSh,re)    [list {\\w F}];
    set Palette(WordBSh,link)    [list Word]

    set Palette(WordBSHc,gloss)    [_ {one non-word character}];
    set Palette(WordBSHc,re)    [list {\\W F}];
    set Palette(WordBSHc,link)    [list Word]

    set Palette(WordHeadBSh,gloss)    [_ {one word head charcter}];
    set Palette(WordHeadBSh,re)    [list {\\h F}];
    set Palette(WordHeadBSh,link)    [list WordHead]

    set Palette(WordHeadBSHc,gloss)    [_ {one non-word head character}];
    set Palette(WordHeadBSHc,re)    [list {\\H F}];
    set Palette(WordHeadBSHc,link)    [list WordHead]

    set Palette(UpperCaseBSu,gloss)    [_ {one upper-case letter}];
    set Palette(UpperCaseBSu,re)    [list {\\u F}];
    set Palette(UpperCaseBSu,link)    [list UpperCase]

    set Palette(UpperCaseBSUc,gloss)    [_ {one non-upper-case letter}];
    set Palette(UpperCaseBSUc,re)    [list {\\U F}];
    set Palette(UpperCaseBSUc,link)    [list UpperCase]

    set Palette(LowerCaseBSl,gloss)    [_ {one lower-case letter}];
    set Palette(LowerCaseBSl,re)    [list {\\l F}];
    set Palette(LowerCaseBSl,link)    [list LowerCase]

    set Palette(LowerCaseBSLc,gloss)    [_ {one non-lower-case letter}];
    set Palette(LowerCaseBSLc,re)    [list {\\L F}];
    set Palette(LowerCaseBSLc,link)    [list LowerCase]

    set Palette(odigitBSo,gloss)    [_ {one octal digit}];
    set Palette(odigitBSo,re)    [list {\\o F}];
    set Palette(odigitBSo,link)    [list OctalDigit]

    set Palette(odigitBSOc,gloss)    [_ {one non octal digit}];
    set Palette(odigitBSOc,re)    [list {\\O F}];
    set Palette(odigitBSOc,link)    [list OctalDigit]

    set Palette(xdigitBSx,gloss)    [_ {one hex digit}];
    set Palette(xdigitBSx,re)    [list {\\x F}];
    set Palette(xdigitBSx,link)    [list HexDigit]

    set Palette(xdigitBSxc,gloss)    [_ {one non hex digit}];
    set Palette(xdigitBSxc,re)    [list {\\X F}];
    set Palette(xdigitBSxc,link)    [list HexDigit]

    set Palette(wordclass,gloss)     [_ {one word character}];
    set Palette(wordclass,re)     [list {[[:word:]] F}];
    set Palette(wordclass,link)    [list Word]

    set Palette(bsw,gloss)        [_ {one alphanumeric character}];
    set Palette(bsw,re)        [list {\\w F}];
    set Palette(bsw,link)        [list AlphaNumWord];

    set Palette(pbsw,gloss)       [_ {one alphanumeric character or underscore}];
    set Palette(pbsw,re)       [list {\\w F}];
    set Palette(pbsw,link)    [list AlphaNumWord]

    set Palette(pbbsw,gloss)      [_ {one alphanumeric character or underscore}];
    set Palette(pbbsw,re)      [list {\\\\w F}];
    set Palette(pbbsw,link)    [list AlphaNumWord]

    set Palette(bsW,gloss)        [_ {one non-alphanumeric character}];
    set Palette(bsW,re)        [list {\\W F}];
    set Palette(bsW,link)        [list AlphaNumword];

    set Palette(bsWdb,gloss)      [_ {one non-alphanumeric character}];
    set Palette(bsWdb,re)      [list {\\\\W F}];
    set Palette(bsWdb,link)        [list AlphaNumword];

    set Palette(pbsW,gloss)       [_ {one character not alphanumeric or underscore}];
    set Palette(pbsW,re)       [list {\\W F}];
    set Palette(pbsW,link)    [list AlphaNumWord]

    set Palette(octal,gloss)      [_ {a single byte character code in octal}];
    set Palette(octal,re)      [list {\\ F} {155 V}];
    set Palette(octal,link)      [list OctalCode];

    set Palette(octalo,gloss)      [_ {a single byte character code in octal}];
    set Palette(octalo,re)      [list {\\o F} {155 V}];
    set Palette(octalo,link)      [list OctalCode];

    set Palette(decimald,gloss)      [_ {a single byte character code in decimal}];
    set Palette(decimald,re)      [list {\\d F} {155 V}];
    set Palette(decimald,link)      [list DecimalCode];

    set Palette(octaldb,gloss)    [_ {a single byte character code in octal}];
    set Palette(octaldb,re)    [list {\\\\ F} {155 V}];
    set Palette(octaldb,link)    [list OctalCode];

    set Palette(hexl,gloss)       [_ {a character code in hexadecimal}];
    set Palette(hexl,re)       [list {\\x F} {6d V}];
    set Palette(hexl,link)       [list HexCode]

    set Palette(hexldb,gloss)     [_ {a character code in hexadecimal}];
    set Palette(hexldb,re)     [list {\\\\x F} {6d V}];
    set Palette(hexldb,link)     [list HexCode]

    set Palette(hexu,gloss)       [_ {a character code in hexadecimal}];
    set Palette(hexu,re)       [list {\\x F} {6D V}];
    set Palette(hexu,link)       [list HexCode]

    set Palette(hexudb,gloss)     [_ {a character code in hexadecimal}];
    set Palette(hexudb,re)     [list {\\\\x F} {6D V}];
    set Palette(hexudb,link)     [list HexCode]

    set Palette(HexWideCharacterCurly,gloss)  [_ {a wide character in hexadecimal}]
    set Palette(HexWideCharCurly,re)  [list {\\x\{ F} {0561 V} {\} F}]
    set Palette(HexWideCharCurly,link) [list HexWideCharCurly]

    set Palette(HTMLHexReference,gloss)  [_ {a Unicode character as an HTML hex character reference}]
    set Palette(HTMLHexReference,re)  [list {&\#x F} {0561 V} {; F}]
    set Palette(HTMLHexReference,link) [list HTMLHexReference]

    set Palette(HTMLDecimalReference,gloss)  [_ {a Unicode character as an HTML decimal character reference}]
    set Palette(HTMLDecimalReference,re)  [list {&\# F} {0561 V} {; F}]
    set Palette(HTMLDecimalReference,link) [list HTMLDecimalReference]

    set Palette(bell,gloss)       [_ {bell character}];
    set Palette(bell,re)       [list {\\a F}];
    set Palette(bell,link)       [list Bell]

    set Palette(belldb,gloss)     [_ {bell character}];
    set Palette(belldb,re)     [list {\\\\a F}];
    set Palette(belldb,link)   [list Bell]

    set Palette(backspace,gloss)     [_ {backspace character (U+0008)}];
    set Palette(backspace,re)     [list {\\b F}];

    set Palette(escape,gloss)     [_ {escape character}];
    set Palette(escape,re)     [list {\\e F}];
    set Palette(escape,link)    [list Escape]

    set Palette(escapedb,gloss)   [_ {escape character}];
    set Palette(escapedb,re)   [list {\\\\e F}];
    set Palette(escapedb,link)   [list Escape];

    set Palette(cr,gloss)         [_ {carriage return character}];
    set Palette(cr,re)         [list {\\r F}];
    set Palette(cr,link)         [list CarriageReturn]

    set Palette(crdb,gloss)       [_ {carriage return character}];
    set Palette(crdb,re)       [list {\\\\r F}];
    set Palette(crdb,link)         [list CarriageReturn]

    set Palette(tab,gloss)        [_ {tab character}];
    set Palette(tab,re)        [list {\\t F}];
    set Palette(tab,link)        [list Tab]

    set Palette(tabdb,gloss)      [_ {tab character}];
    set Palette(tabdb,re)      [list {\\\\t F}];
    set Palette(tabdb,link)        [list Tab]

    set Palette(LiteralMetachar,gloss)      [_ "escape to make metacharacter literal"]
    set Palette(LiteralMetachar,re)      [list {\\ F} {x V}];
    set Palette(LiteralMetachar,link)      [list LiteralMetachar]

    set Palette(controlc,gloss)   [_ {control X}];
    set Palette(controlc,re)   [list {\\c F} {X V}];
    set Palette(controlc,link)   [list ControlCharacter]

    set Palette(controlc,gloss)   [_ {control X}];
    set Palette(controlcdb,re) [list {\\\\c F} {X V}];
    set Palette(controlcdb,link) [list ControlCharacter]

    set Palette(comment,gloss)    [_ {comment}];
    set Palette(comment,re)    [list {(?\# F} {foo V} {) F}];
    set Palette(comment,link)    [list Comment]

    set Palette(QuoteFollowingMetacharsQDot,gloss)    [_ {quote following meta-characters}];
    set Palette(QuoteFollowingMetacharsQDot,re)    [list {\\Q F}]
    set Palette(QuoteFollowingMetacharsQDot,link)    [list QuoteFollowingMetachars]

    set Palette(QuoteFollowingMetacharsMDot,gloss)    [_ {quote following meta-characters}];
    set Palette(QuoteFollowingMetacharsMDot,re)    [list {\\M F}]
    set Palette(QuoteFollowingMetacharsMDot,link)    [list QuoteFollowingMetachars]

    set Palette(ShiftBackToMagicDot,gloss)    [_ {make the following part of the pattern magic}];
    set Palette(ShiftBackToMagicDot,re)    [list {\\m F}]
    set Palette(ShiftBackToMagicDot,link)    [list ShiftBackToMagic]

    set Palette(TerminateMetacharQuotingDot,gloss) [_ {terminate the quoting of metacharacters}];
    set Palette(TerminateMetacharQuotingDot,re)    [list {\\E F}]
    set Palette(TerminateMetacharQuotingDot,link)    [list TerminateMetacharQuotingDot]

    set Palette(CaseSensitiveFlag,gloss)	[_ {case sensitive flag}];
    set Palette(CaseSensitiveFlag,re)	 	[list {(?c) F}];
    set Palette(CaseSensitiveFlag,link)		[list CaseSensitiveInitial]

    set Palette(CaseInsensitiveFlagSmallI,gloss)      [_ {case insensitive flag}];
    set Palette(CaseInsensitiveFlagSmallI,re)      [list {(?i) F}];
    set Palette(CaseInsensitiveFlagSmallI,link)      [list CaseInsensitive]

    set Palette(CaseInsensitiveBSSmallC,gloss)      [_ {case insensitive flag}];
    set Palette(CaseInsensitiveBSSmallC,re)      [list {\\c F}];
    set Palette(CaseInsensitiveBSSmallC,link)      [list CaseInsensitive]

    set Palette(CaseSensitiveBSBigC,gloss)      [_ {case sensitive flag}];
    set Palette(CaseSensitiveBSBigC,re)      [list {\\C F}];
    set Palette(CaseSensitiveBSBigC,link)      [list CaseSensitive]

    set Palette(flagCrosshatchICaseSensitive,gloss)      [_ {case sensitive flag}];
    set Palette(flagCrosshatchICaseSensitive,re)      [list {(#I) F}];
    set Palette(flagCrosshatchICaseSensitive,link)      [list CaseSensitive]

    set Palette(flagCrosshatchlAsymmetricCaseInsensitive,gloss)      [_ {asymmetric case insensitive flag}];
    set Palette(flagCrosshatchlAsymmetricCaseInsensitive,re)      [list {(#l) F}];
    set Palette(flagCrosshatchlAsymmetricCaseInsensitive,link)      [list AsymmetricCaseInsensitive]
									  
    set Palette(CaseInsensitiveCrosshatch,gloss)      [_ {case insensitive flag}];
    set Palette(CaseInsensitiveCrosshatch,re)      [list {(#i) F}];
    set Palette(CaseInsensitiveCrosshatch,link)      [list CaseInsensitive]

    set Palette(CaseInsensitiveFlagSmallIu,gloss)      [_ {Unicode case insensitive flag}];
    set Palette(CaseInsensitiveFlagSmallIu,re)      [list {(?iu) F}];
    set Palette(CaseInsensitiveFlagSmallIu,link)      [list CaseInsensitiveIU]

    set Palette(UnsetFlag,gloss)      [_ {unset flag}];
    set Palette(UnsetFlag,re)      [list { (?- F} {f V} {) F}];
    set Palette(UnsetFlag,link)      [list UnsetFlag]

    set Palette(flagL,gloss)      [_ {locale flag L}];
    set Palette(flagL,re)      [list {(?L) F}];

    set Palette(flagx,gloss)      [_ {verbose flag}];
    set Palette(flagx,re)      [list {(?x) F}];
    set Palette(flagx,link)      [list VerboseFlag]

    set Palette(flagb,gloss)      [_ {basic regexp flag}];
    set Palette(flagb,re)      [list {(?b) F}];
    set Palette(flagb,link)      [list BasicFlag]

    set Palette(flage,gloss)      [_ {extended regexp flag}];
    set Palette(flage,re)      [list {(?e) F}];
    set Palette(flage,link)      [list ExtendedFlag]

    set Palette(flagq,gloss)      [_ {literal string flag}];
    set Palette(flagq,re)      [list {(?q) F}];
    set Palette(flagq,link)      [list LiteralFlag]

    set Palette(IgnoreCombiningCharactersBSZ,gloss)      [_ {ignore combining characters}];
    set Palette(IgnoreCombiningCharactersBSZ,re)      [list {\\Z F}];
    set Palette(IgnoreCombiningCharactersBSZ,link)      [list IgnoreCombiningCharacters]

    set Palette(taggedgroup,gloss)   [_ {tagged group}];
    set Palette(taggedgroup,re)   [list {(?P<  F} {tag V} {> F} {xy V} {) F}];
    set Palette(taggedgroup,link)   [list Taggedgroup]

    set Palette(taggedgroupsq,gloss)   [_ {tagged group with single quotes}];
    set Palette(taggedgroupsq,re)   [list {(?P'  F} {tag V} {' F} {xy V} {) F}];
    set Palette(taggedgroupsq,link)   [list Taggedgroup]

    set Palette(taggedgroupref,gloss)   [_ {tagged group backreference}];
    set Palette(taggedgroupref,re)    [list { (?P= F}  {tag V} {) F} ];
    set Palette(taggedgroupref,link)   [list TaggedBackReference]

    set Palette(uname,gloss)      [_ {Named Unicode character}];
    set Palette(uname,re)      [list {\\N\{ F} {name V} {\}  F}];
    set Palette(uname,link)  [list UnicodeName]

    set Palette(unamedb,gloss)      [_ {Named Unicode character}];
    set Palette(unamedb,re)    [list {\\\\N\{ F} {name V} { \} F}];
    set Palette(unamedb,link)  [list UnicodeName]

    set Palette(jLower,gloss)     [_ {A lower case ASCII letter}];
    set Palette(jLower,re)     [list {\\p\{Lower\} F}];
    set Palette(jLower,link)     [list LowerCaseASCIILetter]

    set Palette(jLowerdb,gloss)   [_ {A lower case ASCII letter}];
    set Palette(jLowerdb,re)   [list {\\\\p\{Lower\} F} ];
    set Palette(jLowerdb,link)     [list LowerCaseASCIILetter]

    set Palette(jLowerc,gloss)    [_ {Not a lower case ASCII letter}];
    set Palette(jLowerc,re)    [list {\\P\{ F} {Lower F} {\} F}];
    set Palette(jLowerc,link)     [list LowerCaseASCIILetter]

    set Palette(jLowercdb,gloss)  [_ {Not a lower case ASCII letter}];
    set Palette(jLowercdb,re)  [list {\\\\P\{ F} {Lower F} {\} F}];
    set Palette(jLowercdb,link)     [list LowerCaseASCIILetter]

    set Palette(jUpper,gloss)     [_ {An upper case ASCII letter}];
    set Palette(jUpper,re)    [list {\\p\{ F} {Upper F} {\} F}];
    set Palette(jUpper,rlink)    [list UpperCaseASCIILetter]

    set Palette(jUpperdb,gloss)   [_ {A upper case ASCII letter}];
    set Palette(jUpperdb,re)   [list {\\\\p\{ F} {Upper F} {\} F}];
    set Palette(jUpperdb,rlink)    [list UpperCaseASCIILetter]

    set Palette(jUpperc,gloss)    [_ {Not an upper case ASCII letter}];
    set Palette(jUpperc,re)    [list {\\P\{ F} {Upper F} {\} F}];
    set Palette(jUpperc,rlink)    [list UpperCaseASCIILetter]

    set Palette(jUppercdb,gloss)  [_ {Not an upper case ASCII letter}];
    set Palette(jUppercdb,re)  [list {\\\\P\{ F} {Upper F} {\} F}];
    set Palette(jUppercdb,rlink)    [list UpperCaseASCIILetter]

    set Palette(jAscii,gloss)     [_ {An ASCII character}];
    set Palette(jAscii,re)     [list {\\p\{ F} {ASCII F} {\} F}];
    set Palette(jAscii,link)     [list ASCIIChar]

    set Palette(jAsciidb,gloss)   [_ {An ASCII character}];
    set Palette(jAsciidb,re)   [list {\\\\p\{ F} {ASCII F} {\} F}];
    set Palette(jAsciidb,link)     [list ASCIIChar]

    set Palette(jAsciic,gloss)    [_ {Not an ASCII character}];
    set Palette(jAsciic,re)    [list {\\P\{ F} {ASCII F} {\} F}];
    set Palette(jAsciic,link)     [list ASCIIChar]
    
    set Palette(jAsciicdb,gloss)  [_ {Not an ASCII character}];
    set Palette(jAsciicdb,re)  [list {\\\\P\{ F} {ASCII F} {\} F}];
    set Palette(jAsciicdb,link)     [list ASCIIChar]

    set Palette(jAlpha,gloss)     [_ {An ASCII letter}];
    set Palette(jAlpha,re)       [list {\\p\{ F} {Alpha F} {\} F}];
    set Palette(jAlpha,link)       [list ASCIILetter]

    set Palette(jAlphadb,gloss) [_ {An ASCII letter}];
    set Palette(jAlphadb,re)  [list {\\\\p\{ F} {Alpha F} {\} F}];
    set Palette(jAlphadb,link)       [list ASCIILetter]

    set Palette(jAlphac,gloss)    [_ {Not an ASCII letter}];
    set Palette(jAlphac,re)      [list {\\P\{ F} {Alpha F} {\} F}];
    set Palette(jAlphac,link)       [list ASCIILetter]

    set Palette(jAlphacdb,gloss)  [_ {Not an ASCII letter}];
    set Palette(jAlphacdb,re)    [list {\\\\P\{ F} {Alpha F} {\} F}];
    set Palette(jAlphacdb,link)       [list ASCIILetter]

    set Palette(jDigit,gloss)     [_ {An ASCII digit}];
    set Palette(jDigit,re)       [list {\\p\{ F} {Digit F} {\} F}];
    set Palette(jDigit,link)    [list ASCIIDigit]

    set Palette(jDigitdb,gloss)   [_ {An ASCII digit}];
    set Palette(jDigitdb,re)     [list {\\\\p\{ F} {Digit F} {\} F}];
    set Palette(jDigitdb,link)    [list ASCIIDigit]

    set Palette(jDigitc,gloss)    [_ {Not an ASCII digit}];
    set Palette(jDigitc,re)      [list {\\P\{ F} {Digit F} {\} F}];
    set Palette(jDigitc,link)    [list ASCIIDigit]

    set Palette(jDigitcdb,gloss)  [_ {Not an ASCII digit}];
    set Palette(jDigitcdb,re)    [list {\\\\P\{ F} {Digit F} {\} F}];
    set Palette(jDigitcdb,link)    [list ASCIIDigit]

    set Palette(jXdigit,gloss)    [_ {A hexadecimal digit}];
    set Palette(jXdigit,re)      [list {\\p\{ F} {XDigit F} {\} F}];
    set Palette(jXdigit,link)    [list HexDigit]

    set Palette(jXdigitdb,gloss)  [_ {A hexadecimal digit}];
    set Palette(jXdigitdb,re)    [list {\\\\p\{XDigit\} F}];
    set Palette(jXdigitdb,link)    [list HexDigit]

    set Palette(jXdigitc,gloss)   [_ {Not a hexadecimal digit}];
    set Palette(jXdigitc,re)     [list {\\P{XDigit} F}];
    set Palette(jXdigitc,link)    [list HexDigit]

    set Palette(jXdigitcdb,gloss) [_ {Not a hexadecimal digit}];
    set Palette(jXdigitcdb,re)   [list {\\\\P\{XDigit\} F}];
    set Palette(jXdigitcdb,link)    [list HexDigit]

    set Palette(jAlnum,gloss)     [_ {An ASCII letter or digit}];
    set Palette(jAlnum,re)        [list {\\p\{Alnum\} F}];
    set Palette(jAlnum,link)    [list ASCIIAlphaDigit]

    set Palette(jAlnumdb,gloss)   [_ {An ASCII letter or digit}];
    set Palette(jAlnumdb,re)      [list {\\\\p\{Alnum\} F}];
    set Palette(jAlnumdb,link)    [list ASCIIAlphaDigit]

    set Palette(jAlnumc,gloss)    [_ {Not an ASCII letter or digit}];
    set Palette(jAlnumc,re)       [list {\\P\{Alnum\} F}];
    set Palette(jAlnumc,link)    [list ASCIIAlphaDigit]

    set Palette(jAlnumcdb,gloss)  [_ {Not an ASCII letter or digit}];
    set Palette(jAlnumcdb,re)     [list {\\\\P\{Alnum\} F}];
    set Palette(jAlnumcdb,link)    [list ASCIIAlphaDigit]

    set Palette(jPunct,gloss)     [_ {An ASCII punctuation symbol}];
    set Palette(jPunct,re)        [list {\\p\{Punct\} F}];
    set Palette(jPunct,link)      [list ASCIIPunctuation]

    set Palette(jPunctdb,gloss)   [_ {An ASCII punctuation symbol}];
    set Palette(jPunctdb,re)      [list {\\\\p\{Punct\} F}];
    set Palette(jPunctdb,link)      [list ASCIIPunctuation]

    set Palette(jPunctc,gloss)    [_ {Not an ASCII punctuation symbol}];
    set Palette(jPunctc,re)       [list {\\P\{Punct\} F}];
    set Palette(jPunctc,link)      [list ASCIIPunctuation]

    set Palette(jPunctcdb,gloss)  [_ {Not an ASCII punctuation symbol}];
    set Palette(jPunctcdb,re)     [list {\\\\P\{Punct\} F}];
    set Palette(jPunctcdb,link)      [list ASCIIPunctuation]

    set Palette(jGraph,gloss)     [_ {A visible ASCII character}];
    set Palette(jGraph,re)     [list {\\p\{Graph\} F} ];
    set Palette(jGraph,link)     [list Visible]

    set Palette(jGraphdb,gloss)   [_ {A visible ASCII character}];
    set Palette(jGraphdb,re)   [list {\\\\p\{Graph\} F} ];
    set Palette(jGraphdb,link)   [list Visible]

    set Palette(jGraphc,gloss)    [_ {Not a visible ASCII character}];
    set Palette(jGraphc,re)    [list {\\P\{Graph\} F} ];
    set Palette(jGraphc,link)    [list Visible]

    set Palette(jGraphcdb,gloss)  [_ {Not a visible ASCII character}];
    set Palette(jGraphcdb,re)  [list {\\\\P\{Graph\} F} ];
    set Palette(jGraphcdb,link)     [list Visible]

    set Palette(jPrint,gloss)     [_ {A visible ASCII character}];
    set Palette(jPrint,re)     [list {\\p\{Print\} F} ];
    set Palette(jPrint,link)     [list Visible]

    set Palette(jPrintdb,gloss)  [_ {A visible ASCII character}];
    set Palette(jPrintdb,re)  [list {\\\\p\{Print\} F} ];
    set Palette(jPrintdb,link)  [list Visible]

    set Palette(jPrintc,gloss)    [_ {Not a visible ASCII character}];
    set Palette(jPrintc,re)   [list {\\P\{Print\} F} ];
    set Palette(jPrintc,link)   [list Visible]

    set Palette(jPrintcdb,gloss)  [_ {Not a visible ASCII character}];
    set Palette(jPrintcdb,re) [list {\\\\P\{Print\} F} ];
    set Palette(jPrintcdb,link) [list Visible]

    set Palette(jBlank,gloss)     [_ {A space or tab}];
    set Palette(jBlank,re)     [list {\\p\{Blank\} F} ];
    set Palette(jBlank,link)     [list Blank]

    set Palette(jBlankdb,gloss)   [_ {A space or tab}];
    set Palette(jBlankdb,re)   [list {\\\\p\{Blank\} F} ];
    set Palette(jBlankdb,link)     [list Blank]

    set Palette(jBlankc,gloss)    [_ {Not a space or tab}];
    set Palette(jBlankc,re)    [list {\\P\{Blank\} F} ];
    set Palette(jBlankc,link)     [list Blank]

    set Palette(jBlankcdb,gloss)  [_ {Not a space or tab}];
    set Palette(jBlankcdb,re)  [list {\\\\P\{Blank\} F} ];
    set Palette(jBlankcdb,link)     [list Blank]

    set Palette(jSpace,gloss)     [_ {A whitespace character}];
    set Palette(jSpace,re)       [list {\\p\{Space\} F} ];
    set Palette(jSpace,link)    [list Whitespace]

    set Palette(jSpacedb,gloss)  [_ {A whitespace character}];
    set Palette(jSpacedb,re)        [list {\\\\p\{Space\} F} ];
    set Palette(jSpacedb,link)    [list Whitespace]

    set Palette(jSpacec,gloss)    [_ {Not a whitespace character}];
    set Palette(jSpacec,re)      [list {\\P\{Space\} F} ];
    set Palette(jSpacec,link)    [list Whitespace]

    set Palette(jSpacecdb,gloss)    [_ {Not a whitespace character}];
    set Palette(jSpacecdb,re)   [list {\\\\P\{Space\} F} ];
    set Palette(jSpacecdb,link)    [list Whitespace]

    set Palette(jCntrl,gloss)     [_ {A control character}];
    set Palette(jCntrl,re)       [list {\\p\{Cntrl\} F} ];
    set Palette(jCntrl,link)      [list ControlCharacter]

    set Palette(jCntrldb,gloss)   [_ {A control character}];
    set Palette(jCntrldb,re)     [list {\\\\p\{Cntrl\} F} ];
    set Palette(jCntrdbl,link)      [list ControlCharacter]

    set Palette(jCntrlc,gloss)    [_ {Not a control character}];
    set Palette(jCntrlc,re)      [list {\\P\{Cntrl\} F} ];
    set Palette(jCntrlc,link)      [list ControlCharacter]

    set Palette(jCntrlcdb,gloss)  [_ {Not a control character}];
    set Palette(jCntrlcdb,re)    [list {\\\\P\{Cntrl\} F} ];
    set Palette(jCntrlcdb,link)      [list ControlCharacter]

    set Palette(jUBlockIn,gloss)    [_ {A named Unicode block}];
    set Palette(jUBlockIn,re)    [list {\\p\{In F} {Hiragana V}  {\} F}];
    set Palette(jUBlockIn,link)    [list UnicodeRange]

    set Palette(jUBlockIndb,gloss)  [_ {A named Unicode block}];
    set Palette(jUBlockIndb,re)  [list {\\\\p\{In F} {Hiragana V}  {\} F}];
    set Palette(jUBlockIndb,link)    [list UnicodeRange]

    set Palette(jUBlockInc,gloss)   [_ {Not in named Unicode block}];
    set Palette(jUBlockInc,re)   [list {\\P\{In F} {Hiragana V}  {\} F}];
    set Palette(jUBlockInc,link)    [list UnicodeRange]

    set Palette(jUBlockIncdb,gloss) [_ {Not in named Unicode block}];
    set Palette(jUBlockIncdb,re) [list {\\\\P\{In F} {Hiragana V}  {\} F}];
    set Palette(jUBlockIncdb,link)    [list UnicodeRange]

    set Palette(jUBlockIs,gloss)    [_ {A named Unicode block}];
    set Palette(jUBlockIs,re)    [list {\\p\{Is F} {Hiragana V}  {\} F}];
    set Palette(jUBlockIs,link)    [list UnicodeRange]

    set Palette(jUBlockIsdb,gloss)  [_ {A named Unicode block}];
    set Palette(jUBlockIsdb,re)  [list {\\\\p\{Is F} {Hiragana V}  {\} F}];
    set Palette(jUBlockIsdb,link)    [list UnicodeRange]

    set Palette(jUBlockIsc,gloss)   [_ {Not in named Unicode block}];
    set Palette(jUBlockIsc,re)   [list {\\P\{Is F} {Hiragana V}  {\} F}];
    set Palette(jUBlockIsc,link)    [list UnicodeRange]

    set Palette(jUBlockIscdb,gloss) [_ {Not in named Unicode block}];
    set Palette(jUBlockIscdb,re) [list {\\\\P\{Is F} {Hiragana V}  {\} F}];
    set Palette(jUBlockIscdb,link)    [list UnicodeRange]

    set Palette(jUBlockBare,gloss)    [_ {A named Unicode block}];
    set Palette(jUBlockBare,re)    [list {\\p\{ F} {Hiragana V}  {\} F}];
    set Palette(jUBlockBare,link)    [list UnicodeRange]

    set Palette(jUBlockBaredb,gloss)  [_ {A named Unicode block}];
    set Palette(jUBlockBaredb,re)  [list {\\\\p\{ F} {Hiragana V}  {\} F}];
    set Palette(jUBlocdbk,link)    [list UnicodeRange]

    set Palette(jUBlockBarec,gloss)   [_ {Not in named Unicode block}];
    set Palette(jUBlockBarec,re)   [list {\\P\{ F} {Hiragana V}  {\} F}];
    set Palette(jUBlockBarec,link)    [list UnicodeRange]

    set Palette(jUBlockBarecdb,gloss) [_ {Not in named Unicode block}];
    set Palette(jUBlockBarecdb,re) [list {\\\\P\{ F} {Hiragana V}  {\} F}];
    set Palette(jUBlockBarecdb,link)    [list UnicodeRange]

    set Palette(jUCat,gloss)      [_ {A named Unicode category}];
    set Palette(jUCat,re)      [list {\\p\{ F} {Sm V}  {\} F}];
    set Palette(jUCat,link)	[list UnicodeCategory]

    set Palette(jUCatdb,gloss)    [_ {A named Unicode category}];
    set Palette(jUCatdb,re)   [list {\\\\p\{ F} {Sm V}  {\} F}];
    set Palette(jUCatdb,link)	[list UnicodeCategory]

    set Palette(jUCatc,gloss)     [_ {Not in named Unicode category}];
    set Palette(jUCatc,re)     [list {\\P\{ F} {Sm V}  {\} F}];
    set Palette(jUCatc,link)	[list UnicodeCategory]

    set Palette(jUCatcdb,gloss)   [_ {Not in named Unicode category}];
    set Palette(jUCatcdb,re)   [list {\\\\P\{ F} {Sm V}  {\} F}];
    set Palette(jUCatcdb,link)	[list UnicodeCategory]


    set Palette(jUCatIn,gloss)      [_ {A named Unicode category}];
    set Palette(jUCatIn,re)      [list {\\p\{In F} {Sm V}  {\} F}];
    set Palette(jUCatIn,link)	[list UnicodeCategory]

    set Palette(jUCatdbIn,gloss)    [_ {A named Unicode category}];
    set Palette(jUCatdbIn,re)   [list {\\\\p\{In F} {Sm V}  {\} F}];
    set Palette(jUCatdbIn,link)	[list UnicodeCategory]

    set Palette(jUCatcIn,gloss)     [_ {Not in named Unicode category}];
    set Palette(jUCatcIn,re)     [list {\\P\{In F} {Sm V}  {\} F}];
    set Palette(jUCatcIn,link)	[list UnicodeCategory]

    set Palette(jUCatcdbIn,gloss)   [_ {Not in named Unicode category}];
    set Palette(jUCatcdbIn,re)   [list {\\\\P\{In F} {Sm V}  {\} F}];
    set Palette(jUCatcdbIn,link)	[list UnicodeCategory]


    set Palette(jUCatIs,gloss)      [_ {A named Unicode category}];
    set Palette(jUCatIs,re)      [list {\\p\{Is F} {Sm V}  {\} F}];
    set Palette(jUCatIs,link)	[list UnicodeCategory]

    set Palette(jUCatdbIs,gloss)    [_ {A named Unicode category}];
    set Palette(jUCatdbIs,re)   [list {\\\\p\{Is F} {Sm V}  {\} F}];
    set Palette(jUCatdbIs,link)	[list UnicodeCategory]

    set Palette(jUCatcIs,gloss)     [_ {Not in named Unicode category}];
    set Palette(jUCatcIs,re)     [list {\\P\{Is F} {Sm V}  {\} F}];
    set Palette(jUCatcIs,link)	[list UnicodeCategory]

    set Palette(jUCatcdbIs,gloss)   [_ {Not in named Unicode category}];
    set Palette(jUCatcdbIs,re)   [list {\\\\P\{Is F} {Sm V}  {\} F}];
    set Palette(jUCatcdbIs,link)	[list UnicodeCategory]


    set Palette(jUnion,gloss)     [_ {The union of [1-3] and [d-f]}];
    set Palette(jUnion,re)     [list {[ F} {1 V} {- F} {3 V} {[ F}  {d V} {- F} {f V} {]] F}];

    set Palette(jInter,gloss)     [_ {The intersection of [d-f] and [a-z]}];
    set Palette(jInter,re)     [list {{[} F} {d V} {- F} {f V} {{&&[} F} {a V} {- F} {z V} {{]]} F}];
    set Palette(jInter,link)     [list Intersection]

    set Palette(plookahead,gloss) [_ {Positive forward assertion}];
    set Palette(plookahead,re) [list {(?= F} {xyz V} {) F}];
    set Palette(plookahead,link) [list PositiveForwardAssertion]

    set Palette(plookaheadAtSign,gloss) [_ {Positive forward assertion}];
    set Palette(plookaheadAtSign,re) [list {\\@= F} {xyz V}];
    set Palette(plookaheadAtSign,link) [list PositiveForwardAssertion]

    set Palette(plookback,gloss)  [_ {Positive backward assertion}];
    set Palette(plookback,re)  [list {(?<= F} {{xyz} V} {) F}];
    set Palette(plookback,link)  [list PositiveBackwardAssertion]

    set Palette(plookbackAtSign,gloss)  [_ {Positive backward assertion}];
    set Palette(plookbackAtSign,re)  [list {\\@<= F} {{xyz} V}];
    set Palette(plookbackAtSign,link)  [list PositiveBackwardAssertion]

    set Palette(nlookahead,gloss) [_ {Negative forward assertion}];
    set Palette(nlookahead,re) [list {(?! F} {xyz V} {) F}];
    set Palette(nlookahead,link) [list NegativeForwardAssertion]

    set Palette(nlookaheadAtSign,gloss) [_ {Negative forward assertion}];
    set Palette(nlookaheadAtSign,re) [list {\\@! F} {xyz V}];
    set Palette(nlookaheadAtSign,link) [list NegativeForwardAssertion]

    set Palette(nlookback,gloss)  [_ {Negative backward assertion}];
    set Palette(nlookback,re)  [list {(?<! F} {xyz V} {) F}];
    set Palette(nlookback,link)  [list NegativeBackwardAssertion]

    set Palette(nlookbackAtSign,gloss)  [_ {Negative backward assertion}];
    set Palette(nlookbackAtSign,re)  [list {\\@<! F} {{xyz} V}];
    set Palette(nlookbackAtSign,link)  [list NegativeBackwardAssertion]

    set Palette(SelfishNoCaptureGroup,gloss)      [_ {selfish no capture group}];
    set Palette(SelfishNoCaptureGroup,re)      [list {(?> F} {abc V} {) F}]
    set Palette(SelfishNoCaptureGroup,link)      [list SelfishNoCaptureGroup]

    set Palette(CondGroupSimple,gloss)      [_ {Group backreference conditional}];
    set Palette(CondGroupSimple,re)      [list {(?( F} {k V} {) F} {x V} {) F}]
    set Palette(CondGroupSimple,link)      [list SimpleGroupConditional]

    set Palette(CondGroupElse,gloss)      [_ {Group backreference conditional with else clause}];
    set Palette(CondGroupElse,re)        [list {(?( F} {k V} {) F} {x V} {| F} {y V} {) F}]
    set Palette(CondGroupElse,link)      [list ElseGroupConditional]

    set Palette(CondPosLookaheadSimple,gloss)      [_ {Positive forward assertion conditional}];
    set Palette(CondPosLookaheadSimple,re)     [list {(?(? F} {= F} {w V} {) F} {x V} {) F}]
    set Palette(CondPosLookaheaddSimple,link)      [list SimpleLookaroundConditional]

    set Palette(CondPosLookaheadElse,gloss)      [_ {Positive forward assertion conditional with else clause}];
    set Palette(CondPosLookaheadElse,re)       [list {(?(? F} {= F} {w V} {) F} {x V} {| F} {y V} {) F}]
    set Palette(CondPosLookaheadElse,link)      [list ElseLookaroundConditional]

    set Palette(CondPosLookbackSimple,gloss)      [_ {Positive backward assertion conditional}];
    set Palette(CondPosLookbackSimple,re)     [list {(?(? F} {<= F} {w V} {) F} {x V} {) F}]
    set Palette(CondPosLookbackSimple,link)      [list SimpleLookaroundConditional]

    set Palette(CondPosLookbackElse,gloss)      [_ {Positive backward assertion conditional with else clause}];
    set Palette(CondPosLookbackElse,re)       [list {(?(? F} {<= F} {w V} {) F} {x V} {| F} {y V} {) F}]
    set Palette(CondPosLookbackElse,link)      [list ElseLookaroundConditional]

    set Palette(CondNegLookaheadSimple,gloss)      [_ {Negative forward assertion conditional}];
    set Palette(CondNegLookaheadSimple,re)     [list {(?(? F} {! F} {w V} {) F} {x V} {) F}]
    set Palette(CondNegLookaheadSimple,link)      [list SimpleLookaroundConditional]

    set Palette(CondNegLookaheadElse,gloss)      [_ {Negative forward assertion conditional with else clause}];
    set Palette(CondNegLookaheadElse,re)       [list {{(?(?} F} {! F} {w V} {) F} {x V} {| F} {y V} {) F}]
    set Palette(CondNegLookaheadElse,link)      [list ElseLookaroundConditional]


    set Palette(CondNegLookbackSimple,gloss)      [_ {Negative backward assertion conditional}];
    set Palette(CondNegLookbackSimple,re)     [list {(?(? F} {<! F} {w V} {) F} {x V} {) F}]
    set Palette(CondNegLookbackSimple,link)      [list SimpleLookaroundConditional]

    set Palette(CondNegLookbackElse,gloss)      [_ {Negative backward assertion conditional with else clause}];
    set Palette(CondNegLookbackElse,re)       [list {(?(? F} {<! F} {w V} {) F} {x V} {| F} {y V} {) F}]
    set Palette(CondNegLookbackElse,link)      [list ElseLookaroundConditional]

    set Palette(SubBackRefBare,gloss)  [_ {Insert the kth captured subgroup}];
    set Palette(SubBackRefBare,re)  [list {k V}];
    set Palette(SubBackRefBare,Prefix)  "";
    set Palette(SubBackRefBare,link)  [list BackReferenceSub]

    set Palette(SubBackReferenceDol,gloss)  [_ {Insert the kth captured subgroup}];
    set Palette(SubBackReferenceDol,re)  [list {$ F} {k V}];
    set Palette(SubBackReferenceDol,Prefix)  {$}
    set Palette(SubBackReferenceDol,link) [list BackReferenceSub]

    set Palette(SubBackReferenceDolZero,gloss)  [_ {Insert the entire match}];
    set Palette(SubBackReferenceDolZero,re)  [list {$0 F}];
    set Palette(SubBackReferenceDolZero,link) [list InsertEntireMatch]

    set Palette(SubBackReferencePercent,gloss)  [_ {Insert the kth captured subgroup}];
    set Palette(SubBackReferencePercent,re)  [list {% F} {k V}];
    set Palette(SubBackReferencePercent,Prefix)  {%}
    set Palette(SubBackReferencePercent,link) [list BackReferenceSub]

    set Palette(SubBackReferencePercentZero,gloss)  [_ {Insert the entire match}];
    set Palette(SubBackReferencePercentZero,re)  [list {%0 F}];
    set Palette(SubBackReferencePercentZero,link) [list InsertEntireMatch]

    set Palette(SubBackRefbs,gloss)   [_ {Insert the kth captured subgroup}]
    set Palette(SubBackRefbs,re)  [list {\\ F} {k V}]
    set Palette(SubBackRefbs,Prefix)  "\\"
    set Palette(SubBackRefbs,link)  [list BackReferenceSub]

    set Palette(SubBackRefbsZero,gloss)   [_ {Insert the entire match}]
    set Palette(SubBackRefbsZero,re)  [list {\\0 F}]
    set Palette(SubBackRefbsZero,link)  [list InsertEntireMatch]

    set Palette(SubBackRefdbs,gloss)  [_ {Insert the kth captured subgroup}];
    set Palette(SubBackRefdbs,re) [list {\\\\ F} {k V}]
    set Palette(SubBackRefdbs,Prefix) {\\}
    set Palette(SubBackRefdbs,link) [list BackReferenceSub]

    set Palette(SubBackRefdbsZero,gloss)  [_ {Insert the entire match}];
    set Palette(SubBackRefdbsZero,re) [list {\\\\0 F}]
    set Palette(SubBackRefdbsZero,link) [list InsertEntireMatch]

    set Palette(SubBackRefPardbsdbs,gloss)  [_ {Insert the kth captured subgroup}];
    set Palette(SubBackRefPardbsdbs,re) [list {\\\\ F} {k V}]
    set Palette(SubBackRefPardbsdbs,Prefix) {\\};
    set Palette(SubBackRefPardbsdbs,link) [list BackReferenceSub]

    set Palette(SubBackRefParbs,gloss)  [_ {Insert the kth captured subgroup}];
    set Palette(SubBackRefParbs,re) [list {\\ F} {k V}]
    set Palette(SubBackRefParbs,Prefix) "\\" ;
    set Palette(SubBackRefParbs,link) [list BackReferenceSub]

    set Palette(SubBackRefPardbsdbsZero,gloss)  [_ {Insert the entire match}];
    set Palette(SubBackRefPardbsdbsZero,re) [list {\\\\0 F}]
    set Palette(SubBackRefPardbsdbsZero,link) [list InsertEntireMatch]

    set Palette(SubEntBackRefZero,gloss)  [_ {Insert the entire match}];
    set Palette(SubEntBackRefZero,re)  [list {0 F}];
    set Palette(SubEntBackRefZero,link)  [list InsertEntireMatch]

    set Palette(Subampentbackrefs,gloss)  [_ {Insert the entire match}];
    set Palette(Subampentbackrefs,re)  [list {& F}];
    set Palette(Subampentbackrefs,link)  [list InsertEntireMatch]

    set Palette(Subampentbackrefsdbs,gloss)  [_ {Insert the entire match}];
    set Palette(Subampentbackrefsdbs,re)  [list {\\\\& F}];
    set Palette(Subampentbackrefsdbs,link)  [list InsertEntireMatch]

    set Palette(SubDolAmpEntBackRef,gloss) [_ {Insert the entire match} ];
    set Palette(SubDolAmpEntBackRef,re) [list {$& F}]
    set Palette(SubDolAmpEntBackRef,link)  [list InsertEntireMatch]

    set Palette(SubampentbackrefsPardbsdbs,gloss)  [_ {Insert the entire match}];
    set Palette(SubampentbackrefsPardbsdbs,re) [list {\\\\& F}];
    set Palette(SubampentbackrefsPardbsdbs,link) [list InsertEntireMatch]

    set Palette(SubPreMatch,gloss)     [_ {Insert the portion preceding the match}];
    set Palette(SubPreMatch,re)     [list {\\` F}];
    set Palette(SubPreMatch,link)     [list InsertPreMatch]

    set Palette(SubPreMatchDol,gloss)     [_ {Insert the portion preceding the match}];
    set Palette(SubPreMatchDol,re)     [list {$\` F}];
    set Palette(SubPreMatchDol,link)  [list InsertPreMatch]

    set Palette(SubPreMatchLit,gloss)     [_ {Insert the portion preceding the match}];
    set Palette(SubPreMatchLit,re)     [list {'pre F}];
    set Palette(SubPreMatchLit,link)  [list InsertPreMatch]

    set Palette(SubPostMatch,gloss)    [_ {Insert the portion following the match}];
    set Palette(SubPostMatch,re)    [list {\' F}];
    set Palette(SubPostMatch,link)    [list InsertPostMatch]

    set Palette(SubPostMatchDol,gloss)    [_ {Insert the portion following the match}];
    set Palette(SubPostMatchDol,re)    [list {$\' F}];
    set Palette(SubPostMatchDol,link)  [list InsertPostMatch]

    set Palette(SubPostMatchLit,gloss)    [_ {Insert the portion following the match}];
    set Palette(SubPostMatchLit,re)    [list {'post F}];
    set Palette(SubPostMatchLit,link)  [list InsertPostMatch]

    set Palette(SubLastCapture,gloss)  [_ {Insert the last captured group}];
    set Palette(SubLastCapture,re)  [list {\\+ F}];
    set Palette(SubLastCapture,link)  [list InsertLastGroup]

    set Palette(SubLastCaptureDol,gloss)  [_ {Insert the last captured group}];
    set Palette(SubLastCaptureDol,re)  [list {$+ F}];
    set Palette(SubLastCaptureDol,link)  [list InsertLastGroup]

    set Palette(SubAlnum,gloss)      [_ {the alphanumeric characters (only in source)}];
    set Palette(SubAlnum,re)      [list {[:alnum:] F}];
    set Palette(SubAlnum,link)    [list AlphaNumWord]

    set Palette(SubAlpha,gloss)      [_ {the alphabetic characters (only in source)}];
    set Palette(SubAlpha,re)      [list {[:alpha:] F}];
    set Palette(SubAlpha,link)      [list Alpha]

    set Palette(SubBlank,gloss)      [_ {space or tab (only in source)}];
    set Palette(SubBlank,re)      [list {[:blank:] F}];
    set Palette(SubBlank,link)      [list Blank]

    set Palette(SubCntrl,gloss)      [_ {the control characters (only in source)}];
    set Palette(SubCntrl,re)      [list {[:cntrl:] F}];
    set Palette(SubCntrl,link)    [list ControlCharacter]

    set Palette(SubDigit,gloss)      [_ {the decimal digits (only in source)}];
    set Palette(SubDigit,re)      [list {[:digit:] F}];
    set Palette(SubDigit,link)      [list Digit]

    set Palette(SubGraph,gloss)      [_ {the `visible' characters (only in source)}];
    set Palette(SubGraph,re)      [list {[:graph:]} F]; 
    set Palette(SubGraph,link)      [list Visible]

    set Palette(SubLower,gloss)      [_ {the lower-case letters}];
    set Palette(SubLower,re)      [list {[:lower:] F}];
    set Palette(SubLower,link)      [list LowerCaseASCIILetter MustPair]

    set Palette(SubPrint,gloss)      [_ {the `visible' characters (only in source)}];
    set Palette(SubPrint,re)      [list {[:print:] F}];
    set Palette(SubPrint,link)      [list Visible]

    set Palette(SubPunct,gloss)      [_ {the punctuation symbols (only in source)}];
    set Palette(SubPunct,re)      [list {[:punct:] F}];
    set Palette(SubPunct,link)      [list ASCIIPunctuation]

    set Palette(SubSpace,gloss)      [_ {the space characters (only in source)}];
    set Palette(SubSpace,re)      [list {[:space:] F}];
    set Palette(SubSpace,link)      [list Whitespace]

    set Palette(SubUpper,gloss)      [_ {The upper-case letters}];
    set Palette(SubUpper,re)      [list {[:upper:] F}];
    set Palette(SubUpper,link)      [list UpperCaseASCIILetter MustPair]

    set Palette(SubXdigit,gloss)     [_ {The hexadecimal digits (only in source)}];
    set Palette(SubXdigit,re)     [list {[:xdigit:] F}];
    set Palette(SubXdigit,link)     [list HexDigit];

    set Palette(SubRange,gloss)     [_ {The letters from a through d}];
    set Palette(SubRange,re)     [list {a V} {- F} {d V}];
    set Palette(SubRange,link)     [list Range]

    set Palette(SubCStarN,gloss)  [_ {N copies of character C (substitution only)}];
    set Palette(SubCStarN,re)  [list {[ F} {C V} {* F} {N V} {] F}];
    set Palette(SubCStarN,link)  [list TRStarN]

    set Palette(SubCStar,gloss)   [_ {As many copies of character C as necessary (substitution only)}];
    set Palette(SubCStar,re)   [list {[ F} {C V} {*] F}];
    set Palette(SubCStar,link)  [list TRStar]

    set Palette(SubLitString,gloss) [_ {Insert literal string}]
    set Palette(SubLitString,re)   [list  {\" F} {xyz V} {\" F}]
    set Palette(SubLitString,link)   [list  InsertLiteralString]

    set Palette(SubDowncaseChar,gloss) [_ {Downcase the following character}]
    set Palette(SubDowncaseChar,re)   [list  {\\l F}]
    set Palette(SubDowncaseChar,link)   [list  DowncaseCharacter]

    set Palette(SubUpcaseChar,gloss) [_ {Upcase the following character}]
    set Palette(SubUpcaseChar,re)   [list  {\\u F}]
    set Palette(SubUpcaseChar,link)   [list  UpcaseCharacter]

    set Palette(SubDowncaseString,gloss) [_ {Downcase the following string}]
    set Palette(SubDowncaseString,re)   [list  {\\L F}]
    set Palette(SubDowncaseString,link)   [list  DowncaseString]

    set Palette(SubUpcaseString,gloss) [_ {Upcase the following string}]
    set Palette(SubUpcaseString,re)   [list  {\\U F}]
    set Palette(SubUpcaseString,link)   [list  UpcaseString]

    set Palette(SubEndCaseDomaine,gloss) [_ {Terminate the effects of a preceding case-changer}]
    set Palette(SubEndCaseDomaine,re)   [list  {\\e F}]
    set Palette(SubEndCaseDomaine,link)   [list  EndCaseDomain]

    set Palette(SubEndCaseDomainE,gloss) [_ {Terminate the effects of a preceding case-changer}]
    set Palette(SubEndCaseDomainE,re)   [list  {\\E F}]
    set Palette(SubEndCaseDomainE,link)   [list  EndCaseDomain]

    set Palette(SubDowncaseCharDollar,gloss) [_ {Downcase the following character}]
    set Palette(SubDowncaseCharDollar,re)   [list  {\\l F}]
    set Palette(SubDowncaseCharDollar,link)   [list  DowncaseCharacter]

    set Palette(SubUpcaseCharDollar,gloss) [_ {Upcase the following character}]
    set Palette(SubUpcaseCharDollar,re)   [list  {\\u F}]
    set Palette(SubUpcaseCharDollar,link)   [list  UpcaseCharacter]

    set Palette(SubDowncaseStringDollar,gloss) [_ {Downcase the following string}]
    set Palette(SubDowncaseStringDollar,re)   [list  {\\L F}]
    set Palette(SubDowncaseStringDollar,link)   [list  DowncaseString]

    set Palette(SubUpcaseStringDollar,gloss) [_ {Upcase the following string}]
    set Palette(SubUpcaseStringDollar,re)   [list  {\\U F}]
    set Palette(SubUpcaseStringDollar,link)   [list  UpcaseString]

    set Palette(SubEndCaseDomaineDollar,gloss) [_ {Terminate the effects of a preceding case-changer}]
    set Palette(SubEndCaseDomaineDollar,re)   [list  {\\e F}]
    set Palette(SubEndCaseDomaineDollar,link)   [list  EndCaseDomain]

    set Palette(SubEndCaseDomainEDollar,gloss) [_ {Terminate the effects of a preceding case-changer}]
    set Palette(SubEndCaseDomainEDollar,re)   [list  {\\E F}]
    set Palette(SubEndCaseDomainEDollar,link)   [list  EndCaseDomain]

    set Palette(SubNewline,gloss) [_ {Insert a line break}]
    set Palette(SubNewline,re)   [list  {\\r F}]
    set Palette(SubNewline,link)   [list  SubNewline]

    set Palette(ExactMatchWD,gloss) [_ {Require exact match of enclosed group}]
    set Palette(ExactMatchWD,re)   [list {< F} {abcd V} {> F}]
    set Palette(ExactMatchWD,link) [list ExactMatch]

    set Palette(ExactMatchTRE,gloss) [_ {Require exact match of preceding group}]
    set Palette(ExactMatchTRE,re)   [list {\{~0\} F}]
    set Palette(ExactMatchTRE,link) [list ExactMatch]

    set Palette(ExactMatchCgrep,gloss) [_ {Require exact match of enclosed material}]
    set Palette(ExactMatchCgrep,re)   [list {< F} {abc V} {> F}]
    set Palette(ExactMatchCgrep,link) [list ExactMatch]

    set Palette(TRECostSetting,gloss) [_ "set error costs for preceding group"];
    set Palette(TRECostSetting,re)    [list {\{ F} {+ F} {w V} {- F} {x V} {\# F} {y V} {~ F} {z V} {{ , } F} {a V} {i F} {+ F} {b V} {d F} {+ F} {c V} {s F} {{ < } F} {k V} {\} F}]
    set Palette(TRECostSetting,link) [list TRECostSetting]

    set Palette(TotalErrorCrosshatchA,gloss) [_ "accept at most N errors"];
    set Palette(TotalErrorCrosshatchA,re)    [list {(\#a F} {N V} {) F}]
    set Palette(TotalErrorCrosshatchA,link) [list TotalErrorCrosshatchA]

    set Palette(ReluctantStar,gloss) [_ "Match zero or more of preceding group (reluctant)"]
    set Palette(ReluctantStar,re) [list {* F}]

    set Palette(GreedyDoubleStar,gloss) [_ "Match zero or more of preceding group (greedy)"]
    set Palette(GreedyDoubleStar,re) [list {** F}]

    set Palette(CollationClass,gloss) [_ "The collation class of the specified character."]
    set Palette(CollationClass,re)    [list {[[= F} {x V} {=]] F} ];
    set Palette(CollationClass,link) [list CollationClass]

    set Palette(CollatingElementMultichar,gloss) [_ "A POSIX multicharacter collating element"]
    set Palette(CollatingElementMultichar,re)    [list {[[. F} {xy V} {.]] F} ];
    set Palette(CollatingElementMultichar,link)  [list CollatingElementMultichar]

    set Palette(CollatingElementNamed,gloss) [_ "A POSIX named collating element"]
    set Palette(CollatingElementNamed,re)    [list {[[. F} {name V} {.]] F} ];
    set Palette(CollatingElementNamed,link)  [list CollatingElementNamed]

    #set Palette(flagm)      [_ {compiler flag m:                                    (?m)}];
    #set Palette(flags)      [_ {compiler flag s:                                    (?s)}];

    set Palette(CposRange,gloss)       [_ "the jth character through the kth character"];
    set Palette(CposRange,re)       [list {[( F} {j V} {, F} {k V} {)] F}];
    set Palette(CposRange,link)       [list CposRange]

    set Palette(RegionDoubleDot,gloss)       [_ "the region beginning with x and ending with y"];
    set Palette(RegionDoubleDot,re)       [list {x V} {.. F} {y V}];
    set Palette(RegionDoubleDot,link)       [list RegionDoubleDot]

    set Palette(ColumnSpecifier,gloss) [_ "match in the specified column"]
    set Palette(ColumnSpecifier,re)    [list {\\% F} {12 V} {c F}]
    set Palette(ColumnSpecifier,link)  [list ColumnSpecifier]

    set Palette(PreColumnSpecifier,gloss) [_ "match before the specified column"]
    set Palette(PreColumnSpecifier,re)    [list {\\%< F} {12 V} {c F}]
    set Palette(PreColumnSpecifier,link)  [list PreColumnSpecifier]

    set Palette(PostColumnSpecifier,gloss) [_ "match after the specified column"]
    set Palette(PostColumnSpecifier,re)    [list {\\%> F} {12 V} {c F}]
    set Palette(PostColumnSpecifier,link)  [list PostColumnSpecifier]
}
#End of SetPalette

#Initialize the count of palette entries for each program to zero.
foreach i $ProgList {
    set UserPalette($i,0) 0;
}

set ExecCmd(agrep,match) ExecuteMatchAgrep;
set ExecCmd(agrep,match,ExactMatchTRE) "-1";#   Flag needed for palette test.
set ExecCmd(agrep,match,ExactMatchWD) "-1";#   Flag needed for palette test.
set ExecCmd(arena,match) ExecuteMatchArena;
set ExecCmd(awk,match) ExecuteMatchAwk;
set ExecCmd(awk,sub) ExecuteSubAwk;
set ExecCmd(bash,match) ExecuteMatchBash;
set ExecCmd(boo,match) ExecuteMatchBoo;
set ExecCmd(BusyBoxEgrep,match) ExecuteMatchBusyBoxEgrep;
set ExecCmd(C,match) ExecuteMatchC;
set ExecCmd(cgrep,match) ExecuteMatchCgrep;
set ExecCmd(cgrep,match,ExactMatchCgrep) [list "-A" "1"];#   Flags needed for palette test.
set ExecCmd(ed,match)  ExecuteMatchEd;
set ExecCmd(ed,sub)  ExecuteSubEd;
set ExecCmd(egrep,match) ExecuteMatchEgrep;
set ExecCmd(emacs,match) ExecuteMatchEmacs;
set ExecCmd(emacs,sub) ExecuteSubEmacs;
set ExecCmd(euphoria,match) ExecuteMatchEuphoria;
set ExecCmd(expr,match) ExecuteMatchExpr;
set ExecCmd(fgrep,match) ExecuteMatchFgrep;
set ExecCmd(fish,match) ExecuteMatchFish;
set ExecCmd(flex,match) ExecuteMatchFlex;
set ExecCmd(frink,match) ExecuteMatchFrink;
set ExecCmd(frink,sub) ExecuteSubFrink;
set ExecCmd(gawk,match) ExecuteMatchGawk;
set ExecCmd(gawk,sub) ExecuteSubGawk;
set ExecCmd(glark,match) ExecuteMatchGlark;
set ExecCmd(gpp,match) ExecuteMatchGPP;
set ExecCmd(gpp,sub) ExecuteSubGPP;
set ExecCmd(grep,match) ExecuteMatchGrep;
set ExecCmd(groovy,match) ExecuteMatchGroovy;
set ExecCmd(guile,match) ExecuteMatchGuile;
set ExecCmd(guile,sub) ExecuteSubGuile;
set ExecCmd(ici,match) ExecuteMatchIci;
set ExecCmd(icon,match) ExecuteMatchIcon;
set ExecCmd(java,match) ExecuteMatchJava;
set ExecCmd(java,sub) ExecuteSubJava;
set ExecCmd(javascript,match) ExecuteMatchJavascript;
set ExecCmd(javascript,sub) ExecuteSubJavascript;
set ExecCmd(jgrep,match) ExecuteMatchJgrep;
set ExecCmd(judoscript,match) ExecuteMatchJudoscript;
set ExecCmd(judoscript,sub) ExecuteSubJudoscript;
set ExecCmd(ksh,match) ExecuteMatchKsh;
set ExecCmd(lua,match) ExecuteMatchLua;
set ExecCmd(lua,sub) ExecuteSubLua;
set ExecCmd(m4,match) ExecuteMatchM4;
set ExecCmd(m4,sub) ExecuteSubM4;
set ExecCmd(mawk,match) ExecuteMatchMawk;
set ExecCmd(mawk,sub) ExecuteSubMawk;
set ExecCmd(minised,match) ExecuteMatchMinised;
set ExecCmd(minised,sub) ExecuteSubMinised;
set ExecCmd(mysql,match) ExecuteMatchMysql;
set ExecCmd(nawk,match) ExecuteMatchNawk;
set ExecCmd(nawk,sub) ExecuteSubNawk;
set ExecCmd(nrgrep,match) ExecuteMatchNrgrep;
set ExecCmd(numgrep,match) ExecuteMatchNumgrep;
set ExecCmd(patmatch,match) ExecuteMatchPatmatch;
set ExecCmd(pcregrep,match) ExecuteMatchPcregrep;
set ExecCmd(perl,match) ExecuteMatchPerl;
set ExecCmd(perl,sub) ExecuteSubPerl;
set ExecCmd(php,match) ExecuteMatchPhp;
set ExecCmd(php,sub) ExecuteSubPhp;
set ExecCmd(pike,match) ExecuteMatchPike;
set ExecCmd(pike,sub) ExecuteSubPike;
set ExecCmd(python,match) ExecuteMatchPython;
set ExecCmd(python,sub) ExecuteSubPython
set ExecCmd(rc,match) ExecuteMatchRc;
set ExecCmd(rebol,match) ExecuteMatchRebol;
set ExecCmd(rep,match) ExecuteMatchRep;
set ExecCmd(ruby,match) ExecuteMatchRuby;
set ExecCmd(ruby,sub) ExecuteSubRuby;
set ExecCmd(sed,match)  ExecuteMatchSed;
set ExecCmd(sed,sub)  ExecuteSubSed;
set ExecCmd(sgrep,match) ExecuteMatchSgrep;
set ExecCmd(sleep,match)  ExecuteMatchSleep;
set ExecCmd(sleep,sub)  ExecuteSubSleep;
set ExecCmd(sleepwc,match)  ExecuteMatchSleepWildcard;
set ExecCmd(ssed,match)  ExecuteMatchSsed;
set ExecCmd(ssed,sub)  ExecuteSubSsed;
set ExecCmd(tcl,match) ExecuteMatchTcl;
set ExecCmd(tcl,sub) ExecuteSubTcl;
set ExecCmd(tclglob,match) ExecuteMatchTclGlob;
set ExecCmd(tcsh,match) ExecuteMatchTcsh;
set ExecCmd(tr,sub) ExecuteSubTr;
set ExecCmd(vim,match) ExecuteMatchVim;
set ExecCmd(vim,sub) ExecuteSubVim;
set ExecCmd(wmagrep,match) ExecuteMatchWMAgrep;
set ExecCmd(wmagrep,match,ExactMatchTRE) "-1";#   Flag needed for palette test.
set ExecCmd(wmagrep,match,ExactMatchWD) "-1";#   Flag needed for palette test.
set ExecCmd(xmlstarlet,match) ExecuteMatchXmlstarlet;
set ExecCmd(zsh,match) ExecuteMatchZsh;

#This maps the language name onto the name of the interpreter/program
set ExecName(agrep) agrep;
set ExecName(arena) arena;
set ExecName(awk) awk;
set ExecName(bash) bash;
set ExecName(boo) boo;
set ExecName(BusyBoxEgrep) busybox;
set ExecName(C) cc;
set ExecName(cgrep) cgrep;
set ExecName(fgrep) fgrep;
set ExecName(ed)  ed;
set ExecName(grep) grep;
set ExecName(egrep) egrep;
set ExecName(emacs) emacs;
set ExecName(euphoria) exu;
set ExecName(expr) expr;
set ExecName(fish) fish;
set ExecName(flex) flex;
set ExecName(frink) java;
set ExecName(gawk) gawk;
set ExecName(glark) glark;
set ExecName(gpp) gpp;
set ExecName(groovy) groovy;
set ExecName(guile) guile;
set ExecName(ici) ici;
set ExecName(icon) icon;
set ExecName(java) javac;
set ExecName(javascript) js;
set ExecName(jgrep) jgrep;
set ExecName(judoscript) java;
set ExecName(ksh) ksh;
set ExecName(lua) lua;
set ExecName(m4) m4;
set ExecName(mawk) mawk;
set ExecName(minised) minised;
set ExecName(mysql) mysql;
set ExecName(nawk) nawk;
set ExecName(nrgrep) nrgrep;
set ExecName(numgrep) numgrep;
set ExecName(patmatch) perl;
set ExecName(pcregrep) pcregrep;
set ExecName(perl) perl;
set ExecName(php) php;
set ExecName(pike) pike;
set ExecName(python)  python;
set ExecName(rc) rc;
set ExecName(rebol) rebol;
set ExecName(rep) rep;
set ExecName(ruby) ruby;
set ExecName(sed)  sed;
set ExecName(sgrep) sgrep;
set ExecName(sleep) java;
set ExecName(sleepwc) java;
set ExecName(ssed)  ssed;
set ExecName(tcl) tcl;
set ExecName(tclglob) tcl;
set ExecName(tcsh) tcsh;
set ExecName(tr) tr;
set ExecName(vim) vim;
set ExecName(wmagrep) wmagrep;
set ExecName(xmlstarlet) xml;
set ExecName(zsh) zsh;

set TestData(SingleOctet) "Z\u0065Z\nZ\u0565Z\nZ\u53CBZ"
set Intended(SingleOctet) "Z\u0565Z"
set TestRegexp(SingleOctet) {Z\C\CZ}

set TestData(CrossUnicodeBlockP) "e\n\u0565\u0598"
set Intended(CrossUnicodeBlockP) "\u0565\n\u0598"
set TestRegexp(CrossUnicodeBlockP) "\[\u0561\-\u0599\]"

set TestData(Range128) "e\n\u4e09"
set Intended(Range128) "\u4e09"
set TestRegexp(Range128) "\[\u4e01\-\u4f01\]"
#For some reason there is a problem with U+4E00.

set TestData(Range129) "e\n\u4e09"
set Intended(Range129) "\u4e09"
set TestRegexp(Range129) "\[\u4e01\-\u4f02\]"

#Test for glark boolean and
set TestData(BooleanAnd)   	"abc\nM\nN\nMN\nMbcN\nNbcM"
set Intended(BooleanAnd)	"MN\nMbcN\nNbcM"
set TestRegexp(BooleanAnd) 	"-a 0 M N"

#Test for Unicode collating classes: e, e-grave, e-acute, f, o-grave
set TestData(CollationClass)    "\u0065\n\u00E8\n\u00E9\n\u0066\n\u00F2";
set Intended(CollationClass)    "\u0065\n\u00E8\n\u00E9";
set TestRegexp(CollationClass) {[[=e=]]}

#Test for multicharacter collating element
#This presupposes that ch is a collating element in the current locale.
set TestData(CollatingElementMultichar)    "a\nb\nc\nch\nd\ne\nbh";
set Intended(CollatingElementMultichar)    "a\nch\ne"
set TestRegexp(CollatingElementMultichar) {[a[.ch.]e]}

set TestData(CollatingElementNamed)    ",\na\nb\nc\nch\nd\ne\nbh";
set Intended(CollatingElementNamed)    ","
set TestRegexp(CollatingElementNamed) {[[.comma.]]}

#Definitions of feature tests.

set TestData(embedding)         "AGC\nTAGCT";
set Intended(embedding)         "AGC\nTAGCT";
set TestRegexp(embedding)       {AGC};

set TestData(EmbeddingMatchOnly)         "AGC\nTAGCT";
set Intended(EmbeddingMatchOnly)         "AGC\nAGC";
set TestRegexp(EmbeddingMatchOnly)       {AGC};

set TestData(embeddingLeft)     "AGC\nTAGC\nAGCT";
set Intended(embeddingLeft)     "AGC\nTAGC";
set TestRegexp(embeddingLeft)   {AGC};

set TestData(embeddingRight)    "AGC\nTAGC\nAGCT";
set Intended(embeddingRight)    "AGC\nAGCT";
set TestRegexp(embeddingRight)  {AGC};

#Group.
set TestData(group)        "AGCAGC\nAGC\nAG";
set Intended(group)        "AGCAGC\nAGC";
set TestRegexp(group)      {(AGC)+};

#Patmatch
set TestData(GroupNoWildcards)        "AGCAGC\nAGC\nAG";
set Intended(GroupNoWildcards)        "AGCAGC"
set TestRegexp(GroupNoWildcards)      {(AGC){2}};

set TestData(groupbs)      "abcabc\nabc\nab";
set Intended(groupbs)      "abcabc\nabc";
set TestRegexp(groupbs)    {\(abc\)\+};

set TestData(groupdbsnqq)      "abcabc\nabc\nab";
set Intended(groupdbsnqq)      "abcabc\nabc";
set TestRegexp(groupdbsnqq)    {\\(abc\\)+};

set TestData(groupdbs)     "abcabc\nabc\nab";
set Intended(groupdbs)     "abcabc\nabc";
set TestRegexp(groupdbs)   {\\(abc\\)\\+};

#No capture group.
set TestData(ncgroup) "abcfgfg\nabcfgabc";
set Intended(ncgroup) "abcfgfg";
set TestRegexp(ncgroup)   {^(?:abc)(fg)\1$};

set TestData(NoCaptureGroupPercentbsall) "abcfgfg\nabcfgabc";
set Intended(NoCaptureGroupPercentbsall) "abcfgfg";
set TestRegexp(NoCaptureGroupPercentbsall)   {^\%\(abc\)\(fg\)\1$};

set TestData(ncgroupdb) "abcfgfg\nabcfgabc";
set Intended(ncgroupdb) "abcfgfg";
set TestRegexp(ncgroupdb)   {^(?:abc)(fg)\\1$};

set TestData(groupcomp) "a\nb\nc\nab\nbc\naa15d\nabc"
set Intended(groupcomp) "a\nb\nc\nab\nbc\naa15d"
set TestRegexp(groupcomp) {!(abc)}

#Maybe need to add ncgroup with single and double backslash on parentheses?


set TestData(dot) "a\nab\na4b\naxb\naxyb";
set Intended(dot) "a4b\naxb";
set TestRegexp(dot)   {a.b};

#Test for the case in which underscore matches any single character as in SQL
set TestData(UnderscoreAnySingle) "a\nab\naxb\na4b\naxyb";
set Intended(UnderscoreAnySingle) "axb\na4b";
set TestRegexp(UnderscoreAnySingle)   {a_b};

#Patmatch
set TestData(XAnySingle) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(XAnySingle) "AAG\nAGG\nACG\nATG"
set TestRegexp(XAnySingle)   {AXG};

#Patmatch
set TestData(DotAnySingle) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(DotAnySingle) "AAG\nAGG\nACG\nATG"
set TestRegexp(DotAnySingle) {A.G};

#Patmatch
set TestData(NAnySingleNucleotide) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(NAnySingleNucleotide) "AAG\nAGG\nACG\nATG"
set TestRegexp(NAnySingleNucleotide)   {ANG};

#Patmatch
set TestData(RAnySinglePurineBase) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(RAnySinglePurineBase) "AAG\nAGG"
set TestRegexp(RAnySinglePurineBase)   {ARG};

#Patmatch
set TestData(YAnySinglePyramidineBase) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(YAnySinglePyramidineBase) "ACG\nATG"
set TestRegexp(YAnySinglePyramidineBase)   {AYG};

#Patmatch
set TestData(SBaseGC) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(SBaseGC) "AGG\nACG"
set TestRegexp(SBaseGC)   {ASG};

#Patmatch
set TestData(WBaseAT) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(WBaseAT) "AAG\nATG"
set TestRegexp(WBaseAT)   {AWG};

#Patmatch
set TestData(MBaseAC) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(MBaseAC) "AAG\nACG"
set TestRegexp(MBaseAC)   {AMG};

#Patmatch
set TestData(KBaseGT) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(KBaseGT) "AGG\nATG"
set TestRegexp(KBaseGT)   {AKG};

#Patmatch
set TestData(VBaseACG) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(VBaseACG) "AAG\nAGG\nACG"
set TestRegexp(VBaseACG)   {AVG};

#Patmatch
set TestData(HBaseACT) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(HBaseACT) "AAG\nACG\nATG"
set TestRegexp(HBaseACT)   {AHG};

#Patmatch
set TestData(DBaseAGT) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(DBaseAGT) "AAG\nAGG\nATG"
set TestRegexp(DBaseAGT)   {ADG};

#Patmatch
set TestData(BBaseCGT) "AAG\nAGG\nACG\nATG\nATTG\nAG"
set Intended(BBaseCGT) "AGG\nACG\nATG"
set TestRegexp(BBaseCGT)   {ABG};

#Patmatch
set TestData(BResidueDN) "QDY\nQNY\nQTY\nQDDY\nQY\nQEY"
set Intended(BResidueDN) "QDY\nQNY"
set TestRegexp(BResidueDN)   {QBY};

#Patmatch
set TestData(ZResidueEQ) "MEY\nMQY\nMTY\nMEEY\nMY\nMDY"
set Intended(ZResidueEQ) "MEY\nMQY"
set TestRegexp(ZResidueEQ)   {MZY};

#Patmatch
set TestData(JResidueHydrophobic) "MIY\nMFY\nMVY\nMLY\nMWY\nMMY\nMAY\nMGY\nMCY\nMYY\nMTY\nMRY"
set Intended(JResidueHydrophobic) "MIY\nMFY\nMVY\nMLY\nMWY\nMMY\nMAY\nMGY\nMCY\nMYY"
set TestRegexp(JResidueHydrophobic)   {MJY};

#Patmatch
set TestData(OResidueHydrophilic) "MTY\nMSY\nMHY\nMEY\nMDY\nMQY\nMNY\nMKY\nMRY\nMIY\nMWY\nMGY"
set Intended(OResidueHydrophilic) "MTY\nMSY\nMHY\nMEY\nMDY\nMQY\nMNY\nMKY\nMRY"
set TestRegexp(OResidueHydrophilic)   {MOY};

#Patmatch 
set TestData(repmax) "AC\nAGC\nAGGC\nAGGGC"
set Intended(repmax) "AC\nAGC\nAGGC"
set TestRegexp(repmax)   {AG{,2}C};

set TestData(repmaxlbs) "AC\nAGC\nAGGC\nAGGGC"
set Intended(repmaxlbs) "AC\nAGC\nAGGC"
set TestRegexp(repmaxlbs)   "AG\\\{,2}C";

set TestData(caret) "babc\nc^c\ndbab";
set Intended(caret) "babc";
set TestRegexp(caret)   {^bab.*};

set TestData(PercentCaretBS) "babc\nc^c\ndbab";
set Intended(PercentCaretBS) "babc";
set TestRegexp(PercentCaretBS)   {\%^bab.*};

set TestData(NegativeCircumflex) "Arthur\nMcArthur"
set Intended(NegativeCircumflex) "Arthur"
set TestRegexp(NegativeCircumflex) {^(Mc)*};

set TestData(MatchNotMatchTilde) "x\ny\nz";
set Intended(MatchNotMatchTilde) "x\nz";
set TestRegexp(MatchNotMatchTilde) "?~y";

set TestData(pabegin) "babc\nc^c\ndbab";
set Intended(pabegin) "babc";
set TestRegexp(pabegin)   {\Abab.*};

set TestData(pabegindb) "babc\nc^c\ndbab";
set Intended(pabegindb) "babc";
set TestRegexp(pabegindb)   {\\Abab.*};

set TestData(caretw) "babc\nc^c\ndbab";
set Intended(caretw) "babc";
set TestRegexp(caretw)   {^bab};

set TestData(boslq) "babc\nc^c\ndbab";
set Intended(boslq) "babc";
set TestRegexp(boslq)   {\`bab.*};

set TestData(dollar) "bab\nbabd";
set Intended(dollar) "bab";
set TestRegexp(dollar)   {bab$};

set TestData(GreaterThanEnd) "TGAGC\nAGC\nAGCC\nAGCT"
set Intended(GreaterThanEnd) "AGC\nAGC"
set TestRegexp(GreaterThanEnd) {AGC>}

set TestData(PercentDollarBS) "bab\nbabd\nbab";
set Intended(PercentDollarBS) "bab";
set TestRegexp(PercentDollarBS)   {bab\%$};

set TestData(LessThanBeginning) "TGAGC\nTAGC\nAGC\nAGCCT"
set Intended(LessThanBeginning) "AGC\nAGC"
set TestRegexp(LessThanBeginning) {<AGC}

set TestData(LiteralMetachar) "a\na\$b\nab";
set Intended(LiteralMetachar) {a$b};
set TestRegexp(LiteralMetachar) {a\$b};

set TestData(eosrq) "cbab\nc\$c\nbabd";
set Intended(eosrq) "cbab";
set TestRegexp(eosrq)   {.*bab\'};

set TestData(AbsoluteEndOfString)   "a\nab"
set Intended(AbsoluteEndOfString)   "a"
set TestRegexp(AbsoluteEndOfString) "a\n$"

set TestData(pzendbs) "cbab\nc\$c\nbabd";
set Intended(pzendbs) "cbab";
set TestRegexp(pzendbs)   {.*bab\z};

set TestData(pZendbs) "cbab\nc\$c\nbabd";
set Intended(pZendbs) "cbab";
set TestRegexp(pZendbs)   {.*bab\Z};

set TestData(pzenddbs) "cbab\nc\$c\nbabd";
set Intended(pzenddbs) "cbab";
set TestRegexp(pzenddbs)   {.*bab\\z};

set TestData(pZenddbs) "cbab\nc\$c\nbabd";
set Intended(pZenddbs) "cbab";
set TestRegexp(pZenddbs)   {.*bab\\Z};

set TestData(dollarw) "cbab\nc\$c\nbabd";
set Intended(dollarw) "cbab";
set TestRegexp(dollarw)   {bab$};

set TestData(langle)  "abc\na abc\na\tabc\naxabc";
set Intended(langle)  "abc\na abc\na\tabc";
set TestRegexp(langle)    {\<abc};

set TestData(BeginWordm)  "abc\na abc\na\tabc\naxabc";
set Intended(BeginWordm)  "abc\na abc\na\tabc";
set TestRegexp(BeginWordm)    {\mabc};

set TestData(LangleClass)  "abc\na abc\na\tabc\naxabc";
set Intended(LangleClass)  "abc\na abc\na\tabc";
set TestRegexp(LangleClass)    {[[:<:]]abc};

set TestData(rangle)  "abc\nabc d\nabc\td\nabcxd";
set Intended(rangle)  "abc\nabc d\nabc\td";
set TestRegexp(rangle)    {abc\>};

set TestData(EndWordM)  "abc\nabc d\nabc\td\nabcxd";
set Intended(EndWordM)  "abc\nabc d\nabc\td";
set TestRegexp(EndWordM)    {abc\M};

set TestData(RangleClass)  "abc\nabc d\nabc\td\nabcxd";
set Intended(RangleClass)  "abc\nabc d\nabc\td";
set TestRegexp(RangleClass)    {abc[[:>:]]};

set TestData(WordBoundary) "ab\n ab \n\tab\t\n;ab;\n3ab\nab_\nxab\nabx\nxabx"
set Intended(WordBoundary) "ab\n ab \n\tab\t\n;ab;"
set TestRegexp(WordBoundary) {\bab\b}

set TestData(WordBoundaryBs) "ab\n ab \n\tab\t\n;ab;\n3ab\nab_\nxab\nabx\nxabx"
set Intended(WordBoundaryBs) "ab\n ab \n\tab\t\n;ab;"
set TestRegexp(WordBoundaryBs) {\\bab\\b}

set TestData(WordBoundaryybs) "ab\n ab \n\tab\t\n;ab;\n3ab\nab_\nxab\nabx\nxabx"
set Intended(WordBoundaryybs) "ab\n ab \n\tab\t\n;ab;"
set TestRegexp(WordBoundaryybs) {\yab\y}

set TestData(NonWordBoundaryYbs)  "axb\na b"
set Intended(NonWordBoundaryYbs) "axb"
set TestRegexp(NonWordBoundaryYbs) {ax\Yb}

set TestData(WordBoundaryydbs) "ab\n ab \n\tab\t\n;ab;\n3ab\nab_\nxab\nabx\nxabx"
set Intended(WordBoundaryydbs) "ab\n ab \n\tab\t\n;ab;"
set TestRegexp(WordBoundaryydbs) {\\yab\\y}

set TestData(NonWordBoundary) "ab\n ab \n\tab\t\n;ab;\n3ab4\n_ab_\nxabx"
set Intended(NonWordBoundary) "3ab4\n_ab_\nxabx"
set TestRegexp(NonWordBoundary) {\Bab\B}

#Disjunctions

set TestData(pipe)  "xaz\nxbz\nxcz\nxz\xooz";
set Intended(pipe)  "xaz\nxbz";
set TestRegexp(pipe)    {x(a|b)z};

set TestData(pipebs)  "xaz\nxbz\nxcz\nxz\nxooz";
set Intended(pipebs)  "xaz\nxbz";
set TestRegexp(pipebs)   {x(a\|b)z};

set TestData(pipedbs)  "xaz\nxbz\nxcz\nxz\nxooz";
set Intended(pipedbs)  "xaz\nxbz";
set TestRegexp(pipedbs)   {x(a\\|b)z};

set TestData(pipebsall)     "xaz\nxbz\nxcz\nxz\nxooz";
set Intended(pipebsall)     "xaz\nxbz";
set TestRegexp(pipebsall)   {x\(a\|b\)z};

set TestData(pipedbsall)     "xaz\nxbz\nxcz\nxz\nxooz";
set Intended(pipedbsall)     "xaz\nxbz";
set TestRegexp(pipedbsall)   {x\\(a\\|b\\)z};

set TestData(piperebol)    "xaz\nxbz\nxcz\nxz\xooz";
set Intended(piperebol)    "xaz\nxbz";
set TestRegexp(piperebol)  {"x"["a"|"b"]"z"};

set TestData(altcomma)  "xaz\nxbz\nxcz\nxdz";
set Intended(altcomma)  "xaz\nxbz\nxcz";
set TestRegexp(altcomma)    {x{a,b,c}z}

#Test for the case in which ? matches zero or one of the preceding regexp.
set TestData(qmopt) "ababcd\nabcd\nabab?cd";
set Intended(qmopt) "ababcd\nabcd";
set TestRegexp(qmopt)   {ab(ab)?cd};

set TestData(qmoptclass) "a\na3\nab\na;";
set Intended(qmoptclass) "a\na3";
set TestRegexp(qmoptclass)   {a%d?$};

#Test for the case in which ? matches zero or one of the preceding regexp.
set TestData(qmoptbs) "xyabcd\nxycd\nxyab?cd\nxyababcd";
set Intended(qmoptbs) "xyabcd\nxycd"
set TestRegexp(qmoptbs)   {xy\(ab\)\?cd};

#Test for the case in which - matches zero or one of the preceding regexp.
set TestData(EqualOptbs) "xyabcd\nxycd\nxyab\=cd\nxyababcd";
set Intended(EqualOptbs) "xyabcd\nxycd";
set TestRegexp(EqualOptbs)   {xy\(ab\)\=cd};

#Test for the case in which ? matches zero or one of the preceding regexp.
set TestData(qmoptdbsnqq) "ababcd\nabcd\nabab?cd";
set Intended(qmoptdbsnqq) "ababcd\nabcd";
set TestRegexp(qmoptdbsnqq)   {ab\\(ab\\)?cd};

#Test for the case in which ? matches zero or one of the following group
set TestData(qmoptnext) "ababcd\nabcd\nabab?cd";
set Intended(qmoptnext) "ababcd\nabcd";
set TestRegexp(qmoptnext)   {ab?(ab)cd};

#Test for the case in which ? matches any single character.
set TestData(qm1) "fag\nfabg\nfasg\nfabcg\nfdag";
set Intended(qm1) "fabg\nfasg";
set TestRegexp(qm1)   {fa?g};

#Test for the case in which ? matches any single character.
set TestData(qm1bs) "fag\nfabg\nfasg\nfabcg\nfdag";
set Intended(qm1bs) "fabg\nfasg";
set TestRegexp(qm1bs)   {fa\?g};

#Test for the case in which * matches zero or more copies of the preceding re
set TestData(StarPrev) "AG\nATG\nATTG\nATTTG\nAaG\nAT*G";
set Intended(StarPrev) "AG\nATG\nATTG\nATTTG"
set TestRegexp(StarPrev)   {AT*G};

#Test for the case in which * matches zero or more copies of the preceding re
set TestData(ZeroOrMoreCurly) "AG\nATG\nATTG\nATTTG\nAaG\nAT*G";
set Intended(ZeroOrMoreCurly) "AG\nATG\nATTG\nATTTG"
set TestRegexp(ZeroOrMoreCurly)   "AT\\\{\}G";

#Test for the case in which \# matches zero or more copies of the preceding group
set TestData(CrosshatchPrev) "xz\nxbz\nxbbz\nxbbbz\nxaz\nxb*z";
set Intended(CrosshatchPrev) "xz\nxbz\nxbbz\nxbbbz"
set TestRegexp(CrosshatchPrev)   {xb#z};

#Test for the case in which \#\# matches one or more copies of the preceding group
set TestData(DoubleCrosshatchPrev) "xz\nxbz\nxbbz\nxbbbz\nxaz\nxb*z";
set Intended(DoubleCrosshatchPrev) "xbz\nxbbz\nxbbbz"
set TestRegexp(DoubleCrosshatchPrev)   {xb##z};

#Test for the case in which * matches zero or more copies of the following group
set TestData(StarNext) "xz\nxabz\nxababz\nx*(ab)z\nabz\nxab\nxaz\n3d"
set Intended(StarNext) "xz\nxabz\nxababz"
set TestRegexp(StarNext)   {x*(ab)z};

#Test for the case in which * matches zero or more copies of the preceding class
set TestData(starclass) "xz\nx1z\nx22z\nx867z\nxdz\nx%dz";
set Intended(starclass) "xz\nx1z\nx22z\nx867z"
set TestRegexp(starclass)   {x%d*z};

#Test for the case in which - matches zero or more copies of the preceding class (reluctant)
set TestData(SubHyphenClass)     "aBBBBa";
set Intended(SubHyphenClass)     "BBBB";
set TestRegexp(SubHyphenClass)   {(a)(%u-)(%u*)(a)};
set TestSubexp(SubHyphenClass)   {%3};

#Test for the case in which * matches zero or more of any character
set TestData(StarAny) "TAG\nTCG\nTACG\nTACCG\nTACCCG\nTACCCCG\nTACCCCCG\nTACcG\nTACdG";
set Intended(StarAny) "TACG\nTACCG\nTACCCG\nTACCCCG\nTACCCCCG\nTACcG\nTACdG";
set TestRegexp(StarAny)  {TAC*G};

#Test for the case in which % matches zero or more of any character as in SQL
set TestData(PercentAny) "xaz\nxbz\nxabz\nxabbz\nxabbbz\nxabbbbz\nxabbbbbz\nxabcz\nxabdz";
set Intended(PercentAny)           "xabz\nxabbz\nxabbbz\nxabbbbz\nxabbbbbz\nxabcz\nxabdz";
set TestRegexp(PercentAny)   {xab%z};

#Test for the case in which + matches one or more copies of the preceding re
set TestData(plusprev) "xz\nxbz\nxbbz\nxbbbz\nxaz\nxb*z";
set Intended(plusprev) "xbz\nxbbz\nxbbbz"
set TestRegexp(plusprev) {xb+z};

#Test for the case in which + matches one or more copies of the following group
set TestData(plusnext) "xz\nxabz\nxababz\nx*(ab)z\nabz\nxab\nxaz\n3d"
set Intended(plusnext) "xabz\nxababz"
set TestRegexp(plusnext)   {x+(ab)z};

#Test for the case in which + matches one or more copies of the following group
set TestData(atsignonenext) "xabz\nxcdz\nxz\nxabcdz\nef"
set Intended(atsignonenext) "xabz\nxcdz"
set TestRegexp(atsignonenext)   {x@(ab|cd)z};

#Test for the case in which \+ matches one or more copies of the preceding re
set TestData(plusprevbs) "xz\nxbz\nxbbz\nxbbbz\nxaz\nxb+z";
set Intended(plusprevbs) "xbz\nxbbz\nxbbbz"
set TestRegexp(plusprevbs) {xb\+z};

#Test for the case in which + matches one or more copies of the preceding class
set TestData(plusclass) "xz\nx1z\nx22z\nx867z\nxdz\nx%dz";
set Intended(plusclass) "x1z\nx22z\nx867z"
set TestRegexp(plusclass)  {x%d+z}; 

#Test for the case in which \+ matches one or more copies of any character
set TestData(plusany) "xaz\nxabz\nxabbz\nxabbbz\nxabbbbz\nxabbbbbz\nxabcz\nxbz\nxabdz";
set Intended(plusany) "xabz\nxabbz\nxabbbz\nxabbbbz\nxabbbbbz\nxabcz\nxabdz";
set TestRegexp(plusany) {xab\+z};

#Test for the case in which crosshatch matches one or more copies of any character
set TestData(crosshatchany) "xaz\nxabz\nxabbz\nxabbbz\nxabbbbz\nxabbbbbz\nxabcz\nxbz\nxabdz";
set Intended(crosshatchany) "xabz\nxabbz\nxabbbz\nxabbbbz\nxabbbbbz\nxabcz\nxabdz";
set TestRegexp(crosshatchany) {xab#z};

#Test for construction in which exactly n copies of preceding group are matched.
set TestData(repfixed)  "AC\nAGC\nAGGC\nAGGGC\nAGGGGC"
set Intended(repfixed)  "AGGGC";
set TestRegexp(repfixed)   {AG{3}C};

#Test for Lua balanced delimiter construct
set TestData(baldlim) "ab<cd>ef\nabcdef";
set Intended(baldlim) "ab<cd>ef";
set TestRegexp(baldlim)   {%b<>};

#Test for construction in which exactly n copies of preceding group are matched.
set TestData(repfixedbs) "xbz\nxbbz\nxbbbz\nxbbbbz";
set Intended(repfixedbs) "xbbbz";
set TestRegexp(repfixedbs)   {xb\{3\}z};

#Test for construction in which exactly n copies of preceding group are matched.
set TestData(repfixeddbs) "xbz\nxbbz\nxbbbz\nxbbbbz";
set Intended(repfixeddbs) "xbbbz";
set TestRegexp(repfixeddbs)   {xb\\{3\\}z};

#Test for construction in which at least n copies of preceding group are matched.
set TestData(repmin) "AC\nAGC\nAGGC\nAGGGC\nAGGGGC"
set Intended(repmin) "AGGGC\nAGGGGC"
set TestRegexp(repmin)   {AG{3,}C};

#Test for construction in which at least n copies of preceding group are matched.
set TestData(repminbs) "xbz\nxbbz\nxbbbz\nxbbbbz";
set Intended(repminbs) "xbbbz\nxbbbbz";
set TestRegexp(repminbs)   {xb\{3,\}z};

#Test for construction in which at least n copies of preceding group are matched.
set TestData(repmindbs) "xbz\nxbbz\nxbbbz\nxbbbbz";
set Intended(repmindbs) "xbbbz\nxbbbbz";
set TestRegexp(repmindbs)   {xb\\{3,\\}z};

#Test for construction in which from m to n copies of preceding group are matched.
set TestData(reprange)  "AC\nAGC\nAGGC\nAGGGC\nAGGGGC"
set Intended(reprange)  "AGGC\nAGGGC"
set TestRegexp(reprange)  {AG{2,3}C};

#Test for construction in which from m to n copies of preceding group are matched.
#Here, curly brackets must be escaped.
set TestData(reprangebs) "xbz\nxbbz\nxbbbz\nxbaz\nxaaaz";
set Intended(reprangebs) "xbbz\nxbbbz";
set TestRegexp(reprangebs)  {xb\{2,3\}z};

#Test for construction in which from m to n copies of preceding group are matched.
#Here, left curly braces are escaped.
set TestData(reprangelbs) "xbz\nxbbz\nxbbbz\nxbaz\nxaaaz";
set Intended(reprangelbs) "xbbz\nxbbbz";
set TestRegexp(reprangelbs) "xb\\\{2,3}z"

#Test for construction in which from m to n copies of preceding group are matched.
#Here, curly brackets must be escaped by double backslashes..
set TestData(reprangedbs) "xbz\nxbbz\nxbbbz\nxbaz\nxaaaz";
set Intended(reprangedbs) "xbbz\nxbbbz";
set TestRegexp(reprangedbs)  {xb\\{2,3\\}z};

#Test whether bracket notation for sets is supported
set TestData(set) "AAT\nACT\nAGT\nATT\nAUT\nAfT"
set Intended(set) "AAT\nACT\nAGT"
set TestRegexp(set)   {A[ACG]T};

#Test whether caret-bracket notation for the complement of sets is supported
set TestData(setcomp) "AAT\nACT\nAGT\nATT\nAUT\nAfT\n"
set Intended(setcomp) "ATT\nAUT\nAfT"
set TestRegexp(setcomp)   {A[^ACG]T};

#Test whether tilde-bracket notation for the complement of sets is supported
set TestData(setcomptilde) "x\ny\nz\na\nf\n4\n";
set Intended(setcomptilde) "a\nf\n4";
set TestRegexp(setcomptilde)   {[~xyz]};

#Test whether bang-bracket notation for the complement of sets is supported
set TestData(setcompbang) "x\ny\nz\na\nf\n4\n";
set Intended(setcompbang) "a\nf\n4";
set TestRegexp(setcompbang)   {[!xyz]};

#Test whether character ranges are supported
set TestData(range) "x\ny\nz\na\nf\n4";
set Intended(range) "x\ny\nz";
set TestRegexp(range)   {[x-z]};

#Test whether multiple character ranges are supported
set TestData(multirange) "x\ny\nz\na\nb\nc\ns\nf\n4\n";
set Intended(multirange) "x\ny\nz\na\nb\nc\ns\n";
set TestRegexp(multirange)   {[a-csx-z]};

#Test whether number ranges are supported
set TestData(IntegerRange) "9\n10\n11\n1\n5\n27\n"
set Intended(IntegerRange) "9\n10\n11"
set TestRegexp(IntegerRange)   {<9-11>};

#Test whether numgrep-style number ranges are supported
set TestData(IntegerRangeDoubleDot) "9\n10\n11\n1\n5\n27\n"
set Intended(IntegerRangeDoubleDot) "9\n10\n11"
set TestRegexp(IntegerRangeDoubleDot)  {9..11};

#Test whether numgrep-style multiples are supported
set TestData(IntegerMultiple) "3\n6\n9\n12\n36\n5\n2\n88\n7\n"
set Intended(IntegerMultiple) "3\n6\n9\n12\n36"
set TestRegexp(IntegerMultiple)  {m3};

#Test whether numgrep-style factors are supported
set TestData(IntegerFactor) "2\n3\n4\n6\n5\n7\n8\n9\n13\n24\n"
set Intended(IntegerFactor) "2\n3\n4\n6"
set TestRegexp(IntegerFactor)  "f12";

#Test whether numgrep-style alternatives are supported
set TestData(IntegerAlternative) "5\n7\n11\n2\n3\n75\n110\n"
set Intended(IntegerAlternative) "5\n7\n11"
set TestRegexp(IntegerAlternative)  {5,7,11};

#Test whether match back references are supported
set TestData(backref) "abcdedebc\nabcdeedcba";
set Intended(backref) "abcdedebc";
set TestRegexp(backref)   {a(bc)(de)\2\1};

set TestData(backrefAtLeastTen) "abcdefghijklj\nabcdefghijkl";
set Intended(backrefAtLeastTen) "abcdefghijklj";
set TestRegexp(backrefAtLeastTen) {(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\10}

set TestData(backrefdbs) "abcdedebc\nabcdeedcba";
set Intended(backrefdbs) "abcdedebc";
set TestRegexp(backrefdbs)   {a(bc)(de)\\2\\1};

set TestData(backrefdbsAtLeastTen) "abcdefghijklj\nabcdefghijkl";
set Intended(backrefdbsAtLeastTen) "abcdefghijklj";
set TestRegexp(backrefdbsAtLeastTen) {(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\\10}

set TestData(backrefksh) "abcdedebc\nabcdeedcba";
set Intended(backrefksh) "abcdedebc";
set TestRegexp(backrefksh)   {a@(bc|pq)@(de|sr)\2\1};

set TestData(backrefkshAtLeastTen) "abcdefghijklj\nabcdefghijkl";
set Intended(backrefkshAtLeastTen) "abcdefghijklj";
set TestRegexp(backrefkshAtLeastTen) {@(a|z)@(b|y)@(c|x)@(d|w)@(e|v)@(f|u)@(g|t)@(h|s)@(i|r)@(j|q)@(k|p)@(l|o)\10}

set TestData(backrefper) "abcdedebc\nabcdeedcba";
set Intended(backrefper) "abcdedebc";
set TestRegexp(backrefper)   {a(bc)(de)%2%1};

set TestData(backrefperAtLeastTen) "abcdefghijklj\nabcdefghijkl";
set Intended(backrefperAtLeastTen) "abcdefghijklj";
set TestRegexp(backrefperAtLeastTen) {(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)%10}

set TestData(backrefbsall)       "abcdedebc\nabcdeedcba";
set Intended(backrefbsall)       "abcdedebc";
set TestRegexp(backrefbsall)     {a\(bc\)\(de\)\2\1};

set TestData(backrefbsallAtLeastTen) "abcdefghijklj\nabcdefghijkl";
set Intended(backrefbsallAtLeastTen) "abcdefghijklj";
set TestRegexp(backrefbsallAtLeastTen) {\(a\)\(b\)\(c\)\(d\)\(e\)\(f\)\(g\)\(h\)\(i\)\(j\)\(k\)\(l\)\10}

set TestData(backrefdbsall)       "abcdedebc\nabcdeedcba";
set Intended(backrefdbsall)       "abcdedebc";
set TestRegexp(backrefdbsall)     {a\\(bc\\)\\(de\\)\\2\\1};

set TestData(backrefdbsallAtLeastTen) "abcdefghijklj\nabcdefghijkl";
set Intended(backrefdbsallAtLeastTen) "abcdefghijklj";
set TestRegexp(backrefdbsallAtLeastTen) {\\(a\\)\\(b\\)\\(c\\)\\(d\\)\\(e\\)\\(f\\)\\(g\\)\\(h\\)\\(i\\)\\(j\\)\\(k\\)\\(l\\)\\10}

set TestData(commaor)      "dog\ncat\ndogcat\ndogncat\ncatndog\ndigncat\ndeogbcant\ndig";
set Intended(commaor)      "dog\ncat\ndogcat\ndogncat\ncatndog\ndigncat";
set TestRegexp(commaor)     {dog,cat};

set TestData(semiand)      "dog\ncat\ndogcat\ndogncat\ncatndog\ndig\ndigncat\ndeogbcant"
set Intended(semiand)      "dogcat\ndogncat\ncatndog";
set TestRegexp(semiand)     {dog;cat};

set TestData(ampandbs)      "dog\ncat\ndogcat\ndogncat\ncatndog\ndig\ndigncat\ndeogbcant"
set Intended(ampandbs)      "dogcat\ndogncat\ncatndog";
set TestRegexp(ampandbs)     {.*dog\&.*cat};

#This is for agrep and requires using the command line flag allowing errors.
set TestData(anglestrict)      "abc\naxc\nbbc\nabd";
set Intended(anglestrict)      "abc";
set TestRegexp(anglestrict)   {<abc>};

#Test the various named character sets
		    
set TestData(alnum) "Za\nZB\nZc\nZZ\nZ+\nZ4\nZ:\nZ?\nZ_";
set Intended(alnum) "Za\nZB\nZc\nZZ\nZ4";
set TestRegexp(alnum)   {Z[[:alnum:]]};

set TestData(wordclass) "Za\nZB\nZc\nZZ\nZ+\nZ4\nZ:\nZ?\nZ_";
set Intended(wordclass) "Za\nZB\nZc\nZZ\nZ4\nZ_";
set TestRegexp(wordclass)   {Z[[:word:]]};

set TestData(alnumrebol) "a\nB\nc\nZ\n+\n4\n:\n?\n_";
set Intended(alnumrebol) "a\nB\nc\nZ\n4";
set TestRegexp(alnumrebol)   {[alnum]};

set TestData(lalnum) "a\nB\nc\nZ\n+\n4\n:\n?\n_";
set Intended(lalnum) "a\nB\nc\nZ\n4";
set TestRegexp(lalnum)   {%w};

set TestData(lalnumc) "aac\naBc\nacc\naZc\na+c\na4c\na:c\na?c\na\040c\na_c";
set Intended(lalnumc) "a+c\na:c\na?c\na\040c\na_c";
set TestRegexp(lalnumc)   {a%Wc};

set TestData(bsw)   "abc\n4bc\n:bc\n bc\n\tbc\n_bc";
set Intended(bsw)   "abc\n4bc";
set TestRegexp(bsw)     {^\wbc};

set TestData(pbsw)   "abc\n4bc\n:bc\n bc\n\tbc\n_bc";
set Intended(pbsw)   "abc\n4bc\n_bc";
set TestRegexp(pbsw)     {^\wbc};

set TestData(pbbsw)   "abc\n4bc\n:bc\n bc\n\tbc\n_bc";
set Intended(pbbsw)   "abc\n4bc\n_bc";
set TestRegexp(pbbsw)     {^\\wbc};


set TestData(bsW)   "abc\n4bc\n:bc\n bc\n\tbc\n_bc";
set Intended(bsW)   ":bc\n bc\n\tbc\n_bc";
set TestRegexp(bsW)   {^\Wbc};

set TestData(bsWdb)   "abc\n4bc\n:bc\n bc\n\tbc\n_bc";
set Intended(bsWdb)   ":bc\n bc\n\tbc\n_bc";
set TestRegexp(bsWdb)   {^\\Wbc};

set TestData(pbsW)   "abc\n4bc\n:bc\n bc\n\tbc\n_bc";
set Intended(pbsW)   ":bc\n bc\n\tbc";
set TestRegexp(pbsW)  {^\Wbc};

set TestData(alpha) "Za\nZB\nZc\nZZ\nZ+\nZ4\nZ:\nZ?";
set Intended(alpha) "Za\nZB\nZc\nZZ";
set TestRegexp(alpha)   {Z[[:alpha:]]};

set TestData(alpharebol) "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(alpharebol) "a\nB\nc\nZ";
set TestRegexp(alpharebol)   {alpha};

set TestData(lalpha) "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(lalpha) "a\nB\nc\nZ";
set TestRegexp(lalpha)   {%a};

set TestData(AlphaBSa) "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(AlphaBSa) "a\nB\nc\nZ";
set TestRegexp(AlphaBSa)   {\a};

set TestData(lalphac) "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(lalphac) "+\n4\n:\n?";
set TestRegexp(lalphac)   {%A};

set TestData(AlphaBSAc) "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(AlphaBSAc) "+\n4\n:\n?";
set TestRegexp(AlphaBSAc)   {\A};

set TestData(WordBSw) "Za\nZB\nZc\nZZ\nZ+\nZ4\nZ:\nZ?\nZ_";
set Intended(WordBSw) "Za\nZB\nZc\nZZ\nZ4\nZ_";
set TestRegexp(WordBSw)   {Z\w};

set TestData(WordBSWc) "Za\nZB\nZc\nZZ\nZ+\nZ4\nZ:\nZ?\nZ_";
set Intended(WordBSWc) "Z+\nZ:\nZ?\nZ_";
set TestRegexp(WordBSWc)   {Z\W};

set TestData(WordHeadBSh) "Za\nZB\nZc\nZZ\nZ+\nZ4\nZ:\nZ?\nZ_";
set Intended(WordHeadBSh) "Za\nZB\nZc\nZZ\nZ_";
set TestRegexp(WordHeadBSh)   {Z\h};

set TestData(WordHeadBSHc) "Za\nZB\nZc\nZZ\nZ+\nZ4\nZ:\nZ?\nZ_";
set Intended(WordHeadBSHc) "Z+\nZ4\nZ:\nZ?";
set TestRegexp(WordHeadBSHc)   {Z\H};

set TestData(XMLInitial)	"_\n:\na\nA\n\u0562\n\u1109\n\u4E01\n3\n?\n\t"
set Intended(XMLInitial)	"_\n:\na\nA\n\u0562\n\u1109\n\u4E01"
set TestRegexp(XMLInitial)   {\i};

set TestData(XMLInitialc)	"_\n:\na\nA\n\u0562\n\u1109\n\u4E01\n3\n?\n\t"
set Intended(XMLInitialc)	"3\n?\n\t"
set TestRegexp(XMLInitialc)   {\I};

set Palette(XMLInitial,gloss)    [_ {one word head character}];
set Palette(XMLInitial,re)    [list {\\i F}];
set Palette(XMLInitial,link)    [list XMLInitial]

set Palette(XMLInitialc,gloss)    [_ {one non-word head character}];
set Palette(XMLInitialc,re)    [list {\\I F}];
set Palette(XMLInitialc,link)    [list XMLInitial]

set TestData(lower) "AaZ\nABZ\nAcZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set Intended(lower) "AaZ\nAcZ";
set TestRegexp(lower)   {A[[:lower:]]Z};

set TestData(lowerrebol) "AaZ\nABZ\nAcZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set Intended(lowerrebol) "AaZ\nAcZ";
set TestRegexp(lowerrebol)   {#"A"[lower]#"Z"};

set TestData(llower) "AaZ\nABZ\nAcZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set Intended(llower) "AaZ\nAcZ";
set TestRegexp(llower)   {A%lZ};

set TestData(llowerc) "AAZ\nA:Z\nA2Z\nAaB\nAbZ";
set Intended(llowerc) "AAZ\nA:Z\nA2Z";
set TestRegexp(llowerc)   {A%LZ};

set TestData(upper) "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z";
set Intended(upper) "aBz\naZz";
set TestRegexp(upper)   {a[[:upper:]]z};

set TestData(upperrebol) "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z";
set Intended(upperrebol) "aBz\naZz";
set TestRegexp(upperrebol)   {#"a"[upper]#"z"};

#W3 character classes
#XML Schema Part 2 says that \s = [#x20\t\n\r], so evidently VT and FF are excluded
set TestData(W3Space) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(W3Space) "a\040b\na\011b";
set TestRegexp(W3Space)   {a\sb};

set TestData(W3Spacec) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(W3Spacec) "a\014b\na\013b\na4b\na:b\nacb";
set TestRegexp(W3Spacec)   {a\Sb};

#\i = Letter U underscore
#\c = NameChars
#\d = \p{Nd}
#\w = [#x0000-#x10FFFF]-[\p{P}\p{Z}\p{C}]

#W3 character class subtraction
set TestData(W3CharClassSubtraction) "a\nd\n\t\nb\nc"
set Intended(W3CharClassSubtraction) "a\nd\n\t"
set TestRegexp(W3CharClassSubtraction)   {[\ta-d]-[bc]]};

#Lua character classes
set TestData(lupper) "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z";
set Intended(lupper) "aBz\naZz";
set TestRegexp(lupper)   {a%uz};

set TestData(lupperc) "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z";
set Intended(lupperc) "aaz\nacz\na+z\na4z\na:z\na?z";
set TestRegexp(lupperc)   {a%Uz};

set TestData(punct) "aaz\naBz\nacz\naZz\na4z\na:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z";
set Intended(punct) "a:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z";
set TestRegexp(punct)   {a[[:punct:]]z};

set TestData(lpunct) "aaz\naBz\nacz\naZz\na4z\na:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z";
set Intended(lpunct) "a:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z";
set TestRegexp(lpunct)   {a%pz};

set TestData(lpunctc) "aaz\naBz\nacz\naZz\na4z\na:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z\na\040z";
set Intended(lpunctc) "aaz\naBz\nacz\naZz\na4z\na\040z";
set TestRegexp(lpunctc)   {a%Pz};

set TestData(blank) "a\040b\na\011b\na\n4\n:";
set Intended(blank) "a\040b\na\011b";
set TestRegexp(blank)   {a[[:blank:]]b};

set TestData(space) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(space) "a\040b\na\014b\na\011b\na\013b";
set TestRegexp(space)   {a[[:space:]]b};

set TestData(lspace) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(lspace) "a\040b\na\014b\na\011b\na\013b";
set TestRegexp(lspace)   {a%sb};

set TestData(pspace) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(pspace) "a\040b\na\014b\na\011b\na\013b";
set TestRegexp(pspace)   {a\sb};

set TestData(pspacedb) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(pspacedb) "a\040b\na\014b\na\011b\na\013b";
set TestRegexp(pspacedb)   {a\\sb};

set TestData(lspacec) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(lspacec) "a4b\na:b\nacb";
set TestRegexp(lspacec)   {a%Sb};

set TestData(pspacec) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(pspacec) "a4b\na:b\nacb";
set TestRegexp(pspacec)   {a\Sb};

set TestData(pspacedbc) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(pspacedbc) "a4b\na:b\nacb";
set TestRegexp(pspacedbc)   {a\\Sb};

set TestData(graph) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(graph) "aab\naAb\na4b\na:b";
set TestRegexp(graph)   {a[[:graph:]]b};

set TestData(print) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(print) "aab\naAb\na4b\na:b\na\040b";
set TestRegexp(print)   {a[[:print:]]b};

set TestData(perlprint) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(perlprint) "aab\naAb\na4b\na:b\na\040b\na\011b";
set TestRegexp(perlprint)   {a[[:print:]]b};

set TestData(mockprint) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(mockprint) "aab\naAb\na4b"
set TestRegexp(mockprint)   {a[[:print:]]b};

set TestData(cntrl) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b\na\177b";
set Intended(cntrl) "a\011b\na\023b\na\177b";
set TestRegexp(cntrl)   {a[[:cntrl:]]b};

set TestData(lcntrl) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b\na\177b";
set Intended(lcntrl) "a\011b\na\023b\na\177b";
set TestRegexp(lcntrl)   {a%cb};

set TestData(lcntrlc) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b\na\177b";
set Intended(lcntrlc) "aab\naAb\na4b\na:b\na\040b";
set TestRegexp(lcntrlc)   {a%Cb};

set TestData(digit) "ZA\nZ:\nZB\nZb\nZ1\nZ2\nZ3\nZ4\nZ5\nZ6\nZ7\nZ8\nZ9\nZ0\nZ?\nZ\023";
set Intended(digit) "Z1\nZ2\nZ3\nZ4\nZ5\nZ6\nZ7\nZ8\nZ9\nZ0";
set TestRegexp(digit)  {Z[[:digit:]]};

set TestData(compposixclassinner) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(compposixclassinner) "A\n:\nB\nb\n?\n\023";
set TestRegexp(compposixclassinner)  {[[:^digit:]]};

set TestData(compposixclassouter) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(compposixclassouter) "A\n:\nB\nb\n?\n\023";
set TestRegexp(compposixclassouter)  {[^[:digit:]]};

set TestData(digitrebol) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(digitrebol) "1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(digitrebol)  {[digit]};

set TestData(ldigit) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(ldigit) "1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(ldigit)  {%d};

set TestData(pdigit) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(pdigit) "1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(pdigit)  {\d};

set TestData(xmldigit) "2\n0\n\u0660\n\u0968\n\u0A69\n\uFF15\n?\n\023\nA\n:\nb\n\u0561";
set Intended(xmldigit) "2\n0\n\u0660\n\u0968\n\u0A69\n\uFF15\n?";
set TestRegexp(xmldigit)  {\d};

set TestData(xmldigitc) "2\n0\n\u0660\n\u0968\n\u0A69\n\uFF15\n?\n\023\nA\n:\nb\n\u0561";
set Intended(xmldigitc) "?\n\023\nA\n:\nb\n\u0561";
set TestRegexp(xmldigitc)  {\D};

set TestData(pdigitdb) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(pdigitdb) "1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(pdigitdb)  {\\d};

set TestData(ldigitc) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(ldigitc) "A\n:\nB\nb\n?\n\023";
set TestRegexp(ldigitc)  {%D};

set TestData(pdigitc) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(pdigitc) "A\n:\nB\nb\n?\n\023";
set TestRegexp(pdigitc)  {\D};

set TestData(pdigitdbc) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(pdigitdbc) "A\n:\nB\nb\n?\n\023";
set TestRegexp(pdigitdbc)  {\\D};

set TestData(xdigit) "5A\n5B\n5C\n5D\n5E\n5F\n5a\n5b\n5c\n5d\n5e\n5f\n51\n52\n53\n54\n55\n56\n57\n58\n59\n50\n5j\n5k\n5;\n5?";
set Intended(xdigit) "5A\n5B\n5C\n5D\n5E\n5F\n5a\n5b\n5c\n5d\n5e\n5f\n51\n52\n53\n54\n55\n56\n57\n58\n59\n50";
set TestRegexp(xdigit) {5[[:xdigit:]]};

set TestData(xdigitrebol) "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nj\nk\n;\n?";
set Intended(xdigitrebol) "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(xdigitrebol) { [xdigit]};

set TestData(lxdigit) "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nj\nk\n;\n?";
set Intended(lxdigit) "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(lxdigit) {%x};

set TestData(lxdigitc) "g\na\n:\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nk\n?\023";
set Intended(lxdigitc) "g\n:\nk\n?\023";
set TestRegexp(lxdigitc) {%X};

set TestData(xdigitBSx) "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nj\nk\n;\n?";
set Intended(xdigitBSx) "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(xdigitBSx) {\x};

set TestData(xdigitBSxc) "g\na\n:\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nk";
set Intended(xdigitBSxc) "g\n:\nk";
set TestRegexp(xdigitBSxc) {\X};

set TestData(odigitBSo) "A\nd\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nj\nk\n;\n?";
set Intended(odigitBSo) "1\n2\n3\n4\n5\n6\n7\n0";
set TestRegexp(odigitBSo) {\o};

set TestData(odigitBSOc) "A\nd\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nj\nk\n;\n?";
set Intended(odigitBSOc) "A\nd\n8\n9\nj\nk\n;\n?";
set TestRegexp(odigitBSOc) {\O};

set TestData(UpperCaseBSu) "A\nB\na\nc\n4\n,";
set Intended(UpperCaseBSu) "A\nB";
set TestRegexp(UpperCaseBSu) {\u}

set TestData(UpperCaseBSUc) "A\nB\na\nc\n4\n,";
set Intended(UpperCaseBSUc) "a\nc\n4\n,";
set TestRegexp(UpperCaseBSUc) {\U}

set TestData(LowerCaseBSl) "A\nB\na\nc\n4\n,";
set Intended(LowerCaseBSl) "a\nc";
set TestRegexp(LowerCaseBSl) {\l}

set TestData(LowerCaseBSLc) "A\nB\na\nc\n4\n,";
set Intended(LowerCaseBSLc) "A\nB\n4\n,";
set TestRegexp(LowerCaseBSLc) {\L}

set TestData(octal) "m\na\n155\n";
set Intended(octal) "m";
set TestRegexp(octal) {\155};

set TestData(octaldb) "m\na\n155\n";
set Intended(octaldb) "m";
set TestRegexp(octaldb) {\\155};

set TestData(octalo) "m\na\no155\n";
set Intended(octalo) "m";
set TestRegexp(octalo) {\o155};

set TestData(decimald) "m\na\nd109\n";
set Intended(decimald) "m";
set TestRegexp(decimald) {\d109};

set TestData(hexl) "m\na\nx6e";
set Intended(hexl) "m";
set TestRegexp(hexl) {\x6d};

set TestData(hexldb) "m\na\nx6e";
set Intended(hexldb) "m";
set TestRegexp(hexldb) {\\x6d};

set TestData(hexu) "m\na\nx6E";
set Intended(hexu) "m";
set TestRegexp(hexu) {\x6D};

set TestData(hexudb) "m\na\nx6E";
set Intended(hexudb) "m";
set TestRegexp(hexudb) {\\x6D};

set TestData(HexWideCharCurly)     "\u1234\n\\x\{1234\}"
set Intended(HexWideCharCurly)     "\u1234"
set TestRegexp(HexWideCharCurly)   "\\x\{1234\}"

set TestData(HTMLHexReference)     "\u1234\n\\x\{1234\}"
set Intended(HTMLHexReference)     "\u1234"
set TestRegexp(HTMLHexReference)   {&#x1234;}

set TestData(HTMLDecimalReference)     "\u1234\n\\x\{1234\}"
set Intended(HTMLDecimalReference)     "\u1234"
set TestRegexp(HTMLDecimalReference)   {&#4660;}

set TestData(tab) "ZmZ\ZnaZ\nZ\tZ";
set Intended(tab) "Z\tZ";
set TestRegexp(tab) {Z\tZ};

set TestData(tabdb) "ZmZ\ZnaZ\nZ\tZ";
set Intended(tabdb) "Z\tZ";
set TestRegexp(tabdb) {\\t};

set TestData(TabClass) "ZmZ\nZaZ\nZ\tZ";
set Intended(TabClass) "Z\tZ";
set TestRegexp(TabClass) {Z[[:tab:]]Z};

set TestData(EscapeClass) "ZmZ\nZaZ\nZ\u001BZ";
set Intended(EscapeClass) "Z\u001BZ";
set TestRegexp(EscapeClass) {Z[[:escape:]]Z};

set TestData(BackspaceClass) "ZmZ\nZaZ\nZ\u0008Z";
set Intended(BackspaceClass) "Z\u0008Z"
set TestRegexp(BackspaceClass) {Z[[:backspace:]]Z};

set TestData(escape) "m\na\n\033";
set Intended(escape) "\033";
set TestRegexp(escape) {\e};

set TestData(escapedb) "m\na\n\033";
set Intended(escapedb) "\033";
set TestRegexp(escapedb) {\\e};

set TestData(bell) "m\na\n\007";
set Intended(bell) "\007";
set TestRegexp(bell) {\a};

set TestData(belldb) "m\na\n\007";
set Intended(belldb) "\007";
set TestRegexp(belldb) {\\a};

set TestData(backspace) "\u0008\nb\n\\b";
set Intended(backspace) "\u0008";
set TestRegexp(backspace) {\b};

set TestData(cr) "m\na\n\r";
set Intended(cr) "\r";
set TestRegexp(cr) {\r};

set TestData(crdb) "m\na\n\r";
set Intended(crdb) "\r";
set TestRegexp(crdb) {\\r};

set TestData(unicodebmp) "AaZ\nbac\nA\u4E09\u58EBZ\nA\u4E09Z\nA\u58EBZ\nA\u10024Z";
set Intended(unicodebmp) "AaZ\nA\u4E09Z\nA\u58EBZ";
set TestRegexp(unicodebmp) {A.Z};

set TestData(unicodefull) "AaZ\nbac\nA\u4E09\u58EBZ\nA\u4E09Z\nA\u58EBZ\nA\u10024Z";
set Intended(unicodefull) "AaZ\nA\u4E09Z\nA\u58EBZ\nA\u10024Z";
set TestRegexp(unicodefull) {A.Z};

set TestData(controlc) "m\na\n\007";
set Intended(controlc) "\007";
set TestRegexp(controlc) {\cG};

set TestData(controlcdb)   "m\na\n\007";
set Intended(controlcdb)   "\007";
set TestRegexp(controlcdb) {\\cG};

set TestData(some) "a\nab\naa\nb\nba\naba\nc\nabc\naab\naaab";
set Intended(some) "ab\naab\naaab";
set TestRegexp(some) {[some "a" "b"]};

set TestData(any)  "a\nab\naa\nb\nba\naba\nc\nabc\naab\naaab";
set Intended(any)  "ab\nb\naab\naaab";
set TestRegexp(any) {[any "a" "b"]};

set TestData(rangerebol) "a\naa\naaa\naaaa\nb\nbb\nab\nba\nc";
set Intended(rangerebol) "a\naa\naaa";
set TestRegexp(rangerebol) {[1 3 "a"]};

set TestData(QuoteFollowingMetacharsQDot)    "...\nabc"
set Intended(QuoteFollowingMetacharsQDot)    "..."
set TestRegexp(QuoteFollowingMetacharsQDot)  {\Q...};

set TestData(QuoteFollowingMetacharsMDot)    "...\nabc"
set Intended(QuoteFollowingMetacharsMDot)    "..."
set TestRegexp(QuoteFollowingMetacharsMDot)  {\M...};

#Perl
set TestData(TerminateMetacharQuotingDot)    "......\nabcdef\nabc...\n...abc"
set Intended(TerminateMetacharQuotingDot)    "......\n...abc"
set TestRegexp(TerminateMetacharQuotingDot)  {\Q...\E...};

#Vim
set TestData(ShiftBackToMagicDot)    "......\nabcdef\nabc...\n...abc"
set Intended(ShiftBackToMagicDot)    "......\n...abc"
set TestRegexp(ShiftBackToMagicDot)  {\M...\m...};

#Test for inline comment
set TestData(comment) "ab\nafoob\na?\#foob\na(?\#foo)b";
set Intended(comment) "ab";
set TestRegexp(comment) {a(?#foo)b};

#Probably should have multiple tests here as for (?i)
#set TestData(CaseInsensitiveBSSmallC) "aB\nAb\nAB\nab"
#set Intended(CaseInsensitiveBSSmallC) "aB\nAb\nAB\nab"
#set TestRegexp(CaseInsensitiveBSSmallC) {\caB}

#Tests for inline case-insensitive flag \c

set TestData(CaseInsensitiveBSSmallCAsciiLiteral) "aB\nAb\nAB\nab"
set Intended(CaseInsensitiveBSSmallCAsciiLiteral) "aB\nAb\nAB\nab"
set TestRegexp(CaseInsensitiveBSSmallCAsciiLiteral) {\caB}

set TestData(CaseInsensitiveBSSmallCNonAsciiLiteral) "\u0531\u0561\n\u0531\u0531"
set Intended(CaseInsensitiveBSSmallCNonAsciiLiteral) "\u0531\u0561\n\u0531\u0531"
set TestRegexp(CaseInsensitiveBSSmallCNonAsciiLiteral) "\\c\u0531\u0561"

set TestData(CaseInsensitiveBSSmallCAsciiClass) "a\nA"
set Intended(CaseInsensitiveBSSmallCAsciiClass) "a\nA"
set TestRegexp(CaseInsensitiveBSSmallCAsciiClass) {\c[[:lower:]]};

set TestData(CaseInsensitiveBSSmallCNonAsciiClass) "\u0561\n\u0531"
set Intended(CaseInsensitiveBSSmallCNonAsciiClass) "\u0561\n\u0531"
set TestRegexp(CaseInsensitiveBSSmallCNonAsciiClass) {\c[[:lower:]]};

set TestData(CaseInsensitiveBSSmallCAsciiClassSymmetric) "aB\nAB\nab";
set Intended(CaseInsensitiveBSSmallCAsciiClassSymmetric) "aB\nAB\nab";
set TestRegexp(CaseInsensitiveBSSmallCAsciiClassSymmetric) {\c[[:lower:]][[:upper:]]};

set TestData(CaseInsensitiveBSSmallCNonAsciiClassSymmetric) \
    "\u0561\u0531\n\u0531\u0531\n\u0561\u0561";
set Intended(CaseInsensitiveBSSmallCNonAsciiClassSymmetric) \
    "\u0561\u0531\n\u0531\u0531\n\u0561\u0561";
set TestRegexp(CaseInsensitiveBSSmallCNonAsciiClassSymmetric) \
    {\c[[:lower:]][[:upper:]]};

set TestData(CaseInsensitiveBSSmallCOctal) "b\nB\nk"
set Intended(CaseInsensitiveBSSmallCOctal) "b\nB"
set TestRegexp(CaseInsensitiveBSSmallCOctal) {\c\142}

set TestData(CaseInsensitiveBSSmallCHex) "b\nB\nk"
set Intended(CaseInsensitiveBSSmallCHex) "b\nB"
set TestRegexp(CaseInsensitiveBSSmallCHex) {\c\x62}

#Tests for inline case-insensitive flag (?i)

set TestData(CaseInsensitiveFlagSmallIAsciiLiteral) "aB\nAb\nAB\nab"
set Intended(CaseInsensitiveFlagSmallIAsciiLiteral) "aB\nAb\nAB\nab"
set TestRegexp(CaseInsensitiveFlagSmallIAsciiLiteral) {(?i)aB}

set TestData(flagCrosshatchICaseSensitive) "ab\nAb\naB\nAB"
set Intended(flagCrosshatchICaseSensitive) "ab\nAb"
set TestRegexp(flagCrosshatchICaseSensitive) {(#i)a(#I)b}

set TestData(CaseInsensitiveFlagSmallINonAsciiLiteral) "\u0531\u0561\n\u0531\u0531"
set Intended(CaseInsensitiveFlagSmallINonAsciiLiteral) "\u0531\u0561\n\u0531\u0531"
set TestRegexp(CaseInsensitiveFlagSmallINonAsciiLiteral) "(?i)\u0531\u0561"

set TestData(CaseInsensitiveFlagSmallIAsciiClass) "a\nA"
set Intended(CaseInsensitiveFlagSmallIAsciiClass) "a\nA"
set TestRegexp(CaseInsensitiveFlagSmallIAsciiClass) {(?i)[[:lower:]]};

set TestData(CaseInsensitiveFlagSmallINonAsciiClass) "\u0561\n\u0531"
set Intended(CaseInsensitiveFlagSmallINonAsciiClass) "\u0561\n\u0531"
set TestRegexp(CaseInsensitiveFlagSmallINonAsciiClass) {(?i)[[:lower:]]};

set TestData(CaseInsensitiveFlagSmallIAsciiClassSymmetric) "aB\nAB\nab";
set Intended(CaseInsensitiveFlagSmallIAsciiClassSymmetric) "aB\nAB\nab";
set TestRegexp(CaseInsensitiveFlagSmallIAsciiClassSymmetric) {(?i)[[:lower:]][[:upper:]]};

set TestData(CaseInsensitiveFlagSmallINonAsciiClassSymmetric) "\u0561\u0531\n\u0531\u0531\n\u0561\u0561";
set Intended(CaseInsensitiveFlagSmallINonAsciiClassSymmetric) "\u0561\u0531\n\u0531\u0531\n\u0561\u0561";
set TestRegexp(CaseInsensitiveFlagSmallINonAsciiClassSymmetric) {(?i)[[:lower:]][[:upper:]]};

set TestData(CaseInsensitiveFlagSmallIuNonAsciiLiteral) "\u0531\u0561\n\u0531\u0531"
set Intended(CaseInsensitiveFlagSmallIuNonAsciiLiteral) "\u0531\u0561\n\u0531\u0531"
set TestRegexp(CaseInsensitiveFlagSmallIuNonAsciiLiteral) "(?iu)\u0531\u0561"

set TestData(CaseInsensitiveFlagSmallIuNonAsciiClass) "\u0561\n\u0531"
set Intended(CaseInsensitiveFlagSmallIuNonAsciiClass) "\u0561\n\u0531"
set TestRegexp(CaseInsensitiveFlagSmallIuNonAsciiClass) {(?iu)[[:lower:]]};

set TestData(CaseInsensitiveFlagSmallIuNonAsciiClassSymmetric) "\u0561\u0531\n\u0531\u0531\n\u0561\u0561";
set Intended(CaseInsensitiveFlagSmallIuNonAsciiClassSymmetric) "\u0561\u0531\n\u0531\u0531\n\u0561\u0561";
set TestRegexp(CaseInsensitiveFlagSmallIuNonAsciiClassSymmetric) {(?iu)[[:lower:]][[:upper:]]};

#Test whether inline case-insensitive flag applies to octal escapes (it doesn't in Ruby).
set TestData(CaseInsensitiveFlagSmallIOctal) "b\nB\nk"
set Intended(CaseInsensitiveFlagSmallIOctal) "b\nB"
set TestRegexp(CaseInsensitiveFlagSmallIOctal) {(?i)\142}

#Test whether inline case-insensitive flag applies to hex escapes (it doesn't in Ruby).
set TestData(CaseInsensitiveFlagSmallIHex) "b\nB\nk"
set Intended(CaseInsensitiveFlagSmallIHex) "b\nB"
set TestRegexp(CaseInsensitiveFlagSmallIHex) {(?i)\x62}

#Tests for inline case-insensitive flag (#i)

set TestData(CaseInsensitiveCrosshatchAsciiLiteral) "aB\nAb\nAB\nab"
set Intended(CaseInsensitiveCrosshatchAsciiLiteral) "aB\nAb\nAB\nab"
set TestRegexp(CaseInsensitiveCrosshatchAsciiLiteral) {(#i)aB}

set TestData(CaseInsensitiveCrosshatchNonAsciiLiteral) "\u0531\u0561\n\u0531\u0531"
set Intended(CaseInsensitiveCrosshatchNonAsciiLiteral) "\u0531\u0561\n\u0531\u0531"
set TestRegexp(CaseInsensitiveCrosshatchNonAsciiLiteral) "(#i)\u0531\u0561"

set TestData(CaseInsensitiveCrosshatchAsciiClass) "a\nA"
set Intended(CaseInsensitiveCrosshatchAsciiClass) "a\nA"
set TestRegexp(CaseInsensitiveCrosshatchAsciiClass) {(#i)[[:lower:]]};

set TestData(CaseInsensitiveCrosshatchNonAsciiClass) "\u0561\n\u0531"
set Intended(CaseInsensitiveCrosshatchNonAsciiClass) "\u0561\n\u0531"
set TestRegexp(CaseInsensitiveCrosshatchNonAsciiClass) {(#i)[[:lower:]]};

set TestData(CaseInsensitiveCrosshatchAsciiClassSymmetric) "aB\nAB\nab";
set Intended(CaseInsensitiveCrosshatchAsciiClassSymmetric) "aB\nAB\nab";
set TestRegexp(CaseInsensitiveCrosshatchAsciiClassSymmetric) {(#i)[[:lower:]][[:upper:]]};

set TestData(CaseInsensitiveCrosshatchNonAsciiClassSymmetric) "\u0561\u0531\n\u0531\u0531\n\u0561\u0561";
set Intended(CaseInsensitiveCrosshatchNonAsciiClassSymmetric) "\u0561\u0531\n\u0531\u0531\n\u0561\u0561";
set TestRegexp(CaseInsensitiveCrosshatchNonAsciiClassSymmetric) {(#i)[[:lower:]][[:upper:]]};

set TestData(CaseInsensitiveCrosshatchuNonAsciiLiteral) "\u0531\u0561\n\u0531\u0531"
set Intended(CaseInsensitiveCrosshatchuNonAsciiLiteral) "\u0531\u0561\n\u0531\u0531"
set TestRegexp(CaseInsensitiveCrosshatchuNonAsciiLiteral) "(#iu)\u0531\u0561"

set TestData(CaseInsensitiveCrosshatchuNonAsciiClass) "\u0561\n\u0531"
set Intended(CaseInsensitiveCrosshatchuNonAsciiClass) "\u0561\n\u0531"
set TestRegexp(CaseInsensitiveCrosshatchuNonAsciiClass) {(#iu)[[:lower:]]};

set TestData(CaseInsensitiveCrosshatchuNonAsciiClassSymmetric) "\u0561\u0531\n\u0531\u0531\n\u0561\u0561";
set Intended(CaseInsensitiveCrosshatchuNonAsciiClassSymmetric) "\u0561\u0531\n\u0531\u0531\n\u0561\u0561";
set TestRegexp(CaseInsensitiveCrosshatchuNonAsciiClassSymmetric) {(#iu)[[:lower:]][[:upper:]]};

set TestData(flagCrosshatchlAsymmetricCaseInsensitive) "aB\nAB\nab\nAb"
set Intended(flagCrosshatchlAsymmetricCaseInsensitive) "aB\nAB"
set TestRegexp(flagCrosshatchlAsymmetricCaseInsensitive) {(#l)aB}

set TestData(CaseInsensitiveCrosshatchOctal) "b\nB\nk"
set Intended(CaseInsensitiveCrosshatchOctal) "b\nB"
set TestRegexp(CaseInsensitiveCrosshatchOctal) {(#i)\142}

set TestData(CaseInsensitiveCrosshatchHex) "b\nB\nk"
set Intended(CaseInsensitiveCrosshatchHex) "b\nB"
set TestRegexp(CaseInsensitiveCrosshatchHex) {(#i)\x62}

#Other flags
set TestData(flagx) "abc\na\tb c\na b c\na2b\nab c\nab c\#foo";
set Intended(flagx) {ab c};
set TestRegexp(flagx) {(?x)^a b\ c$#foo};

set TestData(flagq) "a*b\naab\nacb";
set Intended(flagq) {a*b};
set TestRegexp(flagq) {(?q)a*b};

set TestData(flagb) "t\n\u0009";
set Intended(flagb) "t";
set TestRegexp(flagb) {(?b)\t};

set TestData(flage) "xy\nab"
set Intended(flage) "xy";
set TestRegexp(flage) {(?e)xy};

set TestData(UnsetFlag) "AA\naA\nAa\naa";
set Intended(UnsetFlag) "AA\naA";
set TestRegexp(UnsetFlag) {(?i)a(?-i)A}

set TestData(IgnoreCombiningCharactersBSZ) "\u0065\n\u0065\u0301\n\u00e9\n\u0064"
set Intended(IgnoreCombiningCharactersBSZ) "\u0065\n\u0065\u0301"
set TestRegexp(IgnoreCombiningCharactersBSZ) {\Ze}

#This can only be tested with a global case-insensitive setting.
set TestData(CaseSensitiveFlag) "aB\nAB\nab\nAb"
set Intended(CaseSensitiveFlag) "aB"
set TestRegexp(CaseSensitiveFlag) {(?c)aB}

#This can only be tested with a global case-insensitive setting.
set TestData(CaseSensitiveBSBigC) "aB\nAB\nab\nAb"
set Intended(CaseSensitiveBSBigC) "aB"
set TestRegexp(CaseSensitiveBSBigC) {\CaB}

set TestData(FlagQWideScope) "AA\naA\nAa\naa";
set Intended(FlagQWideScope) "AA\naA\nAa\naa";
set TestRegexp(FlagQWideScope) {a(?i)A}

set TestData(FlagBSSmallCWideScope) "AA\naA\nAa\naa";
set Intended(FlagBSSmallCWideScope) "AA\naA\nAa\naa";
set TestRegexp(FlagBSSmallCWideScope) {a\cA}

set TestData(FlagCrosshatchWideScope) "AA\naA\nAa\naa";
set Intended(FlagCrosshatchWideScope) "AA\naA\nAa\naa";
set TestRegexp(FlagCrosshatchWideScope) {a(#i)A}

#Test whether the case-insensitive command line flag applies to backreferences.
#(It doesn't in egrep.)
#This test requires the command-line CI flag to be set.
set TestData(CaseInsensitiveCLFlagBackrefP) "cabncab\ncabnCAB\nCABncab\nCABnCAB\ncabncb"
set Intended(CaseInsensitiveCLFlagBackrefP) "cabncab\ncabnCAB\nCABncab\nCABnCAB"
set TestRegexp(CaseInsensitiveCLFlagBackrefP) {(cab)n\1}

set TestData(taggedgroup) "xyyyx\nxxyyyxx\nxxxyyyxxx\nxyyyxx\nxyx";
set Intended(taggedgroup) "xyyyx\nxxyyyxx\nxxxyyyxxx";
set TestRegexp(taggedgroup) {^(?P<exes>x+)yyy(?P=exes)$};

set TestData(taggedgroupsq) "xyyyx\nxxyyyxx\nxxxyyyxxx\nxyyyxx\nxyx";
set Intended(taggedgroupsq) "xyyyx\nxxyyyxx\nxxxyyyxxx";
set TestRegexp(taggedgroupsq) {^(?P'exes'x+)yyy(?P=exes)$};

set TestData(uname) "x\u05DCy";
set Intended(uname) "x\u05DCy";
set TestRegexp(uname) {x\N{HEBREW LETTER LAMED}y};

set TestData(unamedb)   "x\u05DCy";
set Intended(unamedb)   "x\u05DCy";
set TestRegexp(unamedb) {x\\N{HEBREW LETTER LAMED}y};

set TestData(jLower) "AaZ\nABZ\nAcZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set Intended(jLower) "AaZ\nAcZ";
set TestRegexp(jLower)   {A\p{Lower}Z};

set TestData(jLowerdb)     "AaZ\nABZ\nAcZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set Intended(jLowerdb)     "AaZ\nAcZ";
set TestRegexp(jLowerdb)   {A\\p{Lower}Z};

set TestData(jLowerc) "AaZ\nABZ\nAcZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set Intended(jLowerc) "ABZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set TestRegexp(jLowerc)   {A\P{Lower}Z};

set TestData(jLowercdb) "AaZ\nABZ\nAcZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set Intended(jLowercdb) "ABZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set TestRegexp(jLowercdb)   {A\\P{Lower}Z};

set TestData(jUpper)    "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z";
set Intended(jUpper)    "aBz\naZz";
set TestRegexp(jUpper)  {a\p{Upper}z};

set TestData(jUpperdb)   "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z";
set Intended(jUpperdb)   "aBz\naZz";
set TestRegexp(jUpperdb) {a\\p{Upper}z};

set TestData(jUpperc)     "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z";
set Intended(jUpperc)     "aaz\nacz\na+z\na4z\na:z\na?z";
set TestRegexp(jUpperc)   {a\P{Upper}z};

set TestData(jUppercdb)     "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z";
set Intended(jUppercdb)     "aaz\nacz\na+z\na4z\na:z\na?z";
set TestRegexp(jUppercdb)   {a\\P{Upper}z};

set TestData(jAscii)     "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z\na\tz\na\222z";
set Intended(jAscii)     "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z\na\tz";
set TestRegexp(jAscii)   {a\p{ASCII}z};

set TestData(jAsciidb)    "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z\na\tz\na\222z";
set Intended(jAsciidb)    "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z\na\tz";
set TestRegexp(jAsciidb)  {a\\p{ASCII}z};

set TestData(jAsciic)     "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z\na\tz\na\222z";
set Intended(jAsciic)     "a\222z";
set TestRegexp(jAsciic)   {a\P{ASCII}z};

set TestData(jAsciicdb)    "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z\na\tz\na\222z";
set Intended(jAsciicdb)    "a\222z";
set TestRegexp(jAsciicdb)  {a\\P{ASCII}z};

set TestData(jAlpha) "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(jAlpha) "a\nB\nc\nZ";
set TestRegexp(jAlpha)  {\p{Alpha}};

set TestData(jAlphadb)    "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(jAlphadb)    "a\nB\nc\nZ";
set TestRegexp(jAlphadb)  {\\p{Alpha}};

set TestData(jAlphac)    "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(jAlphac)    "+\n4\n:\n?";
set TestRegexp(jAlphac)  {\P{Alpha}};

set TestData(jAlphacdb)    "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(jAlphacdb)    "+\n4\n:\n?";
set TestRegexp(jAlphacdb)  {\\P{Alpha}};

set TestData(jDigit) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(jDigit) "1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(jDigit)  {\p{Digit}};

set TestData(jDigitdb) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(jDigitdb) "1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(jDigitdb)  {\\p{Digit}};

set TestData(jDigitc) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(jDigitc) "A\n:\nB\nb\n?\n\023";
set TestRegexp(jDigitc) {\P{Digit}};

set TestData(jDigitcdb) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?\n\023";
set Intended(jDigitcdb) "A\n:\nB\nb\n?\n\023";
set TestRegexp(jDigitcdb) {\\P{Digit}};

set TestData(jXdigit) "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nj\nk\n;\n?";
set Intended(jXdigit) "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(jXdigit) {\p{XDigit}};

set TestData(jXdigitdb)   "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nj\nk\n;\n?";
set Intended(jXdigitdb)   "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0";
set TestRegexp(jXdigitdb) {\\p{XDigit}};

set TestData(jXdigitc)  "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nj\nk\n;\n?";
set Intended(jXdigitc)  "j\nk\n;\n?";
set TestRegexp(jXdigitc) {\P{XDigit}};

set TestData(jXdigitcdb)  "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nj\nk\n;\n?";
set Intended(jXdigitcdb)  "j\nk\n;\n?";
set TestRegexp(jXdigitcdb) {\\P{XDigit}};

set TestData(jAlnum) "a\nB\nc\nZ\n+\n4\n:\n?\n_";
set Intended(jAlnum) "a\nB\nc\nZ\n4";
set TestRegexp(jAlnum)   {\p{Alnum}};

set TestData(jAlnumdb) "a\nB\nc\nZ\n+\n4\n:\n?\n_";
set Intended(jAlnumdb) "a\nB\nc\nZ\n4";
set TestRegexp(jAlnumdb)   {\\p{Alnum}};

set TestData(jAlnumc) "a\nB\nc\nZ\n+\n4\n:\n?\n_";
set Intended(jAlnumc) "+\n:\n?\n_";
set TestRegexp(jAlnumc)   {\P{Alnum}};

set TestData(jAlnumcdb) "a\nB\nc\nZ\n+\n4\n:\n?\n_";
set Intended(jAlnumcdb) "+\n:\n?\n_";
set TestRegexp(jAlnumcdb)   {\\P{Alnum}};

set TestData(jPunct) "aaz\naBz\nacz\naZz\na4z\na:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z";
set Intended(jPunct) "a:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z";
set TestRegexp(jPunct)   {a\p{Punct}z};

set TestData(jPunctdb)    "aaz\naBz\nacz\naZz\na4z\na:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z";
set Intended(jPunctdb)    "a:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z";
set TestRegexp(jPunctdb)  {a\\p{Punct}z};

set TestData(jPunctc) "aaz\naBz\nacz\naZz\na4z\na:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z\na\040z";
set Intended(jPunctc) "aaz\naBz\nacz\naZz\na4z\na\040z";
set TestRegexp(jPunctc)   {a\P{Punct}z};

set TestData(jPunctcdb) "aaz\naBz\nacz\naZz\na4z\na:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z\na\040z";
set Intended(jPunctcdb) "aaz\naBz\nacz\naZz\na4z\na\040z";
set TestRegexp(jPunctcdb)   {a\\P{Punct}z};

set TestData(jGraph) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(jGraph) "aab\naAb\na4b\na:b";
set TestRegexp(jGraph)   {a\p{Graph}b};

set TestData(jGraphdb) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(jGraphdb) "aab\naAb\na4b\na:b";
set TestRegexp(jGraphdb)   {a\\p{Graph}b};

set TestData(jGraphc) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(jGraphc) "a\040b\na\011b\na\023b";
set TestRegexp(jGraphc)   {a\P{Graph}b};

set TestData(jGraphcdb) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(jGraphcdb) "a\040b\na\011b\na\023b";
set TestRegexp(jGraphcdb)   {a\\P{Graph}b};

set TestData(jPrint) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(jPrint) "aab\naAb\na4b\na:b\na\040b";
set TestRegexp(jPrint)   {a\p{Print}b};

set TestData(jPrintdb) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(jPrintdb) "aab\naAb\na4b\na:b\na\040b";
set TestRegexp(jPrintdb)   {a\\p{Print}b};

set TestData(jPrintc) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(jPrintc) "a\011b\na\023b";
set TestRegexp(jPrintc)   {a\P{Print}b};

set TestData(jPrintcdb) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(jPrintcdb) "a\011b\na\023b";
set TestRegexp(jPrintcdb)   {a\\P{Print}b};

set TestData(jBlank) "a\040b\na\011b\nacb\na:b";
set Intended(jBlank) "a\040b\na\011b";
set TestRegexp(jBlank)   {a\p{Blank}b};

set TestData(jBlankdb) "a\040b\na\011b\nacb\na:b";
set Intended(jBlankdb) "a\040b\na\011b";
set TestRegexp(jBlankdb)   {a\\p{Blank}b};

set TestData(jBlankc) "a\040b\na\011b\nacb\na:b";
set Intended(jBlankc) "acb\na:b";
set TestRegexp(jBlankc)   {a\P{Blank}b};

set TestData(jBlankcdb) "a\040b\na\011b\nacb\na:b";
set Intended(jBlankcdb) "acb\na:b";
set TestRegexp(jBlankcdb)   {a\\P{Blank}b};

set TestData(jSpace) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(jSpace) "a\040b\na\014b\na\011b\na\013b";
set TestRegexp(jSpace)  {a\p{Space}b};

set TestData(jSpacedb) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(jSpacedb) "a\040b\na\014b\na\011b\na\013b";
set TestRegexp(jSpacedb)  {a\\p{Space}b};

set TestData(jSpacec) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(jSpacec) "a4b\na:b\nacb";
set TestRegexp(jSpacec)  {a\P{Space}b};

set TestData(jSpacecdb) "a\040b\na\014b\na\011b\na\013b\na4b\na:b\nacb";
set Intended(jSpacecdb) "a4b\na:b\nacb";
set TestRegexp(jSpacecdb)  {a\\P{Space}b};

set TestData(jCntrl) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b\na\177b";
set Intended(jCntrl) "a\011b\na\023b\na\177b";
set TestRegexp(jCntrl)   {a\p{Cntrl}b};
			
set TestData(jCntrldb) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b\na\177b";
set Intended(jCntrldb) "a\011b\na\023b\na\177b";
set TestRegexp(jCntrldb)   {a\\p{Cntrl}b};
		
set TestData(jCntrlc) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b\na\177b";
set Intended(jCntrlc) "aab\naAb\na4b\na:b\na\040b";
set TestRegexp(jCntrlc)   {a\P{Cntrl}b};

set TestData(jCntrlcdb) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b\na\177b";
set Intended(jCntrlcdb) "aab\naAb\na4b\na:b\na\040b";
set TestRegexp(jCntrlcdb)   {a\\P{Cntrl}b};

#Java Unicode range
set TestData(jUBlockIn)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockIn)  "a\u3042b\na\u3057b\na\u309db";
set TestRegexp(jUBlockIn)   {a\p{InHiragana}b};

#Java Unicode range - double backslash
set TestData(jUBlockIndb)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockIndb)  "a\u3042b\na\u3057b\na\u309db";
set TestRegexp(jUBlockIndb)   {a\\p{InHiragana}b};

#Java Unicode range - complement
set TestData(jUBlockInc)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockInc)   "aXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUBlockInc)   {a\P{InHiragana}b};

#Java Unicode range - complement -db
set TestData(jUBlockIncdb)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockIncdb)   "aXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUBlockIncdb)   {a\\P{InHiragana}b};


#Java-style s-variant range
set TestData(jUBlockIs)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockIs)  "a\u3042b\na\u3057b\na\u309db";
set TestRegexp(jUBlockIs)   {a\p{IsHiragana}b};

#Java-style s-variant range - double backslash
set TestData(jUBlockIsdb)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockIsdb)  "a\u3042b\na\u3057b\na\u309db";
set TestRegexp(jUBlockIsdb)   {a\\p{IsHiragana}b};

#Java-style s-variant range - complement
set TestData(jUBlockIsc)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockIsc)   "aXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUBlockIsc)   {a\P{IsHiragana}b};

#Java-style s-variant range - complement -db
set TestData(jUBlockIscdb)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockIscdb)   "aXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUBlockIscdb)   {a\\P{IsHiragana}b};

#Unicode range - bare
set TestData(jUBlockBare)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockBare)  "a\u3042b\na\u3057b\na\u309db";
set TestRegexp(jUBlockBare)   {a\p{Hiragana}b};

#Unicode range - double backslash
set TestData(jUBlockBaredb)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockBaredb)  "a\u3042b\na\u3057b\na\u309db";
set TestRegexp(jUBlockBaredb)   {a\\p{Hiragana}b};

#Unicode range - complement
set TestData(jUBlockBarec)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockBarec)   "aXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUBlockBarec)   {a\P{Hiragana}b};

#Unicode range - complement -db
set TestData(jUBlockBarecdb)  "a\u3042b\na\u3057b\na\u309db\naXb\na7b\na:b\na\u0B86b";
set Intended(jUBlockBarecdb)   "aXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUBlockBarecdb)   {a\\P{Hiragana}b};

#Java Unicode general character property
set TestData(jUCat) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCat) "a+b\na\u00ACb\na\u2044b";
set TestRegexp(jUCat)   {a\p{Sm}b};

#Java Unicode general character property -db
set TestData(jUCatdb) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatdb) "a+b\na\u00ACb\na\u2044b";
set TestRegexp(jUCatdb)   {a\\p{Sm}b};

#Java Unicode general character property - complement
set TestData(jUCatc) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatc) "a\u3042b\naXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUCatc)   {a\P{Sm}b};

#Java Unicode general character property - complement -db
set TestData(jUCatcdb) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatcdb) "a\u3042b\naXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUCatcdb)   {a\\P{Sm}b};


#Java-style s-variant Unicode general character property
set TestData(jUCatIs) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatIs) "a+b\na\u00ACb\na\u2044b";
set TestRegexp(jUCatIs)   {a\p{IsSm}b};

#Java-style s-variant Unicode general character property -db
set TestData(jUCatdbIs) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatdbIs) "a+b\na\u00ACb\na\u2044b";
set TestRegexp(jUCatdbIs)   {a\\p{IsSm}b};

#Java-style s-variant Unicode general character property - complement
set TestData(jUCatcIs) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatcIs) "a\u3042b\naXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUCatcIs)   {a\P{IsSm}b};

#Java-style s-variant Unicode general character property - complement -db
set TestData(jUCatcdbIs) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatcdbIs) "a\u3042b\naXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUCatcdbIs)   {a\\P{IsSm}b};


#Java-style n-variant Unicode general character property
set TestData(jUCatIn) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatIn) "a+b\na\u00ACb\na\u2044b";
set TestRegexp(jUCatIn)   {a\p{InSm}b};

#Java-style n-variant Unicode general character property -db
set TestData(jUCatdbIn) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatdbIn) "a+b\na\u00ACb\na\u2044b";
set TestRegexp(jUCatdbIn)   {a\\p{InSm}b};

#Java-style n-variant Unicode general character property - complement
set TestData(jUCatcIn) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatcIn) "a\u3042b\naXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUCatcIn)   {a\P{InSm}b};

#Java-style n-variant Unicode general character property - complement -db
set TestData(jUCatcdbIn) "a\u3042b\naXb\na7b\na:b\na\u0B86b\na+b\na\u00ACb\na\u2044b";
set Intended(jUCatcdbIn) "a\u3042b\naXb\na7b\na:b\na\u0B86b";
set TestRegexp(jUCatcdbIn)   {a\\P{InSm}b};


#Java character set union
set TestData(jUnion)    "a1b\na2b\na3b\nadb\naeb\nafb\nagb\na8b\na:b";
set Intended(jUnion)    "a1b\na2b\na3b\nadb\naeb\nafb";
set TestRegexp(jUnion)  {a[1-3[d-f]]b};

#Java character set intersection
set TestData(jInter)    "adb\naeb\nafb\nayb\na7b\na:b";
set Intended(jInter)    "adb\naeb\nafb";
set TestRegexp(jInter)  {a[a-z&&[d-f]]b};

#Positive forward assertion
set TestData(plookahead)    "abc lkj\nabc\nabc \nabc lk\nabc (?=lkj)";
set Intended(plookahead)    "abc lkj";
set TestRegexp(plookahead)  {abc (?=lkj).*};

set TestData(plookaheadAtSign)  "doofoobar\nfoobar\nfoobard\nfoo\nfoobird"
set Intended(plookaheadAtSign)  "doofoobar\nfoobar\nfoobard"
set TestRegexp(plookaheadAtSign)  {foo\(bar\)\@=}

#Negative forward assertion
set TestData(nlookahead)    "abclkj\nabc\nabclk\nabc(?!lkj)";
set Intended(nlookahead)    "abc\nabclk\nabc(?!lkj)";
set TestRegexp(nlookahead)  {abc(?!lkj).*};

set TestData(nlookaheadAtSign)    "foodar\nfoo\nfoobar\nfoobard"
set Intended(nlookaheadAtSign)    "foodar\nfoo"
set TestRegexp(nlookaheadAtSign)  {foo\(bar\)\@!}

#Positive backward assertion
set TestData(plookback)    "abc lkj\nabc\nabc \nabc lk\n(?<=abc) lkj";
set Intended(plookback)    "abc lkj";
set TestRegexp(plookback)  {.*(?<=abc) lkj};

set TestData(plookbackAtSign)    "an file\nan \@<=file\nan @<=file"
set Intended(plookbackAtSign)    "an file"
set TestRegexp(plookbackAtSign)  {\(an \)\@<=file}

#Positive backward assertion
#set TestData(plookbackbs)    "abc lkj\nabc\nabc \nabc lk\n(?<=abc) lkj";
#set Intended(plookbackbs)    "abc lkj";
#set TestRegexp(plookbackbs)  {.*(?\<=abc) lkj};

#Negative backward assertion
set TestData(nlookback)    "abclkj\nlkj\nbclkj\n(?<!abc)lkj";
set Intended(nlookback)    "lkj\nbclkj\n(?<!abc)lkj";
set TestRegexp(nlookback)  {.*(?<!abc)lkj};

set TestData(nlookbackAtSign)    "bar\ntbar\nbard\nfoobar"
set Intended(nlookbackAtSign)    "bar\ntbar\nbard"
set TestRegexp(nlookbackAtSign)  {\(foo\)\@<!bar}

#Negative backward assertion
#set TestData(nlookbackbs)    "abclkj\nlkj\nbclkj\n(?<!abc)lkj";
#set Intended(nlookbackbs)    "lkj\nbclkj\n(?<!abc)lkj";
#set TestRegexp(nlookbackbs)  {.*(?\<!abc)lkj};

#conditionals
set TestData(CondGroupSimple)    "<user@host.com>\nuser@host.com\n<user@host.com\nuser@host.com>";
set Intended(CondGroupSimple)    "<user@host.com>\nuser@host.com";
set TestRegexp(CondGroupSimple)  {^(<)?(\w+@\w+(?:\.\w+)+)(?(1)>)$};

set TestData(CondGroupElse)     "<user@host.com>\nuser@host.com:\nuser@host.com";
set Intended(CondGroupElse)     "<user@host.com>\nuser@host.com:";
set TestRegexp(CondGroupElse)  {^(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|:)$};

set TestData(CondLookaroundSimple) "abxy\nxy\naxyc\ncdwz"
set Intended(CondLookaroundSimple) "abxy\nxy\naxyc"
set TestRegexp(CondLookaroundSimple) {.*(?(?<!ab)xy).*}

set TestData(CondLookaroundElse) "abxy\nxy\naxyc\nabwz";
set Intended(CondLookaroundElse) "xy\naxyc\nabwz";
set TestRegexp(CondLookaroundElse)  {.*(?(?<!ab)xy|wz).*}

set TestData(SelfishNoCaptureGroupA)    "aaaa"
set Intended(SelfishNoCaptureGroupA)    "aaaa"
set TestRegexp(SelfishNoCaptureGroupA)    {(?>a+)}

set TestData(SelfishNoCaptureGroupB)    "aaaa"
set Intended(SelfishNoCaptureGroupB)    "aaaa"
set TestRegexp(SelfishNoCaptureGroupB)    {(a+)a}

set TestData(SelfishNoCaptureGroupC)    "aaaa"
set Intended(SelfishNoCaptureGroupC)    ""
set TestRegexp(SelfishNoCaptureGroupC)    {(?>a+)a}

#Substitution tests

#Downcase next char - vim
set TestData(SubDowncaseChar)   "John";
set Intended(SubDowncaseChar)   "Johnjohn";
set TestRegexp(SubDowncaseChar) {\(John\)}
set TestSubexp(SubDowncaseChar) {\1\l\1}

#Upcase next char -vim
set TestData(SubUpcaseChar)   "john";
set Intended(SubUpcaseChar)   "Johnjohn";
set TestRegexp(SubUpcaseChar) {\(john\)}
set TestSubexp(SubUpcaseChar) {\u\1\1}

#Downcase next string - vim
set TestData(SubDowncaseString)   "JOHN";
set Intended(SubDowncaseString)   "JOHNjohn";
set TestRegexp(SubDowncaseString) {\(JOHN\)}
set TestSubexp(SubDowncaseString) {\1\L\1}

#Upcase next string -vim
set TestData(SubUpcaseString)   "john";
set Intended(SubUpcaseString)   "johnJOHN";
set TestRegexp(SubUpcaseString) {\(john\)}
set TestSubexp(SubUpcaseString) {\1\U\1}

#Endcase - vim
set TestData(SubEndCaseDomaine)   "abc";
set TestRegexp(SubEndCaseDomaine) {\(abc\)}
set TestSubexp(SubEndCaseDomaine) {\U\1\e\1}
set Intended(SubEndCaseDomaine)   "ABCabc";

set TestData(SubEndCaseDomainE)   "ABC";
set TestRegexp(SubEndCaseDomainE) {\(ABC\)}
set TestSubexp(SubEndCaseDomainE) {\L\1\E\1}
set Intended(SubEndCaseDomainE)   "abcABC";

#Downcase next char - perl
set TestData(SubDowncaseCharDollar)   "John";
set Intended(SubDowncaseCharDollar)   "Johnjohn";
set TestRegexp(SubDowncaseCharDollar) {(John)}
set TestSubexp(SubDowncaseCharDollar) {$1\l$1}

#Upcase next char -perl
set TestData(SubUpcaseCharDollar)   "john";
set Intended(SubUpcaseCharDollar)   "Johnjohn";
set TestRegexp(SubUpcaseCharDollar) {(john)}
set TestSubexp(SubUpcaseCharDollar) {\u$1$1}

#Downcase next string - perl
set TestData(SubDowncaseStringDollar)   "JOHN";
set Intended(SubDowncaseStringDollar)   "JOHNjohn";
set TestRegexp(SubDowncaseStringDollar) {(JOHN)}
set TestSubexp(SubDowncaseStringDollar) {$1\L$1}

#Upcase next string -perl
set TestData(SubUpcaseStringDollar)   "john";
set Intended(SubUpcaseStringDollar)   "johnJOHN";
set TestRegexp(SubUpcaseStringDollar) {(john)}
set TestSubexp(SubUpcaseStringDollar) {$1\U$1}

#Endcase - perl
set TestData(SubEndCaseDomainEDollar)   "ABC";
set TestRegexp(SubEndCaseDomainEDollar) {(ABC)}
set TestSubexp(SubEndCaseDomainEDollar) {\L$1\E$1}
set Intended(SubEndCaseDomainEDollar)   "abcABC";

#Endcase - perl style but not currently accepted by Perl
set TestData(SubEndCaseDomaineDollar)   "abc";
set TestRegexp(SubEndCaseDomaineDollar) {(abc)}
set TestSubexp(SubEndCaseDomaineDollar) {\U$1\e$1}
set Intended(SubEndCaseDomaineDollar)   "ABCabc";

set TestData(SubNewline)	"abcd"
set TestRegexp(SubNewline)	{\(ab\)\(cd\)}
set TestSubexp(SubNewline)	{\1\r\2}
set Intended(SubNewline)	"ab\ncd"

#Test for substitution backreference with k
set TestData(SubBackRefBare)   "abcdef";
set TestRegexp(SubBackRefBare) {(a.)(c.)(e.)};
set TestSubexp(SubBackRefBare) {1 3};
set Intended(SubBackRefBare)   "abef";

#Test for limit on number of groups in substitution backreference with k
set TestData(SubBackRefBareAtLeastTen)   "abcdefghijklmnopqrstuvwxyz";
set Intended(SubBackRefBareAtLeastTen)   "ajmnopqrstuvwxyz";
set TestRegexp(SubBackRefBareAtLeastTen) {(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)}
set TestSubexp(SubBackRefBareAtLeastTen) {1 10};

#Test for substitution backreference with $k
set TestData(SubBackReferenceDol)   "abcdef";
set Intended(SubBackReferenceDol)   "abef";
set TestRegexp(SubBackReferenceDol) {(a.)(c.)(e.)};
set TestSubexp(SubBackReferenceDol) {$1$3};

#Test for substitution backreference with $0
set TestData(SubBackReferenceDolZero)   "abcdef";
set Intended(SubBackReferenceDolZero)   "ab abcdef";
set TestRegexp(SubBackReferenceDolZero) {(a.)(c.)(e.)};
set TestSubexp(SubBackReferenceDolZero) {$1 $0};

#Test for limit on number of groups in substitution backreference with $k
set TestData(SubBackReferenceDolAtLeastTen)   "abcdefghijklmnopqrstuvwxyz";
set Intended(SubBackReferenceDolAtLeastTen)   "ajmnopqrstuvwxyz";
set TestRegexp(SubBackReferenceDolAtLeastTen) {(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)}
set TestSubexp(SubBackReferenceDolAtLeastTen) {$1$10};

#Test for substitution backreference with %k
set TestData(SubBackReferencePercent)  "abcdef";
set Intended(SubBackReferencePercent)  "abef";
set TestRegexp(SubBackReferencePercent) {(a.)(c.)(e.)};
set TestSubexp(SubBackReferencePercent) {%1%3};

#Test for substitution backreference with %0
set TestData(SubBackReferencePercentZero)  "abcdef";
set Intended(SubBackReferencePercentZero)  "ab abcdef";
set TestRegexp(SubBackReferencePercentZero) {(a.)(c.)(e.)};
set TestSubexp(SubBackReferencePercentZero) {%1 %0};

#Test for limit on number of groups in substitution backreference with %k
set TestData(SubBackReferencePercentAtLeastTen)   "abcdefghijklmnopqrstuvwxyz";
set Intended(SubBackReferencePercentAtLeastTen)   "ajmnopqrstuvwxyz";
set TestRegexp(SubBackReferencePercentAtLeastTen) {(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)}
set TestSubexp(SubBackReferencePercentAtLeastTen) {%1%10};

#Test for substitution backreference with \k
set TestData(SubBackRefbs)   "abcdef";
set Intended(SubBackRefbs)  "abef";
set TestRegexp(SubBackRefbs) {(a.)(c.)(e.)};
set TestSubexp(SubBackRefbs) {\1\3};

#Test for substitution backreference with \0
set TestData(SubBackRefbsZero)   "abcdef";
set Intended(SubBackRefbsZero)  "ab abcdef";
set TestRegexp(SubBackRefbsZero) {(a.)(c.)(e.)};
set TestSubexp(SubBackRefbsZero) {\1 \0};

#Test for limit on number of groups in substitution backreference with \k
set TestData(SubBackRefbsAtLeastTen)   "abcdefghijklmnopqrstuvwxyz";
set Intended(SubBackRefbsAtLeastTen)   "ajmnopqrstuvwxyz";
set TestRegexp(SubBackRefbsAtLeastTen)  {(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)}
set TestSubexp(SubBackRefbsAtLeastTen) {\1\10};

#Test for substitution backreference with \k and \(
set TestData(SubBackRefParbs)   "abcdef";
set Intended(SubBackRefParbs)  "abef";
set TestRegexp(SubBackRefParbs) {\(a.\)\(c.\)\(e.\)};
set TestSubexp(SubBackRefParbs) {\1\3};

#Test for substitution backreference with \0 and \(
set TestData(SubBackRefParbsZero)   "abcdef";
set Intended(SubBackRefParbsZero)  "ab abcdef";
set TestRegexp(SubBackRefParbsZero) {\(a.\)\(c.\)\(e.\)};
set TestSubexp(SubBackRefParbsZero) {\1 \0};

#Test for limit on number of groups in substitution backreference with \k and \(
set TestData(SubBackRefParbsAtLeastTen)   "abcdefghijklmnopqrstuvwxyz";
set Intended(SubBackRefParbsAtLeastTen)   "ajmnopqrstuvwxyz";
set TestRegexp(SubBackRefParbsAtLeastTen)  {\(a\)\(b\)\(c\)\(d\)\(e\)\(f\)\(g\)\(h\)\(i\)\(j\)\(k\)\(l\)}
set TestSubexp(SubBackRefParbsAtLeastTen) {\1\10};

#Test for substitution backreference with \\k
set TestData(SubBackRefdbs)   "abcdef";
set Intended(SubBackRefdbs)   "abef";
set TestRegexp(SubBackRefdbs) {(a.)(c.)(e.)};
set TestSubexp(SubBackRefdbs) {\\1\\3};

#Test for substitution backreference with \\0
set TestData(SubBackRefdbsZero)   "abcdef";
set Intended(SubBackRefdbsZero)  "ab abcdef";
set TestRegexp(SubBackRefdbsZero) {(a.)(c.)(e.)};
set TestSubexp(SubBackRefdbsZero) {\\1 \\0};

#Test for limit on number of groups in substitution backreference with \\k and 
set TestData(SubBackRefdbsAtLeastTen)   "abcdefghijklmnopqrstuvwxyz";
set Intended(SubBackRefdbsAtLeastTen)   "ajmnopqrstuvwxyz";
set TestRegexp(SubBackRefdbsAtLeastTen) {(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)};
set TestSubexp(SubBackRefdbsAtLeastTen) {\\1\\10};

#Test for substitution backreference with \\k and \\(\\)
set TestData(SubBackRefPardbsdbs)   "abcdef";
set Intended(SubBackRefPardbsdbs)   "abef";
set TestRegexp(SubBackRefPardbsdbs) {\\(a.\\)\\(c.\\)\\(e.\\)};
set TestSubexp(SubBackRefPardbsdbs) {\\1\\3};

#Test for substitution backreference with \\0 and \\(\\)
set TestData(SubBackRefPardbsdbsZero)   "abcdef";
set Intended(SubBackRefPardbsdbsZero)   "ab abcdef";
set TestRegexp(SubBackRefPardbsdbsZero) {\\(a.\\)\\(c.\\)\\(e.\\)};
set TestSubexp(SubBackRefPardbsdbsZero) {\\1 \\0};

#Test for limit on number of groups in substitution backreference with \\k and  \\(\\)
set TestData(SubBackRefPardbsdbsAtLeastTen)   "abcdefghijklmnopqrstuvwxyz";
set Intended(SubBackRefPardbsdbsAtLeastTen)   "ajmnopqrstuvwxyz";
set TestRegexp(SubBackRefPardbsdbsAtLeastTen) {\\(a\\)\\(b\\)\\(c\\)\\(d\\)\\(e\\)\\(f\\)\\(g\\)\\(h\\)\\(i\\)\\(j\\)\\(k\\)\\(l\\)};
set TestSubexp(SubBackRefPardbsdbsAtLeastTen) {\\1\\10};

#Test for substitution backreference to entire match with 0
set TestData(SubEntBackRefZero)   "abcdef";
set Intended(SubEntBackRefZero)   "abcdefabcdef";
set TestRegexp(SubEntBackRefZero) {(ab)(cdef)};
set TestSubexp(SubEntBackRefZero) {0 0};

#Test for substitution backreference to entire match with & as in Vim
set TestData(Subampentbackrefs)   "abcdef";
set Intended(Subampentbackrefs)   "abcdefabcdef";
set TestRegexp(Subampentbackrefs) {abcdef};
set TestSubexp(Subampentbackrefs) {&&};

#Test for substitution backreference to entire match with \\&
set TestData(Subampentbackrefsdbs)   "abcdef";
set Intended(Subampentbackrefsdbs)   "abcdefabcdef";
set TestRegexp(Subampentbackrefsdbs) {(ab)(cdef)};
set TestSubexp(Subampentbackrefsdbs) {\\&\\&};

#Test for substitution backreference to entire match with $&
set TestData(SubDolAmpEntBackRef)   "abcdef";
set Intended(SubDolAmpEntBackRef)   "abcdefabcdef";
set TestRegexp(SubDolAmpEntBackRef) {(ab)(cdef)};
set TestSubexp(SubDolAmpEntBackRef) {$&$&};

#Test for substitution backreference to entire match with \\& where
#parentheses must be double-backslashed.
set TestData(SubampentbackrefsPardbsdbs)   "abcdef";
set Intended(SubampentbackrefsPardbsdbs)   "abcdefabcdef";
set TestRegexp(SubampentbackrefsPardbsdbs) {\\(ab\\)\\(cdef\\)};
set TestSubexp(SubampentbackrefsPardbsdbs) {\\&\\&};

#Test for backreference to pre-match
set TestData(SubPreMatch)   "abcdef";
set Intended(SubPreMatch)   "ababef";
set TestRegexp(SubPreMatch) {cd};
set TestSubexp(SubPreMatch) {\`};

#Test for backreference to pre-match
set TestData(SubPreMatchDol)   "abcdef";
set Intended(SubPreMatchDol)   "ababef";
set TestRegexp(SubPreMatchDol) {cd};
set TestSubexp(SubPreMatchDol) {$`};

#Test for backreference to pre-match with 'pre
set TestData(SubPreMatchLit)   "abcdef";
set Intended(SubPreMatchLit)   "ab";
set TestRegexp(SubPreMatchLit) {cd};
set TestSubexp(SubPreMatchLit) {'pre};

#Test for backreference to post-match
set TestData(SubPostMatch)   "abcdef";
set Intended(SubPostMatch)   "abefef";
set TestRegexp(SubPostMatch) {cd};
set TestSubexp(SubPostMatch) {\'};

#Test for backreference to post-match
set TestData(SubPostMatchDol)   "abcdef";
set Intended(SubPostMatchDol)   "abefef";
set TestRegexp(SubPostMatchDol) {cd};
set TestSubexp(SubPostMatchDol) {$'};

#Test for backreference to post-match with post
set TestData(SubPostMatchLit)   "abcdef";
set Intended(SubPostMatchLit)   "ef";
set TestRegexp(SubPostMatchLit) {cd};
set TestSubexp(SubPostMatchLit) {'post};

#Test for backreference to last captured subgroup
set TestData(SubLastCapture)   "abcdef";
set Intended(SubLastCapture)   "ef";
set TestRegexp(SubLastCapture) {((ab)cd)(ef)};
set TestSubexp(SubLastCapture) {\+};

#Test for backreference to last captured subgroup
set TestData(SubLastCaptureDol)   "abcdef";
set Intended(SubLastCaptureDol)   "ef";
set TestRegexp(SubLastCaptureDol) {((ab)cd)(ef)};
set TestSubexp(SubLastCaptureDol) {$+};

#Test for tr style repetition notation C*N
set TestData(SubCStarN)   "starz";
set Intended(SubCStarN)   "aaaaz";
set TestRegexp(SubCStarN) {abcdefghijklmnopqrstuvwxyz};
set TestSubexp(SubCStarN) {[a*25]z};

#Test for tr style repetition notation C*
set TestData(SubCStar)   "starz";
set Intended(SubCStar)   "aaaaa";
set TestRegexp(SubCStar) {abcdefghijklmnopqrstuvwxyz};
set TestSubexp(SubCStar) {[a*]};

#Tests for tr versions of POSIX character classes

set TestData(SubAlnum) "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(SubAlnum)  "x\nx\nx\nx\n+\nx\n:\n?";
set TestRegexp(SubAlnum)   {[:alnum:]};
set TestSubexp(SubAlnum)   {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx};

set TestData(SubAlpha) "a\nB\nc\nZ\n+\n4\n:\n?";
set Intended(SubAlpha)  "x\nx\nx\nx\n+\n4\n:\n?";
set TestRegexp(SubAlpha)   {[:alpha:]};
set TestSubexp(SubAlpha)   {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx};

set TestData(SubBlank) "a\040b\na\011b\na\n4\n:";
set Intended(SubBlank) "axb\naxb\na\n4\n:";
set TestRegexp(SubBlank)   {[:blank:]};
set TestSubexp(SubBlank)   {xxxxxxxxxx};

set TestData(SubCntrl) "aabaAba4ba:ba\040ba\011ba\023ba\177b";
set Intended(SubCntrl) "aabaAba4ba:ba\040baXbaXbaXbX"; #Last X is for newline added to data
set TestRegexp(SubCntrl)   {[:cntrl:]};
set TestSubexp(SubCntrl)   {XXXXXXXXXXXXXXXXXXXXXXXXXX};

set TestData(SubDigit) "A\n:\nB\nb\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n?";
set Intended(SubDigit) "A\n:\nB\nb\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\n?";
set TestRegexp(SubDigit)  {[:digit:]};
set TestSubexp(SubDigit)  {DDDDDDDDDD};

set TestData(SubGraph) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(SubGraph) "ggg\nggg\nggg\nggg\ng\040g\ng\011g\ng\023g";
set TestRegexp(SubGraph)   {[:graph:]};
set TestSubexp(SubGraph)   {gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg};

set TestData(SubLower) "AaZ\nABZ\nAcZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set Intended(SubLower) "AAZ\nABZ\nACZ\nAZZ\nA+Z\nA4Z\nA:Z\nA?Z";
set TestRegexp(SubLower)  {[:lower:]};
set TestSubexp(SubLower)  {[:upper:]};

set TestData(SubPrint) "aab\naAb\na4b\na:b\na\040b\na\011b\na\023b";
set Intended(SubPrint) "ggg\nggg\nggg\nggg\nggg\ng\011g\ng\023g";
set TestRegexp(SubPrint)   {[:print:]};
set TestSubexp(SubPrint)   {gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg};

set TestData(SubPunct) "aaz\naBz\nacz\naZz\na4z\na:z\na?z\na!z\na\#z\na\$z\na%z\na&z\na*z\na(z\na)z\na-z\na,z\na.z\na/z";
set Intended(SubPunct)  "aaz\naBz\nacz\naZz\na4z\naPz\naPz\naPz\naPz\naPz\naPz\naPz\naPz\naPz\naPz\naPz\naPz\naPz\naPz";
set TestRegexp(SubPunct)   {[:punct:]};
set TestSubexp(SubPunct)   {PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP};

set TestData(SubSpace) "a\040ba\014ba\011ba\013ba4ba:bacb";
set Intended(SubSpace) "axbaxbaxbaxba4ba:bacbx"; #Last X is for newline added to data
set TestRegexp(SubSpace)   {[:space:]};
set TestSubexp(SubSpace)   {xxxxxxxxxx};

set TestData(SubUpper)     "aaz\naBz\nacz\naZz\na+z\na4z\na:z\na?z";
set Intended(SubUpper)     "aaz\nabz\nacz\nazz\na+z\na4z\na:z\na?z";
set TestRegexp(SubUpper)   {[:upper:]};
set TestSubexp(SubUpper)   {[:lower:]};

set TestData(SubXdigit) "A\nB\nC\nD\nE\nF\na\nb\nc\nd\ne\nf\n1\n2\n3\n4\n5\n6\n7\n8\n9\n0\nj\nk\n;\n?";
set Intended(SubXdigit) "D\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nD\nj\nk\n;\n?";
set TestRegexp(SubXdigit) {[:xdigit:]};
set TestSubexp(SubXdigit) {DDDDDDDDDDDDDDDDDDDDDD};

set TestData(SubRange) "x\ny\nz\na\nf\n4";
set Intended(SubRange) "F\nF\nF\na\nf\n4";
set TestRegexp(SubRange)   {[x-z]};
set TestSubexp(SubRange) {FFF};

#Tests for reluctant quantifiers
#These work for Java and Perl.
#To generalize them, turn them into templates and generate the actual expressions using our knowledge
#of what backreference notation the program uses and what quoting is necessary for
#capture groups.

set TestData(SubReluctantStarPrevDollar)     "abbbba";
set Intended(SubReluctantStarPrevDollar)     "bbbb";
set TestRegexp(SubReluctantStarPrevDollar)   {(a)(b*?)(b*)(a)};
set TestSubexp(SubReluctantStarPrevDollar)   {$3};

set TestData(SubReluctantPlusPrevDollar)     "abbbba";
set Intended(SubReluctantPlusPrevDollar)     "b";
set TestRegexp(SubReluctantPlusPrevDollar)   {(a)(b+?)(b+)(a)};
set TestSubexp(SubReluctantPlusPrevDollar)   {$2};

set TestData(SubReluctantQuestionMarkPrevDollar)     "abbbba";
set Intended(SubReluctantQuestionMarkPrevDollar)     "bbbb";
set TestRegexp(SubReluctantQuestionMarkPrevDollar)   {(a)(b??)(b+)(a)};
set TestSubexp(SubReluctantQuestionMarkPrevDollar)   {$3};

set TestData(SubReluctantIntegerRangeDollar)     "abbbba";
set Intended(SubReluctantIntegerRangeDollar)     "bb";
set TestRegexp(SubReluctantIntegerRangeDollar)   {(a)(b{2,4}?)(b+)(a)};
set TestSubexp(SubReluctantIntegerRangeDollar)   {$3};

# For Ruby
set TestData(SubReluctantStarPrevBackslash)     "abbbba";
set Intended(SubReluctantStarPrevBackslash)     "bbbb";
set TestRegexp(SubReluctantStarPrevBackslash)   {(a)(b*?)(b*)(a)};
set TestSubexp(SubReluctantStarPrevBackslash)   {\3};

set TestData(SubReluctantPlusPrevBackslash)     "abbbba";
set Intended(SubReluctantPlusPrevBackslash)     "b";
set TestRegexp(SubReluctantPlusPrevBackslash)   {(a)(b+?)(b+)(a)};
set TestSubexp(SubReluctantPlusPrevBackslash)   {\2};

set TestData(SubReluctantQuestionMarkPrevBackslash)     "abbbba";
set Intended(SubReluctantQuestionMarkPrevBackslash)     "bbbb";
set TestRegexp(SubReluctantQuestionMarkPrevBackslash)   {(a)(b??)(b+)(a)};
set TestSubexp(SubReluctantQuestionMarkPrevBackslash)   {\3};

set TestData(SubReluctantIntegerRangeBackslash)     "abbbba";
set Intended(SubReluctantIntegerRangeBackslash)     "bb";
set TestRegexp(SubReluctantIntegerRangeBackslash)   {(a)(b{2,4}?)(b+)(a)};
set TestSubexp(SubReluctantIntegerRangeBackslash)   {\3};

set TestData(ReluctantIntegerRangeVIMBackslash) "abbbbab\nabbbbabb\nabbbbabbb\nabbbbabbbb";
set Intended(ReluctantIntegerRangeVIMBackslash) "abbbbabb\nabbbbabbb"
set TestRegexp(ReluctantIntegerRangeVIMBackslash)   "^\\(a\\)\\(b\\\{-2,4}\\)\\(b\\+\\)\\(a\\)\\2$";
set TestData(ReluctantAtLeastMVIMBackslash) "abbbbab\nabbbbabb\nabbbbabbb\nabbbbabbbb";
set Intended(ReluctantAtLeastMVIMBackslash)  "abbbbabb\nabbbbabbb";
set TestRegexp(ReluctantAtLeastMVIMBackslash)   "^\\(a\\)\\(b\\\{-2,}\\)\\(b\\+\\)\\(a\\)\\2$";

set TestData(ReluctantAtMostNVIMBackslash) "abbbbab\nabbbbabb\nabbbbabbb\nabbbbabbbb";
set Intended(ReluctantAtMostNVIMBackslash)  "abbbbab\nabbbbabb\nabbbbabbb"
set TestRegexp(ReluctantAtMostNVIMBackslash)   "^\\(a\\)\\(b\\\{-,4}\\)\\(b\\+\\)\\(a\\)\\2$";

set TestData(ReluctantExactlyMVIMBackslash) "abbbbab\nabbbbabb\nabbbbabbb\nabbbbabbbb";
set Intended(ReluctantExactlyMVIMBackslash)  "abbbbabbb"
set TestRegexp(ReluctantExactlyMVIMBackslash)   "^\\(a\\)\\(b\\\{-3}\\)\\(b\\+\\)\\(a\\)\\2$";

set TestData(SubReluctantZeroOrMoreVIMBackslash)    "abc"
set TestRegexp(SubReluctantZeroOrMoreVIMBackslash)  ".\\\{-\}"
set TestSubexp(SubReluctantZeroOrMoreVIMBackslash)  X
set Intended(SubReluctantZeroOrMoreVIMBackslash)    "XaXbXc"

set TestData(PossStarA)     "aaaa";
set Intended(PossStarA)     "aaaa";
set TestRegexp(PossStarA)   "a*+";

set TestData(PossStarB)     "aaaa";
set Intended(PossStarB)     "";
set TestRegexp(PossStarB)   "a*+a";

set TestData(PossPlusA)     "aaaa";
set Intended(PossPlusA)     "aaaa";
set TestRegexp(PossPlusA)   "a++";

set TestData(PossPlusB)     "aaaa";
set Intended(PossPlusB)     "";
set TestRegexp(PossPlusB)   "a++a";

set TestData(PossQMarkA)     "a";
set Intended(PossQMarkA)     "a";
set TestRegexp(PossQMarkA)   "a?+";

set TestData(PossQMarkB)     "a";
set Intended(PossQMarkB)     "";
set TestRegexp(PossQMarkB)   "a?+a";

set TestData(PossAtLeastMA)     "aaaa";
set Intended(PossAtLeastMA)     "aaaa";
set TestRegexp(PossAtLeastMA)   "a{1,}+";

set TestData(PossAtLeastMB)     "aaaa";
set Intended(PossAtLeastMB)     "";
set TestRegexp(PossAtLeastMB)   "a{1,}+a";

set TestData(PossMToNA)     "aa\na";
set Intended(PossMToNA)     "aa\na";
set TestRegexp(PossMToNA)   "a{1,2}+";

set TestData(PossMToNB)     "aa\na";
set Intended(PossMToNB)     "";
set TestRegexp(PossMToNB)   "a{1,2}+a";

set TestData(PossMToNC)     "aaa\naa\na";
set Intended(PossMToNC)     "aaa";
set TestRegexp(PossMToNC)   "a{1,2}+a";

set TestData(SubLitString)    "abcde";
set Intended(SubLitString)    "GH";
set TestRegexp(SubLitString)  ".*cd.*";
set TestSubexp(SubLitString)  "\"GH\"";

set TestData(ExactMatchWD)      "read\nready\nbeads\nroads\nreads"
set Intended(ExactMatchWD)      "read\nready\nbeads\nreads";
set TestRegexp(ExactMatchWD)    "r<ead>s";

set TestData(ExactMatchTRE)      "read\nready\nbeads\nroads\nreads"
set Intended(ExactMatchTRE)      "read\nready\nbeads\nreads";
set TestRegexp(ExactMatchTRE)    "r(ead){~0}s";

set TestData(ExactMatchCgrep)      "read\nready\nbeads\nroads\nreads"
set Intended(ExactMatchCgrep)      "read\nready\nbeads\nreads";
set TestRegexp(ExactMatchCgrep)    "r<ead>";

set TestData(TRECostSetting)      "read\nready\nbeads\nroads\nreads\nrains"
set Intended(TRECostSetting)      "read\nready\nroads\nreads"
set TestRegexp(TRECostSetting)    "r(eads){~1,1i+1d+1s}";

set TestData(TotalErrorCrosshatchA) "abc\ndbc\nadc\nabd\nabcd\nzabc"
set Intended(TotalErrorCrosshatchA) "abc\ndbc\nadc\nabd\nabcd\nzabc"
set TestRegexp(TotalErrorCrosshatchA) {(#a1)^abc$}

#The results I get disagree with the documentation so leave this
#out until I can find out if sleep is buggy or if I have misunderstood.

#set TestData(ReluctantStar) "this is me testing with this test\nthis is me test";
#set Intended(ReluctantStar) "this is me test";
#set TestRegexp(ReluctantStar) {this*test}

#set TestData(GreedyDoubleStar) "this is me testing with this test\nthis is me test";
#set Intended(GreedyDoubleStar) "this is me testing with this test";
#set TestRegexp(GreedyDoubleStar) {this**test}

set TestData(ColumnSpecifier) "abcde\nabcd\nabc\nab\na"
set Intended(ColumnSpecifier) "abcde\nabcd"
set TestRegexp(ColumnSpecifier) {\%4c.}

set TestData(PreColumnSpecifier)   "X\nAX\nABX\nABCX"
set Intended(PreColumnSpecifier)   "X\nAX"
set TestRegexp(PreColumnSpecifier) {\%<3cX}

set TestData(PostColumnSpecifier)   "X\nAX\nABX\nABCX\nABCDX"
set Intended(PostColumnSpecifier)   "ABCX\nABCDX"
set TestRegexp(PostColumnSpecifier) {\%>3cX}

#Tests for Sgrep

#Test for Sgrep-style character range
set TestData(CposRange) "abcde"
set Intended(CposRange)  "bcd"
set TestRegexp(CposRange)  {[(1,3)]};

#Test for Sgrep-style bounded region
set TestData(RegionDoubleDot) "<b>foo</b>\n</b>foo<b>\nfoo\n(foo)\n<b>bar</b>"
set Intended(RegionDoubleDot)  "foo"
set TestRegexp(RegionDoubleDot)  {"<b>" .. "</b>"};


proc NoEnc {or re} {
    set ol [split $or  ""]
    set rl [split $re ""]
    foreach o $ol r $rl {
	if {($o != $r) && ($r == "?")} {
	    lappend NoEncoding $o
	}
    }
    return [lsort -unique $NoEncoding]
}

proc PutNL {fh} {
    puts $fh ""
}

proc PutWithEncoding {fh enc s} {
    set es [encoding convertto $enc $s]
    set re [encoding convertfrom $enc $es]
    if {[string equal $s $re] == 1} {
	set SavedEncoding [fconfigure $fh -encoding]
	fconfigure $fh -encoding binary
	puts -nonewline $fh $es
	fconfigure $fh -encoding $SavedEncoding
    } else {
	foreach c [NoEnc $s $re] {
	    scan $c "%c" t
	    append str [format "%s (U+%04X)  " $c $t]
	}
	set str [string trimright $str]
	error "The following characters do not exist in the $enc encoding: $str"
    }
}

proc GetVersion {p} {
    set failmsg  [_ "version unknown"];
    switch -exact -- $p {
	agrep {
	    if {[catch {exec agrep --version} vinfo] == 0} {
		return [lindex [split $vinfo "\n"] 0]
	    } else {
		return [_ "Agrep declines to reveal its age"]
	    }
	}
	arena {
	    return [exec arena -V]
	}
	awk {
	    return [lindex [split [exec awk --version] "\n"] 0]
	}
	bash {
	    return [lindex [split [exec bash --version] "\n"] 0]
	}
	boo {
	    return [lindex [split [exec boo --version] "\n"] 0];# Fix this
	}
	BusyBoxEgrep {
	    catch {exec busybox grep} vinfo
	    return [lindex [lindex [split $vinfo "\n"] 0] 1]
	}
	C {
	    return [_ "C declines to reveal its age"]
	}
	cgrep {
	    catch {exec cgrep} vline;
	    return [lindex [split $vline] 4]
	}
	ed {
	    return [lindex [split [exec ed --version] "\n"] 0]
	}
	egrep {
	    return [lindex [split [exec egrep --version] "\n"] 0]
	}
	emacs {
	    return [lindex [split [exec emacs --version] "\n"] 0]
	}
	euphoria {
	    return [_ "Euphoria declines to reveal its age"]
	}
	"expr" {
	    return [lindex [exec expr --version] 3]
        }
	fgrep {
	    return [lindex [split [exec fgrep --version] "\n"] 0]
	}
	fish {
	    catch {[exec fish -v 2> $::VersionFile]}
	    if {[catch {open $::VersionFile "r"} TmpHandle ] != 0} {
		ShowMessage [format [_ "Mysterious failure to open temporary file %s."] $::VersionFile];
		return $failmsg;
	    }
	    if {[gets $TmpHandle vline] < 1} {
		return $failmsg;
	    }
	    close $TmpHandle
	    #	    file delete -force $::VersionFile; #debug
	    return [string trim [lindex [split $vline ","] 1]]
	}
	flex {
	    return [exec flex -V]
	}
	frink {
	    return [exec java -cp frink.jar frink.parser.Frink --version];
	}
	gawk {
	    return [lindex [split [exec gawk --version] "\n"] 0]
	}
	glark {
	    return [lindex [split [exec glark -v] "\n"] 0]
	}
	gpp {
	    return [exec gpp --version]
	}
	grep {
	    return [lindex [split [exec grep --version] "\n"] 0]
	}
	groovy {
	    set r [exec groovy --version]
	    return [lindex $r 2]
	}
	guile {
	    return [lindex [split [exec guile -v] "\n"] 0]
	}
	icon {
	    catch {[exec icon -V 2> $::VersionFile]}
	    if {[catch {open $::VersionFile "r"} TmpHandle ] != 0} {
		ShowMessage [format [_ "Mysterious failure to open temporary file %s."] $::VersionFile];
		return $failmsg;
	    }
	    if {[gets $TmpHandle vline] < 1} {
		return $failmsg;
	    }
	    close $TmpHandle
	    file delete -force $::VersionFile
	    return [string range $vline 0 [expr [string first "," $vline] -1] ];
	}
	ici {
	    catch {[exec ici -v 2> $::VersionFile]}
	    if {[catch {open $::VersionFile "r"} TmpHandle ] != 0} {
		ShowMessage [format [_ "Mysterious failure to open temporary file %s."] $::VersionFile];
		return $failmsg;
	    }
	    if {[gets $TmpHandle vline] < 1} {
		return $failmsg;
	    }
	    close $TmpHandle
	    file delete -force $::VersionFile
	    return [lindex [split $vline] 1]
	}
	java {
	    catch {[exec java -version 2> $::VersionFile]}
	    if {[catch {open $::VersionFile "r"} TmpHandle ] != 0} {
		ShowMessage [format [_ "Mysterious failure to open temporary file %s."] $::VersionFile];
		return $failmsg;
	    }
	    if {[gets $TmpHandle vline] < 1} {
		return $failmsg;
	    }
	    close $TmpHandle
	    file delete -force $::VersionFile
	    return [string trim [lindex [split $vline] 2] {\"}];
	}
	javascript {
	    return [lindex [split [exec js --version] "\n"] 0]
	}
	jgrep {
	    return [_ "Jgrep declines to reveal its age"]
	}
	judoscript {
	    return [lindex [split [exec java -jar judo.jar] "\n"] 1]
	}
	ksh {
	    return [_ "Ksh declines to reveal its age"]
	}
	lua {
	    catch {[exec lua -v 2> $::VersionFile]}
	    if {[catch {open $::VersionFile "r"} TmpHandle ] != 0} {
		ShowMessage [format [_ "Mysterious failure to open temporary file %s."] $::VersionFile];
		return $failmsg;
	    }
	    if {[gets $TmpHandle vline] < 1} {
		return $failmsg;
	    }
	    close $TmpHandle
	    file delete -force $::VersionFile
	    return [string range $vline 0 [expr [string first "Copyright" $vline] -3]];
	}
	m4 {
	    return [exec m4 --version]
	}
	mawk {
	    set vinfo [lindex [split [exec mawk -W version 2> /dev/null] "\n"] 0];	
	    return [list [lindex $vinfo 0] [lindex $vinfo 1]];
	}
	minised {
	    return [_ "Minised declines to reveal its age"]
	}
	mysql {
	    set vinfo [split [exec mysql -V]]
	    lappend v [lindex $vinfo 2]
	    lappend v [lindex $vinfo 3]
	    lappend v [lindex $vinfo 4]
	    lappend v [lindex $vinfo 5]
	    return [join $v]
	}
	nawk {
	    return [_ "Nawk declines to reveal its age"]
	}
	nrgrep {
	    set vinfo [lindex [split [exec nrgrep -H] "\n"] 2];
	    return [format "%s %s" [_ "version"] [string trimright [lindex $vinfo 2] ","]];
	}
	numgrep {
	    return [_ "Numgrep declines to reveal its age"]
	}
	patmatch {
	    return [_ "Patmatch declines to reveal its age"]
	}
	pcregrep {
	    catch {[exec pcregrep --version 2> $::VersionFile]}
	    if {[catch {open $::VersionFile "r"} TmpHandle ] != 0} {
		ShowMessage [format \
			 [_ "Mysterious failure to open temporary file %s."] $::VersionFile];
		return $failmsg;
	    }
	    if {[gets $TmpHandle vline] < 1} {
		return $failmsg;
	    }
	    close $TmpHandle
	    file delete -force $::VersionFile
	    set version [lindex $vline 2]
	    set date [lindex $vline 3]
	    set pcreversion [lindex $vline 7]
	    set pcredate [lindex $vline 8]
	    return [format "%s (%s\) using pcre %s (%s)" $version $date $pcreversion $pcredate]
	}
	perl {
	    set vinfo [lindex [split [exec perl -v] "\n"] 1];
	    return [lindex [split $vinfo] 3];
	}
	pike {
	    catch {[exec pike -v 2> $::VersionFile]}
	    if {[catch {open $::VersionFile "r"} TmpHandle ] != 0} {
		ShowMessage [format [_ "Mysterious failure to open temporary file %s."] $::VersionFile];
		return $failmsg;
	    }
	    if {[gets $TmpHandle vline] < 1} {
		return $failmsg;
	    }
	    close $TmpHandle
	    file delete -force $::VersionFile
	    return [string range $vline 0 [string first "Copyright" $vline]];
	}
	python {
	    catch {[exec python -V 2> $::VersionFile]}
	    if {[catch {open $::VersionFile "r"} TmpHandle ] != 0} {
		ShowMessage [format [_ "Mysterious failure to open temporary file %s."] $::VersionFile];
		return $failmsg;
	    }
	    if {[gets $TmpHandle vline] < 1} {
		return $failmsg;
	    }
	    close $TmpHandle
	    file delete -force $::VersionFile
	    return $vline;
	}
	rc {
	    return [lindex [exec rc -c {echo $version}] 0]
	}
	rebol {
	    set vinfo [lindex [split [exec rebol --help --do q] "\n"] 1];    
	    return [string range $vinfo [string first REBOL $vinfo] end]
	}
	rep {
	    return [exec rep --version]
	}
	ruby {
	    set vinfo [lindex [split [exec ruby -v] "\n"] 0];  
	    return [string range $vinfo 0 [expr [string first \[ $vinfo] -2]];
	}
	sed {
	    if {[catch {exec sed --version} vinfo] == 0} {
		return [lindex [split $vinfo "\n"] 0]
	    } else {
		return [_ "Sed declines to reveal its age"]	
	    }
	}
	sgrep {
	    return [lindex [exec sgrep -V] 2]
	}
	ssed {
	    return [lindex [split [lindex [split [exec ssed --version] "\n"] 0]] 2] 
	}
	tcl {
	    return [info patchlevel]
	}
	tclglob {
	    return [info patchlevel]
	}
	tcsh {
	    set vilist [split [lindex [split [exec tcsh --version] "\n"] 0]]
	    return [format "%s %s %s" [lindex $vilist 1] [lindex $vilist 2] [lindex $vilist 3]]
	}
	tr {
	    return [lindex [split [exec tr --version] "\n"] 0]
	}
	vim {
	    set vilist [split [lindex [split [exec vim --version] "\n"] 0]]
	    return [join [lreplace $vilist 0 3]]
	}
	xmlgawk {
	    return [lindex [split [lindex [split [exec xmlgawk --version] "\n"] 0]] 3]
	}
	xmlstarlet {
	    return [exec xml --version]
	}
	wmagrep {
	    return [_ "Wu-Manber agrep declines to reveal its age"]	
	}
	zsh {
	    return [exec zsh --version]
	}
	default {
	    return $failmsg;
	}
    }
}

#Return the full name of the currently selected daughter program
proc NameProgram {} {
    if {[string equal $::program agrep]} {
	if {$::ProgramInfo(agrep,TreAgrepP) == 1} {
	    return "TRE agrep";
	} else {
	    return "Wu-Manber agrep";
	}
    } elseif {[string equal $::program sed]} {
	return $::ProgramInfo(sed,Which)
    } else {
	return $::program;
    }
}

proc LoadMessageCatalog {} {
    global DebugP;

    if {$DebugP} {
	if {[::msgcat::mcload "msgs"] == 0} {
	    puts "No message catalog loaded."
	} else {
	    puts "Message catalog loaded."
	}
    } else {
	::msgcat::mcload [file join [file dirname [info script]] msgs];
    }
}

proc ScaleMoveBigIncrement {w k x y} {
    set part [$w identify $x $y]
    set inc 0;
    switch -exact -- $part {
	trough1 {
	    set dir -1;
	}
	trough2 {
	    set dir  1;
	}
	default {
	    return ;
	}
    }
    set Resolution [$w cget -resolution]
    set CurrentValue [$w get]
    set Delta [expr $dir * $k * $Resolution]
    $w set [expr $CurrentValue + $Delta]
}

# Given a number represented as a string, insert delimiters to break it up for
# readability. Normally, the delimiter will be a comma which will be inserted every
# three digits. However, the delimiter and groupsize are arguments, permitting use
# in other locales.
#
# The string is assumed to consist of digits, possibly preceded by spaces,
# and possibly containing a decimal point, i.e.: [:space:]*[:digit:]*\.[:digit:]*

proc DelimitNumber {number {delim ","} {GroupSize 3}} {
    # First, extract right hand part of number, up to and including decimal point
    set point [string last "." $number];
    if {$point >= 0} {
	set PostDecimal [string range $number [expr $point + 1] end];
	set PostDecimalP 1;
    } else {
	set point [expr [string length $number] + 1]
	set PostDecimal "";
	set PostDecimalP 0;
    }

    # Now extract any leading spaces.
    set ind 0;
    while {[string equal [string index $number $ind] \u0020]} {
	incr ind;
    }
    set FirstNonSpace $ind;
    set LastSpace [expr $FirstNonSpace - 1];
    set LeadingSpaces [string range $number 0 $LastSpace];

    # Now extract the non-fractional part of the number, omitting leading spaces.
    set MainNumber [string range $number $FirstNonSpace [expr $point - 1]];

    # Insert commas into the main number.
    set Length [string length $MainNumber];
    set Phase  [expr $Length % $GroupSize]
    set PhaseMinusOne  [expr $Phase -1];
    set DelimitedMain "";

    #First we deal with the extra stuff.
    if {$Phase > 0} {
	append DelimitedMain [string range $MainNumber 0 $PhaseMinusOne];
    }
    set FirstInGroup $Phase;
    set LastInGroup [expr $FirstInGroup + $GroupSize -1];
    while {$LastInGroup < $Length} {
	if {$FirstInGroup > 0} {
	    append DelimitedMain $delim;
	}
	set ToAppend [string range $MainNumber $FirstInGroup $LastInGroup];
	append DelimitedMain [string range $MainNumber $FirstInGroup $LastInGroup];
	incr FirstInGroup $GroupSize
	incr LastInGroup  $GroupSize
    }

    # Reassemble the number.
    if {$PostDecimalP} {
	return [format "%s%s.%s" $LeadingSpaces $DelimitedMain $PostDecimal];
    } else {
	return [format "%s%s" $LeadingSpaces $DelimitedMain];
    }
}

#Font system begins here

# We set these outside the namespace since FontInfo has to be global.
# Default defaults
if {$TkEightFivePlusOnX11P} {
    set FontInfo(size) 9
} else {
    set FontInfo(size) 12
}
set FontInfo(family) courier
set FontInfo(weight) normal
set FontInfo(slant) roman
set FontInfo(underline) 0
set FontInfo(overstrike) 0

namespace eval fontsel {
    variable FontPropertyList [list family size weight slant underline overstrike]
    variable FontPropertyClass
    variable FSCColors

    foreach p $FontPropertyList {
	set FontPropertyClass($p) generic;
    }
    set FontPropertyClass(underline) boolean
    set FontPropertyClass(overstrike) boolean

    #We check the existence of the variable so that this
    #can safely be called AFTER non-default values are set.
    proc SetFontInfoDefaults {} {
	global FontInfo;
	foreach ft $::FontList {
	    if {![info exist FontInfo($ft,family)]} {
		set FontInfo($ft,family)	$FontInfo(family)
	    }
	    if {![info exist FontInfo($ft,size)]} {
		set FontInfo($ft,size)	$FontInfo(size)
	    }
	    if {![info exist FontInfo($ft,weight)]} {
		set FontInfo($ft,weight)	$FontInfo(weight)
	    }
	    if {![info exist FontInfo($ft,slant)]} {
		set FontInfo($ft,slant)	$FontInfo(slant)
	    }
	    if {![info exist FontInfo($ft,underline)]} {
		set FontInfo($ft,underline)	$FontInfo(underline)
	    }
	    if {![info exist FontInfo($ft,overstrike)]} {
		set FontInfo($ft,overstrike)	$FontInfo(overstrike)
	    }
	    if {![info exist FontInfo($ft,gloss)]} {
		set FontInfo($ft,gloss)	$ft;
	    }
	    if {![info exist FontInfo($ft,help)]} {
		set FontInfo($ft,help)	"?"
	    }
	}
    }

    #For a given font assign font-specific properties from generics.
    proc FontSet {which} {
	global FontInfo
	variable FontPropertyList
	foreach prop $FontPropertyList {
	    set FontInfo($which,$prop) $FontInfo($prop);
	}
    }

    #Assign the proprety values of a specified font to the generics.
    proc InverseFontSet {which} {
	global FontInfo
	variable FontPropertyList
	foreach prop $FontPropertyList {
	    set FontInfo($prop) $FontInfo($which,$prop);
	}
    }

    #Configure a specified font according to the font-specific properties.
    proc ConfigureFont {which} {
	global FontInfo
	variable FontPropertyList
	foreach prop $FontPropertyList {
	    font configure $which -$prop $FontInfo($which,$prop)
	}
    }

    #Record as default values the font-specific values of properties at the
    #time of the call. The recorded values are intended for use by
    #ResetToDefaults 
    proc RecordDefaults {} {
	global FontInfo
	global FontList;
	variable FontPropertyList

	foreach f $FontList {
	    foreach p $FontPropertyList {
		set FontInfo($f,$p,Default) $FontInfo($f,$p);
	    }
	}
    }

    #Create all of the fonts on the font list and configure them
    #according to the generic values of the properties, which are
    #also assigned at this time to the font-specific variables.
    proc CreateFonts {} {
	global FontList;

	foreach ft $FontList {
	    font create $ft;
	    InverseFontSet $ft;
	    ConfigureFont $ft;
	}
    
    }

    #Get the values from the three scales, combine them into a hex RGB spec,
    #assign its value to FontExampleColor, and configure the two examples.
    proc UpdateFontExampleColor {x} {
	variable FSCColors
	global FontExampleColorConfigureWhich

	UpdateFontExampleColorHex;
	.selectFont.curcan.att.r1c1 configure \
	    -$::FontExampleColorConfigureWhich  \#$::FontExampleColor
	.selectFont.curcan.att.r2c1 configure \
	    -$::FontExampleColorConfigureWhich \#$::FontExampleColor
	set FSCColors(red,$FontExampleColorConfigureWhich)   $::FontRed;
	set FSCColors(green,$FontExampleColorConfigureWhich) $::FontGreen;
	set FSCColors(blue,$FontExampleColorConfigureWhich)  $::FontBlue;
    }

    proc UpdateFontExampleColorHex {} {
	set ::FontExampleColor [format "%02X%02X%02X" $::FontRed $::FontGreen $::FontBlue];
    }

    proc RestoreCSColors {} {
	variable FSCColors
	global FontExampleColorConfigureWhich
	set ::FontRed   $FSCColors(red,$FontExampleColorConfigureWhich)
	set ::FontGreen $FSCColors(green,$FontExampleColorConfigureWhich)
	set ::FontBlue  $FSCColors(blue,$FontExampleColorConfigureWhich)
	UpdateFontExampleColorHex;
    }

    proc CloneMainFontAsFontControlPanelFont {} {
	variable FontPropertyList
	global FontInfo

	foreach p $FontPropertyList {
	    font configure FontControlPanelFont -$p $FontInfo(MainFont,$p);
	}
    }
					

    #We create this separately because we don't want it on the FontList.
    font create FontControlPanelFont;

    #This is the main procedure of this package.
    #It creates the font control panel.
    proc CreateFontControlPanel {args} {
	global FontInfo;
	global WhichFontToSet
	global FontList;
	variable FontPropertyList
	variable FSCColors

	set General 1
	set exwid 10

	set w .selectFont
	if {[winfo exists $w]} {
	    wm deiconify $w;
	    raise $w;
	    return ;
	}
	toplevel $w
	wm title $w [_ "Font Selection"]
	BindKeys $w
	wm protocol $w WM_DELETE_WINDOW "wm withdraw $w"
	
	#The idea is that in general we want to use the main
	#font here, but we keep them separate so that we
	#can wait before switching the control panel to
	#the new main font configuration so that
	#the user isn't confronted with an unusable
	#control panel if he or she sets the mainfont to something
	#crazy.
	CloneMainFontAsFontControlPanelFont;

	if {[llength $args] > 0} {
	    set ::WhichFontToSet [lindex $args 0];
	    set General 0;
	} 
	set FontTypes [llength $FontList];
	if {$FontTypes == 1} {
	    set ::WhichFontToSet [lindex $FontList 0];
	    set General 0;
	}

	frame $w.which -relief ridge -border 3
	if {$General} {
	    set msg [_ "For what aspect of the program\ndo you wish to set the font?"]
	    balloonhelp_for $w.which $msg
	    label $w.which.title -text [_ "Use for which to set font"] \
		-anchor w -font FontControlPanelFont
	    frame $w.which.btns;
	    set k 0;
	    set PerRow 4;
	    set ypad 3
	    set xpad 10
	    foreach ft $FontList {
		set bn $w.which.btns.f$ft;
		radiobutton $bn -text [_ $FontInfo($ft,gloss)]  \
		    -variable WhichFontToSet -value $ft \
		    -command fontsel::SetFontSelectionDefaults \
		    -font FontControlPanelFont \
		    -indicatoron 0 -selectcolor $::ColorSpecs(Default,Background)
		balloonhelp_for $w.which.btns.f$ft $FontInfo($ft,help)
		set row [expr 1+ $k/$PerRow]
		set col [expr $k%$PerRow]
		if {$FontTypes >= $PerRow} {
		    grid $w.which.btns.f$ft -row $row -column $col \
			-sticky we -ipadx 3 -padx $xpad -pady $ypad
		}
		incr k
	    }
	    if {$FontTypes < $PerRow} {
		foreach ft $FontList {
		    pack $w.which.btns.f$ft -side left -expand 1 -fill x \
			-ipadx 5 -ipady 3 -padx 40 -pady 3
		}
	    }
	    frame $w.which.pad  -height 4
	    pack $w.which.title -side top -expand 1 -fill both -anchor w
	    pack $w.which.btns  -side top -expand 1 -fill both -anchor w
	    pack $w.which.pad   -side top -expand 0 -fill x    -anchor w

	}

	frame $w.mid 
	frame $w.mid.opts  -relief ridge -border 3
	frame $w.mid.families  -relief ridge -border 3
	label $w.mid.families.lab -text [_ "Family"] -relief ridge \
	    -justify center -font FontControlPanelFont
	listbox $w.mid.families.lb -height 1 -exportselection 0 \
	    -yscrollcommand "$w.mid.families.sbar set" -selectmode single \
	    -font FontControlPanelFont
	scrollbar $w.mid.families.sbar -orient vertical -command "$w.mid.families.lb yview"
	bind $w.mid.families.sbar <<B3>> \
	    "ScrollbarMoveBigIncrement $w.mid.families.sbar 0.20 %x %y"

	bind $w.mid.families.lb <<B3>> ProvideFontDescription

	pack $w.mid.families.lab  -side top -expand 0 -fill x
	pack $w.mid.families.lb   -side left -expand 1 -fill both
	pack $w.mid.families.sbar -side left -expand 1 -fill y

	label $w.mid.opts.lab -text [_ "Attributes"] -relief ridge \
	    -justify center -font FontControlPanelFont
	label $w.mid.opts.sizel -text [_ "Size:"]  -font FontControlPanelFont
	scale $w.mid.opts.size -orient h -digit 1 -from 5 -to 55 \
	    -variable FontInfo(size)  -tickinterval 0 -length 150 \
	    -font FontControlPanelFont
	bind $w.mid.opts.size <<B3>> "ScaleMoveBigIncrement $w.mid.opts.size 5 %x %y"

	label $w.mid.opts.weightl -text [_ "Bold:"] \
	    -font FontControlPanelFont	    
	checkbutton $w.mid.opts.weight -variable FontInfo(weight) \
	    -onvalue bold -offvalue normal  -font FontControlPanelFont

	label $w.mid.opts.slantl -text [_ "Italic:"] \
	    -font FontControlPanelFont
	checkbutton $w.mid.opts.slant -variable FontInfo(slant) \
	    -onvalue italic -offvalue roman -font FontControlPanelFont

	label $w.mid.opts.ulinel -text [_ "Underline:"] \
	    -font FontControlPanelFont
	checkbutton $w.mid.opts.uline -variable FontInfo(underline) \
	    -onvalue 1 -offvalue 0  -font FontControlPanelFont

	label $w.mid.opts.strkovl -text [_ "Overstrike:"] \
	    -font FontControlPanelFont
	checkbutton $w.mid.opts.strkov -variable FontInfo(overstrike) \
	    -onvalue 1 -offvalue 0  -font FontControlPanelFont

	grid $w.mid.opts.lab   -row 0 -column 0 -columnspan 2 -sticky ew
	grid $w.mid.opts.sizel -row 1 -column 0 -sticky w
	grid $w.mid.opts.size -row 1 -column 1 -sticky w
	grid $w.mid.opts.weightl -row 2 -column 0 -sticky w
	grid $w.mid.opts.weight -row 2 -column 1 -sticky w
	grid $w.mid.opts.slantl -row 3 -column 0 -sticky w
	grid $w.mid.opts.slant -row 3 -column 1 -sticky w
	grid $w.mid.opts.ulinel -row 4 -column 0 -sticky w
	grid $w.mid.opts.uline -row 4 -column 1 -sticky w
	grid $w.mid.opts.strkovl -row 5 -column 0 -sticky w
	grid $w.mid.opts.strkov -row 5 -column 1 -sticky w

	pack $w.mid.families -side left -expand 1 -fill both -padx 5 -pady 2
	pack $w.mid.opts     -side left -expand 1 -fill both -padx 5 -pady 2

	eval $w.mid.families.lb insert 0 [lsort [font families]]

	bind $w.mid.families.lb <ButtonPress-1> {fontsel::SelectFontFamily %W %y}

	frame $w.cntls -relief ridge -border 3
	button $w.cntls.sav -text [_ "Apply"]  -command fontsel::FontSave \
	    -font FontControlPanelFont
	button $w.cntls.res -text [_ "Reset"] -command  fontsel::ResetToDefaults \
	    -font FontControlPanelFont
	button $w.cntls.can -text [_ "Dismiss"] -command "wm withdraw $w" \
	    -font FontControlPanelFont
	button $w.cntls.cpanel -text [_ "Here Too?"] \
	    -command fontsel::CloneMainFontAsFontControlPanelFont \
	-font FontControlPanelFont
	pack $w.cntls.cpanel -side left  -expand 1 -fill both -padx 3
	pack $w.cntls.can    -side left  -expand 1 -fill both -padx 3
	pack $w.cntls.res    -side left  -expand 1 -fill both -padx 3
	pack $w.cntls.sav    -side right -expand 1 -fill both -padx 3

	set msg [_ "Press this button to dismiss the popup."];
	balloonhelp_for $w.cntls.can $msg
	set msg [_ "Press this button to reset the font to its defaults."];
	balloonhelp_for $w.cntls.res $msg
	set msg [_ "Press this button to make the changes\nyou have made take effect."]
	balloonhelp_for $w.cntls.sav $msg
	set msg [format \
	     [_ "Press this button to set the fonts\nin this control panel to the %s font."] \
		     [_ $::FontInfo(MainFont,gloss)]]
	balloonhelp_for $w.cntls.cpanel $msg

	frame $w.curcan -relief ridge -border 1
	set ATT [frame $w.curcan.att]
	set Row 0
	foreach r {Header Current Candidate} {
	    set Column 2
	    foreach p $FontPropertyList {
		set v $w.curcan.att.r${Row}c${Column};
		label $v  -font FontControlPanelFont
		incr Column;
	    } 
	    incr Row;
	}

	font create CurrentFontExampleFont \
	    -family $FontInfo($::WhichFontToSet,family) \
	    -size $FontInfo($::WhichFontToSet,size) \
	    -weight $FontInfo($::WhichFontToSet,weight) \
	    -slant $FontInfo($::WhichFontToSet,slant) \
	    -underline $FontInfo($::WhichFontToSet,underline) \
	    -overstrike $FontInfo($::WhichFontToSet,overstrike);

	font create CandidateFontExampleFont \
	    -family $FontInfo($::WhichFontToSet,family) \
	    -size $FontInfo($::WhichFontToSet,size) \
	    -weight $FontInfo($::WhichFontToSet,weight) \
	    -slant $FontInfo($::WhichFontToSet,slant) \
	    -underline $FontInfo($::WhichFontToSet,underline) \
	    -overstrike $FontInfo($::WhichFontToSet,overstrike);

	label $w.curcan.att.r0c0 -font FontControlPanelFont
	label $w.curcan.att.r0c1 -font FontControlPanelFont
	label $w.curcan.att.r1c0  -text [_ "Current"] -font FontControlPanelFont
	entry $w.curcan.att.r1c1 -font CurrentFontExampleFont -relief flat -width $exwid
	$w.curcan.att.r1c1 insert 0 [_ "example"]
	label $w.curcan.att.r2c0  -text [_ "Candidate"] -font FontControlPanelFont
	entry $w.curcan.att.r2c1 -font CandidateFontExampleFont -relief flat  -width $exwid
	$w.curcan.att.r2c1 insert 0 [_ "example"]

	#This is for use in conjunction with my character insertion library.
	#It arranges for the various character insertion widgets to insert
	#characters into the focussed window.
	if {[llength [info commands BindInsertionTarget]]} {
	    BindInsertionTarget $w.curcan.att.r1c1;
	    BindInsertionTarget $w.curcan.att.r2c1;
	}

	set CLR [frame $w.curcan.clr]
	set ln 60;
	set wd 10
	set trc \#D4B8C1
	scale $CLR.red -orient v -digit 1 -from 255 -to 0 -tickinterval 0 \
	    -variable FontRed  -showvalue 0 -length $ln -width $wd\
	    -troughcolor $trc -activebackground \#F0AAAA \
	    -bg red -fg yellow -command fontsel::UpdateFontExampleColor
	scale $CLR.grn -orient v -digit 1 -from 255 -to 0 -tickinterval 0 \
	    -variable FontGreen  -showvalue 0 -length $ln -width $wd\
	    -troughcolor $trc -activebackground \#AAF0AA \
	    -bg green -fg yellow -command fontsel::UpdateFontExampleColor
	scale $CLR.blu -orient v -digit 1 -from 255 -to 0 -tickinterval 0 \
	    -variable FontBlue  -showvalue 0 -length $ln -width $wd\
	    -troughcolor $trc -activebackground \#AAAAF0 \
	    -bg blue -fg yellow -command fontsel::UpdateFontExampleColor
	set FSCColors(red,bg)   0x00
	set FSCColors(green,bg) 0x00
	set FSCColors(blue,bg)  0x00
	set FSCColors(red,fg)   0x00
	set FSCColors(green,fg) 0x00
	set FSCColors(blue,fg)  0x00

	bind $CLR.red <<B3>> "ScaleMoveBigIncrement $CLR.red -20 %x %y"
	bind $CLR.grn <<B3>> "ScaleMoveBigIncrement $CLR.grn -20 %x %y"
	bind $CLR.blu <<B3>> "ScaleMoveBigIncrement $CLR.blu -20 %x %y"

	set ::FontRed   255
	set ::FontGreen 255
	set ::FontBlue  255
	set FontExampleColor \#FFFFFF
	label $CLR.rdt -textvariable FontExampleColor -width 7 -relief raised
	bind $CLR.rdt <Button-1> "pack forget $CLR"
	bind $ATT <Button-1> "pack $w.curcan.clr -before $ATT -side left -expand 1 -fill both"
	set msg [_ "Left click here to remove the color selector."]
	balloonhelp_for $CLR.rdt $msg;
	set msg [_ "Use this to set the colors in the example text boxes."]
	balloonhelp_for $CLR.red $msg;
	balloonhelp_for $CLR.grn $msg;
	balloonhelp_for $CLR.blu $msg;

	frame $CLR.whi
	set ::FontExampleColorConfigureWhich bg;
	radiobutton $CLR.whi.t -variable FontExampleColorConfigureWhich \
	    -value fg -command fontsel::RestoreCSColors -text [_ "fg"] \
	    -indicatoron 0 -activebackground gray -selectcolor gray \
	    -font FontControlPanelFont
	radiobutton $CLR.whi.b -variable FontExampleColorConfigureWhich \
	    -value bg -command fontsel::RestoreCSColors -text [_ "bg"] \
	    -indicatoron 0 -activebackground gray -selectcolor gray \
	    -font FontControlPanelFont
	pack $CLR.whi.t -side left -expand 1 -fill both
	pack $CLR.whi.b -side left -expand 1 -fill both

	pack $CLR.rdt -side top -expand 1  -fill both
	pack $CLR.whi -side bottom -expand 1  -fill both
	pack $CLR.red -side left -expand 1 -fill y
	pack $CLR.grn -side left -expand 1 -fill y
	pack $CLR.blu -side left -expand 1 -fill y

	set msg [_ "Choose the color for the sample text."]
	balloonhelp_for $CLR.whi.t $msg;
	set msg [_ "Choose the background color for the sample text."]
	balloonhelp_for $CLR.whi.b $msg;

	#Now grid them all
	set xp 5
	set yp 3
	set CLimit [expr [llength $FontPropertyList] + 2];
	for {set r 0} {$r < 3} {incr r} {
	    for {set c 0} {$c < $CLimit} {incr c} {
		set v $w.curcan.att.r${r}c${c};
		grid $v -row $r -column $c -sticky w -padx $xp -pady $yp
	    } 
	}

	set xp 3
	set yp 1
	if {!$General} {
	    $w.curcan.att.r0c0 configure -text [string totitle [_ $FontInfo($::WhichFontToSet,gloss)]]
	}

	pack $w.curcan.clr -side left -expand 1 -fill both -padx 9 -pady 5
	pack $w.curcan.att -side left -expand 1 -fill both -padx 3 -pady 5

	#Put it all together
	frame $w.botsep -height 4
	pack $w.which -side top -expand 1 -fill x -padx 8 -pady 6
	pack $w.curcan -side top -expand 1 -fill x -padx 8 -pady 6
	pack $w.mid   -side top -expand 1 -fill x -padx 8 -pady 1
	pack $w.cntls -side top -expand 1 -fill x -padx 8 -pady 2
	pack $w.botsep -side top -expand 1 -fill x -padx 8 -pady 2
	if {$General} {
	    $w.which.btns.f[lindex $FontList 0] invoke;#  Default to first on list
	}
	foreach f $FontPropertyList {
	    trace add variable FontInfo($f) write fontsel::FontShow;
	}
	return $w;
    }

    #This resets the properties of the font specified by WhichFontToSet
    #to their default values, where "default" means whatever values
    #are stored in FontInfo(<font>,<property>,Default). The intention
    #is that these values will have been set by RecordDefaults at
    #a suitable point. A suitable point might be program startup or it
    #might be after init files have been read.
    #After resetting the attributes for the current font to their
    #default values, it configures the fonts for both the current and candidate
    #examples in the control panel to match.
    proc ResetToDefaults {} {
	global FontInfo;
	global WhichFontToSet
	variable FontPropertyList

	foreach prop $FontPropertyList {
	    set FontInfo($::WhichFontToSet,$prop) $FontInfo($::WhichFontToSet,$prop,Default);
	    set FontInfo($prop) $FontInfo($::WhichFontToSet,$prop,Default);
	}
	ConfigureFont $::WhichFontToSet;
	ConfigureCurrentExampleFont;
	ConfigureCandidateExampleFont;
	DescribeBothFonts;
    }

    #This is the procedure called from the control panel when the user decides
    #to apply and save the values set on the control panel. It sets the font-specific
    #attributes from the generic ones, configures the target font as well as the
    #current example font, and updates the description of the current font
    #in the control panel.
    proc FontSave {} {
	global FontInfo

	set f $::WhichFontToSet;
	FontSet $f;
	ConfigureFont $f
	ConfigureCurrentExampleFont;
	DescribeBothFonts;
    } 

    #This procedure configures the font used to display the candidate example
    #in the control panel. It is intended to be called whenever a property
    #is changed in the control panel or when the target font is changed.
    proc ConfigureCandidateExampleFont {} {
	global FontInfo
	global WhichFontToSet
	variable FontPropertyList

	foreach prop $FontPropertyList {
	    font configure CandidateFontExampleFont -$prop $FontInfo($prop)
	}
    }

    #This procedure configures the font used to display the current example
    #in the control panel. It is intended to be called when the user
    #applies new values or when the target font is changed.
    proc ConfigureCurrentExampleFont {} {
	global FontInfo
	global WhichFontToSet
	variable FontPropertyList

	foreach prop $FontPropertyList {
	    font configure CurrentFontExampleFont -$prop $FontInfo($::WhichFontToSet,$prop)
	}
    }

    #This procedure configures the candidate example font#and updates the
    #description of the candidate font in the control panel. It is intended
    #to be called whenever a proprty of the candidate font is changed.
    proc FontShow {args} {
	ConfigureCandidateExampleFont;
	DescribeBothFonts;
    }

    #This procedure generates the descriptions of the current and candidate
    #fonts that are shown in the control panel.
    proc DescribeBothFonts {} {
	global FontInfo
	global WhichFontToSet;
	variable FontPropertyList

	set f $::WhichFontToSet;
	set c 2;
	foreach prop $FontPropertyList {
	    .selectFont.curcan.att.r0c$c configure -text  [string totitle [_ $prop]] 
	    set value $FontInfo($f,$prop)
	    if {$value == 1} {set value [_ "Yes"]} else {
		if {$value == 0} {set value [_ "No"]}}
	    .selectFont.curcan.att.r1c$c configure -text $value;
	    set value $FontInfo($prop)
	    if {$value == 1} {set value [_ "Yes"]} else {
		if {$value == 0} {set value [_ "No"]}}
	    .selectFont.curcan.att.r2c$c configure -text $value; 
	    incr c;
	}
    }

#This is to be called when we change font targets.
#It resets the control panel to show the current
#configuration for the newly targeted font.
    proc SetFontSelectionDefaults {} {
	global FontInfo;
	global WhichFontToSet;
	variable FontPropertyList

	foreach prop $FontPropertyList {
	    set FontInfo($prop) $FontInfo($WhichFontToSet,$prop);
	}
	set FontChoices [.selectFont.mid.families.lb size];
	set k 1;
	while {$k <= $FontChoices} {
	    set Family [.selectFont.mid.families.lb get $k];
	    if {[string equal $Family [string tolower $FontInfo($WhichFontToSet,family)]]} {
		.selectFont.mid.families.lb selection clear 0 end;
		.selectFont.mid.families.lb see $k
		.selectFont.mid.families.lb selection set $k $k;
		.selectFont.mid.families.lb activate $k;
		set FontInfo(family) [.selectFont.mid.families.lb get $k]
		break
	    }
	    incr k;
	}
	ConfigureCandidateExampleFont
	ConfigureCurrentExampleFont;
	DescribeBothFonts;
    }

    #This is the callback that extracts a new font family
    #setting from the control panel.
    proc SelectFontFamily {w y} {
	global FontInfo

	set index [$w nearest $y]
	if {$index != ""} {
	    set FontInfo(family) [$w get $index]
	}
    }

    #This is the callback that extracts a new font size
    #from the control panel.
    proc SelectFontSize {w} {
	global WhichFontToSet
	global FontInfo

	set size [$w get]
	if {[catch {expr round($size)} size] == 0} {
	    if { ($size > 0) && ($size <= 60) } {
		set FontInfo(size) $size
		return ;
	    }
	}
	$w delete 0 end
	$w insert 0 $FontInfo($WhichFontToSet,size)
    }

    #This is presently a stub.
    #It is intended to be called on an event, probably <B3>,
    #in the font family listbox in the control panel.
    #Its purpose is to provide the user with information about
    #the particular font. 
    proc ProvideFontDescription {w y} {
	variable FontDescriptions

	set index [$w nearest $y]
	if {$index != ""} {
	    FontDescriptions([$w get $index])
	}
    }

    #Create a command for setting each combination of font and property.
    proc DefineFontSettingProcs {} {
	variable FontPropertyList
	variable FontPropertyClass
	global FontList;
	global FontProcList;

	foreach ft $FontList {
	    foreach prop $fontsel::FontPropertyList {
		if {[string equal $FontPropertyClass($prop) boolean]} {
		    set ProcName  [format "::fontsel::Set%s%sP" $ft [string totitle $prop]];
		    lappend FontProcList $ProcName;
		    set cmd [list "proc"  $ProcName  "\{v\}" \
			 "set ::FontInfo($ft,$prop) \[SlaveBoolean \$v\];\nConfigureFont $ft;"]
		} else {
		    set ProcName  [format "::fontsel::Set%s%s" $ft [string totitle $prop]];
		    lappend FontProcList $ProcName;
		    set cmd [list "proc" $ProcName "\{v\}" \
			 "set ::FontInfo($ft,$prop) \$v;\nConfigureFont $ft;"]
		}
		eval $cmd;
	    }
	}
    }

    #Create aliases in the named daughter interpreter for the font setting commands
    proc AliasFontSettings {interp} {
	variable FontPropertyList
	variable FontPropertyClass
	global FontList;
	
	foreach ft $FontList {
	    foreach prop $FontPropertyList {
		set Tprop [string totitle $prop]
		set Tprop2 $Tprop;
		if {[string equal $FontPropertyClass($prop) boolean]} {
		    set Tprop ${Tprop}P
		}
		eval [split [format "%s alias %s%s ::fontsel::Set%s%s" \
			 $interp $ft $Tprop $ft $Tprop2]]
	    }
	}
    }

    #Returns a list of init file commands representing the current font settings.
    proc SaveFontSettings {} {
	variable FontPropertyList
	variable FontPropertyClass
	global FontInfo
	global FontList;
	
	set cl [list]
	foreach ft $FontList {
	    foreach prop $FontPropertyList {
		set Tprop [string totitle $prop]
		if {[string equal $FontPropertyClass($prop) boolean]} {
		    set Tprop ${Tprop}P
		}
		lappend cl [format "%s%s %s" $ft $Tprop [list $FontInfo($ft,$prop)]]
	    }
	}
	return [lsort $cl];
    }
}

namespace import ::msgcat::mcset;

# End of namespace fontsel

# This is the stuff specific to this program.

set FontList [list MainFont MenuFont BalloonHelpFont PopupTitleFont CharacterEntryFont TextFont \
		  RegexpFont AccentedLetterFont DiacriticFont];

set FontInfo(family) courier
set FontInfo(BalloonHelpFont,family) lucida
set FontInfo(PopupTitleFont,family) "bookman l"
set FontInfo(MainFont,family) courier
set FontInfo(MainFont,weight) bold
set FontInfo(MenuFont,family) courier
set FontInfo(MenuFont,weight) bold
set FontInfo(AccentedLetterFont,family) "code2000"
set FontInfo(CharacterEntryLabelFont,family) bible
set FontInfo(CharacterEntryFont,family) "doulos sil"
set FontInfo(RegexpFont,family)  "doulos sil"

if {$TkEightFivePlusOnX11P} {
    set FontInfo(BalloonHelpFont,size) 10
    set FontInfo(PopupTitleFont,size) 13
    set FontInfo(MainFont,size)  9
    set FontInfo(MenuFont,size)  10
    set FontInfo(AccentedLetterFont,size) 11
    set FontInfo(CharacterEntryLabelFont,size) 10
    set FontInfo(CharacterEntryFont,size) 11
    set FontInfo(RegexpFont,size) 11
    set FontInfo(TextFont,size) 10
    set FontInfo(CharacterEntryFont,size) 11
} else {
    set FontInfo(BalloonHelpFont,size) 13
    set FontInfo(PopupTitleFont,size) 16
    set FontInfo(MainFont,size) 12
    set FontInfo(MenuFont,size) 12
    set FontInfo(AccentedLetterFont,size) 14
    set FontInfo(CharacterEntryLabelFont,size) 13
    set FontInfo(CharacterEntryFont,size) 14
    set FontInfo(RegexpFont,size) 13
    set FontInfo(TextFont,size) 12
    set FontInfo(CharacterEntryFont,size) 14
}

set FontInfo(DiacriticFont,size)  [expr $FontInfo(CharacterEntryFont,size) + 40];

proc SetFontGlossHelpTranslations {} {
    global FontInfo;

    set FontInfo(BalloonHelpFont,gloss) [_ "balloon help"]
    set FontInfo(BalloonHelpFont,help) [_ "This font is used in help balloons."]

    set FontInfo(TextFont,gloss) [_ "text"]
    set FontInfo(TextFont,help) [_ "This font is used in the three text windows."]

    set FontInfo(MainFont,gloss) [_ "general"]
    set FontInfo(MainFont,help) [_ "This font is used for most things."]

    set FontInfo(MenuFont,gloss) [_ "menu"]
    set FontInfo(MenuFont,help) [_ "This font is used for menu labels."]

    set FontInfo(PopupTitleFont,gloss) [_ "popup titles"]
    set FontInfo(PopupTitleFont,help) [_ "This font is used for the titles of popup windows."]

    set FontInfo(RegexpFont,gloss) "regexp" 
    set FontInfo(RegexpFont,help) \
	[_ "This font is used for regular expressions\nand substitution expressions"];

    set FontInfo(CharacterEntryFont,gloss) [_ "character entry"]
    set FontInfo(CharacterEntryFont,help) \
	[_ "This font is used on the labels of\ncharacter insertion widgets."]
    set FontInfo(AccentedLetterFont,gloss) [_ "accented letters"]
    set FontInfo(AccentedLetterFont,help) \
	[_ "This font is used on the labels of the\naccented character insertion widget."]

    set FontInfo(DiacriticFont,gloss) [_ "diacritics"]
    set FontInfo(DiacriticFont,help) \
	[_ "This font is used on the labels of the\ndiacritic insertion widget."]
}

SetFontGlossHelpTranslations;
fontsel::SetFontInfoDefaults;
fontsel::CreateFonts;

option add *selectFont*Font FontControlPanelFont 100
option add *Label.Font MainFont 100
option add *Menu.Font MenuFont 100
option add *Radiobutton.Font MainFont 100
option add *Scale.Font MainFont 100

#This is the history system.
namespace eval hist {
    namespace export AddToHistoryList ClearHistoryList ConstructHistory ParseHistoryEntry;
    namespace export PruneHistoryList SaveHistoryList ShowHistory ToggleHistory;
    namespace export ToggleHistoryProgramDisplay HistoryIsDisplayedP AddToHistoryFile ToggleHistoryMark;
    # 0xFDDF is a codepoint guaranteeed to be unused.
    # The same value must be used as the field separator when history
    # file entries are made in ExecuteRegexp, SaveRegexp, and
    # SaveHistoryList, and when they are parsed by ParseHistoryEntry.
    variable HistoryDelimiter "\uFDDF";
    variable HistoryIsDisplayedP 0;
    variable HistoryIsToBeDisplayedP 0;
    variable HistoryCnt 0;		# The number of entries in the history list
    variable HistoryCntOffset 0;	# The number of entries read from files rather than
    					# executed in the current session.
    variable HistoryMax 10		# The maximum number of history entries
    variable HistoryShowProgP 0;	# Should the history window display the program used?
    variable HistoryRegexps [list];	# Regular expression executed
    variable HistorySubexps [list];	# Substitution expression (may be null)
    variable HistoryMarks [list];	# Flag indicating whether entry is marked
    variable HistoryProgs [list];	# Program in use when regexp was executed

    variable HistoryListIndex 0; #Used by color configuration system.
    variable HistoryListHandle;
    variable EventNumberFieldWidth 4;
    variable ProgramFieldWidth 12;
    variable LocalP 1;
    variable RecordHistoryP 1;

    proc ShowHistory {} {
	pack $::HISTF.hlist -expand 1 -fill both
	wm deiconify .hl;
    }

    proc OpenHistoryFile {} {
	variable RecordHistoryP;
	variable HistoryListHandle;
	variable LocalP;
	if {$LocalP} {
	    set hf $::HistoryFile;
	    if {[catch {open $hf "a"} HistoryListHandle] == 0} {
		return ;
	    } else {
		ShowMessage [format \
			 [_ "Unable to open history file %s for writing in directory %s."]\
			 $hf [pwd]];
		ShowMessage [_ "Using home directory instead."]
	    }
	}
	set hf [file join $::HomeDir $::HistoryFile]
	if {[catch {open $hf "a"} HistoryListHandle] != 0} {
	    ShowMessage [format [_ "Unable to open history file %s for writing."] $hf];
	    ShowMessage [_ "History will not be automatically recorded."];
	    set RecordHistoryP 0;
	}
    }

    proc ParseHistoryEntry {entry} {
	variable HistoryProgs;
	variable HistoryRegexps;
	variable HistorySubexps;
	variable HistoryMarks;
	variable HistoryDelimiter;

	set Fields [split $entry $HistoryDelimiter];
	set FieldCnt [llength $Fields];
	lappend HistoryProgs [string trim  [lindex $Fields 0]];
	lappend HistoryRegexps [lindex $Fields 1];
	if {$FieldCnt > 2} {
	    lappend HistorySubexps [lindex $Fields 2];
	} else {
	    lappend HistorySubexps "";
	}
	lappend HistoryMarks 0;
    }

    #Delete all the entries from the history list
    proc ClearHistoryList {} {
	variable HistoryCnt;
	variable HistoryCntOffset;
	variable HistoryRegexps;
	variable HistorySubexps;
	variable HistoryMarks;
	variable HistoryProgs;
	variable HistoryIsDisplayedP;
	variable ToggleHistoryIndex;
	global m;
	
	set HistoryRegexps [lreplace $HistoryRegexps 0 end];
	set HistorySubexps [lreplace $HistorySubexps 0 end];
	set HistoryMarks   [lreplace $HistoryMarks 0 end];
	set HistoryProgs   [lreplace $HistoryProgs 0 end];
	set HistoryCnt 0;
	set HistoryCntOffset 0;
	if {$HistoryIsDisplayedP} {
	    destroy .hl;
	    set HistoryIsDisplayedP 0;
	    $m.history entryconfigure $ToggleHistoryIndex -label [_ "Popup History List"];
	}
	update;
    }

    #Delete the unmarked entries from the history list
    proc PruneHistoryList {} { 
	variable HistoryCnt;
	variable HistoryCntOffset;
	variable HistoryRegexps;
	variable HistorySubexps;
	variable HistoryMarks;
	variable HistoryProgs;
	variable HistoryIsDisplayedP;
	variable ToggleHistoryIndex;
	global m;

	set MaxIndex [expr $HistoryCnt -1];
	for {set i $MaxIndex} {$i >= 0} {incr i -1} {
	    if {[lindex $HistoryMarks $i] == 0} { #if not marked, delete entry
		set HistoryRegexps [lreplace $HistoryRegexps $i $i];
		set HistorySubexps [lreplace $HistorySubexps $i $i];
		set HistoryMarks [lreplace $HistoryMarks $i $i];
		set HistoryProgs [lreplace $HistoryProgs $i $i];
		incr HistoryCnt -1;
	    } else {#if marked, retain but unset mark
		set HistoryMarks [lreplace $HistoryMarks $i $i 0];
	    }
	}
	set HistoryCntOffset 0;
	if {$HistoryCnt > 0} {
	    ConstructHistory;
	} else {
	    if {$HistoryIsDisplayedP} {
		pack forget $::HISTF.hlist
		pack forget $::HISTF
		pack forget .hl
		destroy .hl;
		set HistoryIsDisplayedP 0;
		$m.history entryconfigure $ToggleHistoryIndex -label [_ "Popup History List"];
	    }
	}
	update;
    }

    proc ReadHistoryFile {FileName} {
	variable HistoryCnt;
	variable HistoryCntOffset;
	variable HistoryMax;
	if {[catch {open $FileName "r"} HistoryHandle] == 0} {
	    while { [gets $HistoryHandle line] > 0} {
		ParseHistoryEntry $line;
		incr HistoryCnt;
		if {$HistoryCnt >= $HistoryMax} { break }
	    }
	    set HistoryCntOffset $HistoryCnt;
	    close $HistoryHandle;
	} else {
	    ShowMessage [format [_ "Failed to open history file %s"] $FileName];
	}
    }

    proc SaveHistoryList {} {
	variable HistoryRegexps;
	variable HistorySubexps;
	variable HistoryProgs;
	variable HistoryCnt;
	variable HistoryDelimiter;
	variable ProgramFieldWidth;
	variable HistoryMax;

	if {$HistoryCnt == 0} {
	    ShowMessage [_ "There is nothing on the history list to save."];
	    return;
	}
	set HistorySaveFile [tk_getSaveFile -initialfile [_ "SavedHistoryList"]];
	if {[ string equal $HistorySaveFile ""] ==1} {
	    ShowMessage [_ "File selection cancelled."]
	    return;
	} else {
	    if { [catch {open $HistorySaveFile "w+"} HistorySaveHandle] != 0} {
		ShowMessage [format [_ "Unable to open file %s to save history."] \
				 [MinimizeFileName $HistorySaveFile]];
		return ;
	    }
	}
	if {$HistoryCnt >= $HistoryMax} {
	    set Limit $HistoryMax
	} else {
	    set Limit $HistoryCnt
	}
	for {set i 0} {$i < $Limit} {incr i} {

	    puts $HistorySaveHandle [format "%*s%s%s%s%s" $ProgramFieldWidth [lindex $HistoryProgs $i] $HistoryDelimiter [lindex $HistoryRegexps $i] $HistoryDelimiter [lindex $HistorySubexps $i]];
	}
	close $HistorySaveHandle;
	ShowMessage [format [_ "History list saved in %s."] [MinimizeFileName $HistorySaveFile]];
    }

    proc ToggleHistoryProgramDisplay {} {
	variable HistoryShowProgP;
	variable HistoryShowProgIndex;
	variable HistoryIsToBeDisplayedP;
	global m;

	if { $HistoryShowProgP == 0} {
	    set HistoryShowProgP 1;
	    $m.history entryconfigure $HistoryShowProgIndex -label [_ "Do Not Show Program"];
	} else {
	    set HistoryShowProgP 0;
	    $m.history entryconfigure $HistoryShowProgIndex -label [_ "Show Program"];
	}
	ConstructHistory;
    }

    proc ToggleHistory {} {
	variable HistoryIsDisplayedP;
	variable HistoryIsToBeDisplayedP;
	variable ToggleHistoryIndex;
	global m;

	if {[winfo exists $::HISTF.hlist] == 0} {
	    if {[ConstructHistory] == 1} {return;}
	}
	if { $HistoryIsDisplayedP == 0} {
	    pack $::HISTF.hlist
	    wm deiconify .hl
	    set HistoryIsDisplayedP 1;
	    set HistoryIsToBeDisplayedP 1;
	    $m.history entryconfigure $ToggleHistoryIndex -label [_ "Hide History"];
	} else {
	    pack forget $::HISTF.hlist
	    wm iconify .hl
	    set HistoryIsDisplayedP 0;
	    set HistoryIsToBeDisplayedP 0;
	    $m.history entryconfigure $ToggleHistoryIndex -label [_ "Popup History"];
	}
    }

    proc HistoryDestroyed {} {
	variable HistoryIsDisplayedP;
	variable HistoryIsToBeDisplayedP;
	variable ToggleHistoryIndex;
	global m;

	set HistoryIsDisplayedP 0;
	set HistoryIsToBeDisplayedP 0;
	$m.history entryconfigure $ToggleHistoryIndex -label [_ "Popup History List"];
    }

    proc AddToHistoryList {re se pr} {
	variable HistoryCnt;
	variable HistoryRegexps;
	variable HistoryMarks;
	variable HistoryProgs;
	variable HistorySubexps;

	incr HistoryCnt;
	lappend HistoryRegexps $re;
	lappend HistoryMarks 0;
	lappend HistoryProgs $pr;
	lappend HistorySubexps $se;
    }

    proc AddToHistoryFile {re se pr} {
	variable HistoryDelimiter;
	variable HistoryListHandle;
	variable ProgramFieldWidth;
	variable RecordHistoryP;

	if {$RecordHistoryP} {
	    puts $HistoryListHandle \
		[format "%*s%s%s%s%s" \
	     $ProgramFieldWidth $pr $HistoryDelimiter $re $HistoryDelimiter $se];
	}
    }

    #Extract the event number from a history entry and convert it into the real
    #index into the history list.
    #We have to strip leading zeroes (including those following a negative sign)
    #so that Tcl won't think that the string represents an octal number.
    proc HistoryEntryToIndex {EntryLine} {
	variable HistoryCntOffset;

	set RawIndexString [string range $EntryLine 0 [string first " " $EntryLine]];
	if {[string match  "-*" $RawIndexString]} {
	    set StrippedString [string trimleft [string range $RawIndexString 1 end] "0"];
	    if {[string equal $StrippedString ""]} {set StrippedString 0}
	    set OffsetIndex [expr 0 - $StrippedString];
	} else {
	    set StrippedString [string trimleft $RawIndexString "0"];
	    if {[string equal $StrippedString ""]} {
		set OffsetIndex 0;
	    } else {
		set OffsetIndex $StrippedString;
	    }
	}
	return [expr $OffsetIndex + $HistoryCntOffset -1];
    }

    #Toggles the marked status of the active entry in the history list.
    proc ToggleHistoryMark {} {
	variable HistoryCnt;
	variable HistoryMarks;

	set RHIndex [HistoryEntryToIndex [$::HISTF.hlist get active]];
	if { [lindex $HistoryMarks $RHIndex] == 1} {
	    set HistoryMarks [lreplace $HistoryMarks $RHIndex $RHIndex 0];
	    $::HISTF.hlist itemconfigure [expr $HistoryCnt - $RHIndex -1] -foreground \#00000000ffff; #blue
	} else {
	    set HistoryMarks [lreplace $HistoryMarks $RHIndex $RHIndex 1];
	    $::HISTF.hlist itemconfigure [expr $HistoryCnt - $RHIndex -1] -foreground \#ffff11111111; #red
	}
    }

    # Insert the regexp and subexp of the active history list entry.
    proc InsertHistoryEntry {} {
	variable HistoryRegexps;
	variable HistorySubexps;

	set hi [HistoryEntryToIndex [$::HISTF.hlist get active]];
	$::REG  insert insert [lindex $HistoryRegexps $hi];
	$::SUB insert insert [lindex $HistorySubexps $hi];
    }

    # Return 0 if created, 1 if not created (due to empty history list).
    proc ConstructHistory {} {
	global ColorSpecs;
	global UseScrollbarsP;
	variable ProgramFieldWidth;
	variable EventNumberFieldWidth;
	variable ProgramFieldWidth;
	variable HistoryRegexps;
	variable HistorySubexps;
	variable HistoryMarks;
	variable HistoryProgs;
	variable HistoryCnt;
	variable HistoryCntOffset;
	variable HistoryIsDisplayedP;
	variable HistoryIsToBeDisplayedP;
	variable HistoryShowProgP;

	pack forget $::HISTF.sbar;
	if {$HistoryCnt == 0} {
	    ShowMessage [_ "There is nothing on the history list."];
	    return 1;
	}
	if {[winfo exists .hl] == 0} {toplevel .hl}
	wm withdraw .hl
	if {[winfo exists $::HISTF] == 0} {frame $::HISTF}
	pack $::HISTF -expand 1 -fill both
	if {[winfo exists $::HISTF.hlist] == 0} {
	    set Height 12
	    listbox $::HISTF.hlist -height $Height -width 0 -font RegexpFont \
		-fg $ColorSpecs(HistoryList,Foreground) \
		-bg $ColorSpecs(HistoryList,Background) -yscrollcommand {$::HISTF.sbar set}
	    scrollbar $::HISTF.sbar -command {$::HISTF.hlist yview} \
		-trough $::ColorSpecs(HistoryList,Background);
	    bind $::HISTF.sbar <<B3>> "ScrollbarMoveBigIncrement $::HISTF.sbar 0.20 %x %y"
	} else {$::HISTF.hlist delete 0 end}
	for {set i [expr $HistoryCnt -1]} {$i >= 0} {incr i -1} {
	    set UserIndex [expr $i - $HistoryCntOffset +1];
	    if {$HistoryShowProgP} {
		$::HISTF.hlist insert end [format "%0*d %-*s  %s  %s" $EventNumberFieldWidth \
			  $UserIndex $ProgramFieldWidth [lindex $HistoryProgs $i] \
			  [lindex $HistoryRegexps $i] [lindex $HistorySubexps $i]];
	    } else {
		$::HISTF.hlist insert end [format "%0*d  %s  %s" $EventNumberFieldWidth $UserIndex \
			  [lindex $HistoryRegexps $i] [lindex $HistorySubexps $i]];
	    }
	    if {[lindex $HistoryMarks $i] == 1} {
		$::HISTF.hlist itemconfigure [expr $HistoryCnt - $i -1]  -foreground \#ffff11111111; #red
	    }
	}
	BindKeys .hl;
	bind $::HISTF.hlist <Button-1> {+
	    hist::ToggleHistoryMark;
	}
	bind $::HISTF.hlist <<B3>> {	
	    hist::InsertHistoryEntry;
	}
	bind $::HISTF.hlist <Destroy> {
	    hist::HistoryDestroyed;
	}
	balloonhelp_for $::HISTF.hlist  \
	    [_ "Left click to select and toggle mark.\nRight click to insert into regular expression."];
	if {$HistoryIsToBeDisplayedP} {
	    ShowHistory
	}
	return 0;
    }
}

#Check whether the PCRE regexp extension to PHP is available on this system
proc PHPPCREAvailable {} {
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open %s."] $CommandFile];
	return -2;
    }
    puts $CommandHandle "<?php if (preg_match('t', 't')){\n\t\tprintf('Success\\n');\n}?>";
    close $CommandHandle;
    if { [catch {set result [exec php -f $CommandFile]}] != 0} {
	return 0;
    }
    if { [string length $result]  > 0 } {
	return 1;
    }
    return 0;
}

#Check whether the multibyte extension to PHP is available on this system

proc PHPMBAvailable {} {
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open %s."] $CommandFile];
	return -2;
    }
    puts $CommandHandle "<?php mb_regex_encoding('UTF-8';\nif (mb_ereg('t', 't')){\n\t\tprintf('Success\\n');\n}?>";
    close $CommandHandle;
    if { [catch {set result [exec php -f $CommandFile]}] != 0} {
	return 0;
    }
    if { [string length $result]  > 0 } {
	return 1;
    }
    return 0;
}

# tk_exec is like exec but allows updates while the child process is running.
proc tk_exec_fileevent {id} {
    global tk_exec_data
    global tk_exec_cond
    global tk_exec_pipe

    if {[eof $tk_exec_pipe($id)]} {
	fileevent $tk_exec_pipe($id) readable ""
	set tk_exec_cond($id) 1
	return
    }
    append tk_exec_data($id) [read $tk_exec_pipe($id) 1024]
  }

  proc tk_exec {args} {
      global tk_exec_id
      global tk_exec_data
      global tk_exec_cond
      global tk_exec_pipe

      if {![info exists tk_exec_id]} {
	  set tk_exec_id 0
      } else {
	  incr tk_exec_id
      }
      set keepnewline 0

      for {set i 0} {$i < [llength $args]} {incr i} {
	  set arg [lindex $args $i]
	  switch -glob -- $arg {
	      -keepnewline {
		  set keepnewline 1
	      }
	      -- {
		  incr i
		  break
	      }
	      -* {
		  error "unknown option: $arg"
	      }
	      ?* {
		  break
	      }
	  }
      }
      if {$i > 0} {
	  set args [lrange $args $i end]
      }
      set pipe [open "|$args" r]
      set tk_exec_pipe($tk_exec_id) $pipe
      set tk_exec_data($tk_exec_id) ""
      set tk_exec_cond($tk_exec_id) 0
      set tk_exec_pipe(pid) [lindex [pid $pipe] 0]

      fconfigure $pipe -blocking 0
      fileevent $pipe readable "tk_exec_fileevent $tk_exec_id"
      vwait tk_exec_cond($tk_exec_id)
      if {$keepnewline} {
	  set data $tk_exec_data($tk_exec_id)
      } else {
	  set data [string trimright $tk_exec_data($tk_exec_id) \n]
      }

      unset tk_exec_pipe($tk_exec_id)
      unset tk_exec_data($tk_exec_id)
      unset tk_exec_cond($tk_exec_id)

      if {[catch {close $pipe} err]} {
	  error "pipe error: $err"
      }
      return $data
  }

proc CheckProgramAvailability {} {
    #If we're running, tcl is obviously available.
    set ::ProgramInfo(tcl,AvailableP) 1;
    set ::ProgramInfo(tclglob,AvailableP) 1;

    foreach prog $::ProgList {
	if {!([expr [string equal $prog "tcl"] || \
	       [string equal $prog "tclglob"]])} {
	    if {[string length [auto_execok $::ExecName($prog)]] == 0} {
		set ::ProgramInfo($prog,AvailableP) 0;
	    } else {
		set ::ProgramInfo($prog,AvailableP) 1;
	    }
	}
    }
    #Maybe add check for file patmatch.pl too?
    if {[string length [auto_execok nrgrep_coords]] == 0} {
	set ::ProgramInfo(patmatch,AvailableP) 0;
    }
    if {$::ProgramInfo(sleep,AvailableP)} {
	set ::ProgramInfo(sleepwc,AvailableP) 1;
    }
    if {$::ProgramInfo(php,AvailableP)} {
	set ::ProgramInfo(php-posix,AvailableP) 1;
	set ::ProgramInfo(php-mb,AvailableP) [PHPMBAvailable];
	set ::ProgramInfo(php-pcre,AvailableP) [PHPPCREAvailable];
    } else {
	set ::ProgramInfo(php-posix,AvailableP) 0;
	set ::ProgramInfo(php-mb,AvailableP) 0;
	set ::ProgramInfo(php-pcre,AvailableP) 0;
    }
    if {$::ProgramInfo(arena,AvailableP)} {
	if {![CheckRegexpAvailabilityArena]} {
	    set ::ProgramInfo(arena,AvailableP) 0;
	    ShowMessage [_ "Arena was not built with regular expression support."]
	}
    }
}

proc MarkProgramAvailability {} {
    set index 0;
    foreach prog $::DetailedProgList {
	    incr index;
	if {!$::ProgramInfo($prog,AvailableP)} {
	    .menubar.program entryconfigure $index -state disabled
	} else {
	    .menubar.program entryconfigure $index -state normal
	}
    }
}

#Sets the color of program menu buttons to show whether the program has been
#tested in the current locale.
proc MarkProgramTested {} {
    set index 0;
    foreach prog $::DetailedProgList {
	incr index;
	if {[FeaturesUnSetP $prog $::InterfaceLocale]} {
	    .menubar.program entryconfigure $index \
		-foreground $::ColorSpecs(Menu,Foreground)
	    .menubar.program entryconfigure $index \
		-background $::ColorSpecs(Menu,Background)
	} else {
	    .menubar.program entryconfigure $index \
		-foreground $::ColorSpecs(ProgramMenu,TestedForeground)
	    .menubar.program entryconfigure $index \
		-background $::ColorSpecs(ProgramMenu,TestedBackground)
	}
    }
}

proc SelectProgram {prog} {
    global Program;
    global program;
    global m;
    global PHPMB;
    global PHPPCRE;
    global ButtonName;
    global ExecName;
    global Features;
    global InterfaceLocale;
    global LeftImplicitStar;
    global RightImplicitStar;
    global FeatureTestDebugP;
    
    ClearMessageWindow;
    if {$::TestingFeaturesP} {
	ShowMessage \
	    [_ "Please wait until the current feature test is completed."]
	return 0
    }
    set ::PreviousProgram $program;
    set ActualProgram $prog;
    if {[string range $prog 0 3] == "php-"} {
	set ActualProgram "php";
    }
    set Prog [format "%s%s" \
	  [string toupper [string range $ActualProgram 0 0]] \
	  [string range $ActualProgram 1 end]];

    #If we're running, tcl is obviously available.
    if {![expr [string equal $ActualProgram "tcl"] || [string equal $ActualProgram "tclglob"]]} {
	if {![info exists ExecName($ActualProgram)]} {
	    ShowMessage [format [_ "Redet does not support the program %s."] $ActualProgram]
	    return 0;
	}
	if { [string length [auto_execok $ExecName($ActualProgram)]]  == 0 } {
	    ShowMessage [format [_ "%s is not available on this machine or not in your path."] $Prog];
	    return 0;
	}
    }
    set ::ProgramInfo($ActualProgram,version) [GetVersion $ActualProgram];

    set PHPMB 0;
    set PHPPCRE 0;
    if { $ActualProgram == "php" } {
	set suffix [string range $prog 4 end];
	if { $suffix == "mb"} {
	    if {[PHPMBAvailable] == 0} {
		set PHPMB 1;
	    } else {
		ShowMessage [_ "The multibyte extension to PHP is not available."];
		return 0;
	    }
	}
	if { $suffix == "pcre"} {
	    if {[PHPPCREAvailable] == 0} {
		set PHPPCRE 1;
	    } else {
		ShowMessage [_ "The PCRE extension to PHP is not available."];
		return 0;
	    }
	}
    }
    if {[string equal $ActualProgram sed]} {
	WhichSed;
	ShowMessage [format "Identified sed as %s" $::ProgramInfo(sed,Which)]
    }
    set program $ActualProgram;
    set Program $Prog;
    set ButtonName [format "%s%s" [string toupper [string range $prog 0 0]] [string range $prog 1 end]];
    if { [FeaturesUnSetP $program $InterfaceLocale] } {
	TestFeatures
	RefreshProginfo;
    }
    if {$FeatureTestDebugP} {
	puts "Program is now $program";
	puts "Size of Features array [array size Features]";
    }
    ConstructPalette;
    if { [FeaturesUnSetP $program $InterfaceLocale] == 0} {
	if {$Features(embedding,$program,$InterfaceLocale) || \
		 $Features(embeddingLeft,$program,$InterfaceLocale) || \
		$Features(EmbeddingMatchOnly,$program,$InterfaceLocale)} {
	    set LeftImplicitStar "*";
	} else {
	    set LeftImplicitStar "^";
	}
	if {$Features(embedding,$program,$InterfaceLocale) || \
		$Features(embeddingRight,$program,$InterfaceLocale) || \
		$Features(EmbeddingMatchOnly,$program,$InterfaceLocale)} {
	    set RightImplicitStar "*";
	} else {
	    set RightImplicitStar "$";
	}
	set ExecLabel [format [_ "Execute-%s%s%s"] $LeftImplicitStar $ButtonName $RightImplicitStar]
    } else {
	set ExecLabel [format [_ "Execute-%s"]  $ButtonName];
    }

    if {$::AquaP} {
	.cmnds.execute configure -text $ExecLabel;
    } else {
	$m entryconfigure 2 -label $ExecLabel;
    }
    UpdateProgramControlPanel;
    CheckUserClassAvailability;
    CheckModeCompatibility;
    return 1;
}

proc CheckUserClassAvailability {} {
    if {[info exists ::Features(alttype,$::program,$::InterfaceLocale)]} {
	if {$::UserClassCnt > 0 && ($::Features(alttype,$::program,$::InterfaceLocale) == 0)} {
	    PopupAlert "UserClass" [format [_ "Warning: named character classes are defined\nbut %s does not support them."] $::program];
	    ShowMessage [format [_ "Warning: named character classes are defined\nbut %s does not support them."] $::program];
	}
    }
}

proc CheckModeCompatibility {} {
    if {($::DoSubstitutionsP == 1) && ([info exists ::ExecCmd($::program,sub)] ==0) } {
	PopupAlert "Sub" [format \
	      [_ "Warning: redet is in substitution mode\nbut %s does not support substitution."] $::program];
	ShowMessage [format \
		 [_ "Warning: redet is in substitution mode but %s does not support substitution."] $::program];
	return 0;
    }
    if {($::DoSubstitutionsP == 0) && ([info exists ::ExecCmd($::program,match)] ==0) } {
	PopupAlert "Sub" [format \
	      [_ "Warning: redet is in match mode\nbut %s does not support matching."] $::program];
	ShowMessage [format \
	 [_ "Warning: redet is in match mode but %s does not support matching."] $::program];
	return 0;
    }
    return 1;
}

proc YViewBothPalette {args} {
    set ac [llength $args];
    set a  [lindex $args 0]
    set b  [lindex $args 1]
    if {$ac == 3} {
	set c  [lindex $args 2]
	$::PALF.lba yview $a $b $c;
	$::PALF.lbb yview $a $b $c;
    } else {
	$::PALF.lba yview $a $b;
	$::PALF.lbb yview $a $b;
    }
}


proc DefineUserEtextProc {name etext} {
    set procname Explain$name
    set etext [lindex $etext 0]
    eval [list "proc" $procname \
	      \
	      "" \
    "global HPWidth;
    global HPLines;
    global PopupList;
    if \{\[PopupDown $name\] ==1\} \{return\}
    set po \[CreateTextDisplay \"$name\" \$HPWidth \$HPLines\]
    BindKeys \$po;
    set PopupList($name) \$po;
    AppendToTextDisplay \$po \"$etext\""]
}

proc ConstructPalette {} {
    global Palette;
    global Program;
    global program;
    global InterfaceLocale;
    global Features;
    global PropertyList
    global PropertyUse
    global PaletteIsDisplayedP;
    global PaletteToBeDisplayedP;
    global PaletteFeatures;
    global UserPalette;
    global ButtonName;
    global FeatureTestP;
    global ColorSpecs;
    global linkNum;

    destroy $::PALF.lba;
    destroy $::PALF.lbb;
    destroy $::PALF.sbar;
    set PaletteIsDisplayedP 0;

    #See if we have a record of palette features for this program.
    if { [FeaturesUnSetP $program $InterfaceLocale] } {
	ShowMessage [_ "No feature list is available for this program and locale."]
	if {$FeatureTestP == 0} {
	    ShowMessage [_ "Feature testing is disabled."]
	}
	return;
    }
    #See if this program supports any palette features.
    set fcnt 0;
    foreach x $PropertyList {
	if {$PropertyUse($x,PaletteP)} {
	    set fcnt [expr $Features($x,$program,$InterfaceLocale) + $fcnt];
	}
    }
    set PaletteFeatures [expr $fcnt + $UserPalette($program,0)];
    if {$PaletteFeatures == 0} {
	destroy .pal;
	return
    }
    if {[winfo exists .pal] == 0} {toplevel .pal} 
    if {[winfo exists $::PALF] == 0} {frame $::PALF} 
    if {[string equal $program agrep]} {
	if {$::ProgramInfo(agrep,TreAgrepP) == 1} {
	    set which "TRE Agrep"
	} elseif {$::ProgramInfo(agrep,TreAgrepP) == 0} {
	    set which "Wu-Manber Agrep"
	} else {
	    set which "Agrep";
	}
	set TitleName $which
    } else {
	set TitleName $ButtonName
    }
    wm title .pal [format [_ "Regular Expression Palette for %s"] $TitleName];
    wm withdraw .pal;

    if {$PaletteFeatures < $::PaletteHeightLimit} {
	set ht $PaletteFeatures;
    } else {
	set ht $::PaletteHeightLimit;
    }					
    text $::PALF.lba -bd 0 -relief flat \
	-bg $ColorSpecs(PaletteGloss,Background) -fg $ColorSpecs(PaletteGloss,Foreground) \
	-font MainFont 	-yscrollcommand {$::PALF.sbar set} -width 62 -height $ht
    text  $::PALF.lbb -bd 0 -relief flat \
	-bg $ColorSpecs(PaletteNotation,Background) -fg $ColorSpecs(PaletteNotation,Foreground) \
	-font MainFont -yscrollcommand {$::PALF.sbar set} -width 28 -height $ht

    scrollbar $::PALF.sbar -command {YViewBothPalette} \
	-troughcolor $::ColorSpecs(PaletteNotation,Background) \
	-bg $::ColorSpecs(PaletteNotation,Background) \
	-activebackground $::ColorSpecs(PaletteScrollbarSlider,Highlight)

    grid rowconfigure $::PALF 0 -weight 1;
    grid columnconfigure $::PALF {0 1} -weight 1;
    grid columnconfigure $::PALF 2 -weight 0;
    grid configure $::PALF.lba $::PALF.lbb -sticky nsew;
    if {$::UseScrollbarsP} {
	grid configure $::PALF.sbar -row 0 -column 2 -sticky ns;
    }
    pack $::PALF -expand 1 -fill both;

    bind $::PALF.sbar <<B3>> "ScrollbarMoveBigIncrement $::PALF.sbar 0.25 %x %y"
    bind $::PALF.lba <Motion>  {$::PALF.lbb yview moveto [lindex [$::PALF.lba yview] 0]}
    bind $::PALF.lbb <Motion>  {$::PALF.lba yview moveto [lindex [$::PALF.lbb yview] 0]}

    bind $::PALF.lba <Button-1> {+
	$::PALF.lbb yview moveto [lindex [$::PALF.lba yview] 0];
	set ::PaletteLineNumber [lindex [split [$::PALF.lba index @%x,%y] "."] 0]
	MarkPaletteSelection;
    }
    bind $::PALF.lbb <Button-1> {+
	$::PALF.lba yview moveto [lindex [$::PALF.lbb yview] 0];
	set ::PaletteLineNumber [lindex [split [$::PALF.lbb index @%x,%y] "."] 0]
	MarkPaletteSelection;
    }
    bind $::PALF.lbb <<B3>> {InsertPaletteEntry}
    bind $::PALF.lbb <Double-Button-1> {UndoPaletteEntry;break}
    bind $::PALF.lba <Destroy> {
	destroy $::PALF.lbb;
	set PaletteIsDisplayedP 0;
	ClearPaletteUndoStacks;
    }
    bind $::PALF.lbb <Destroy> {
	destroy $::PALF.lba;
	set PaletteIsDisplayedP 0;
    }
    BindKeys .pal;
    foreach test $PropertyList {
	if {$PropertyUse($test,PaletteP)} {
	    if { $Features($test,$program,$InterfaceLocale) == 1} {
		if {![info exists Palette($test,gloss)]} {
		    continue ;
		}
		set gloss $Palette($test,gloss);
		set re   $Palette($test,re);
		if {[info exist Palette($test,link)]} {
		    set LinkCode [list ShowInfo $::Palette($test,link)]
		    set tag "link[incr linkNum]"
		    $::PALF.lba insert end [format " %s\n" $gloss] [list body $tag]
		    $::PALF.lba tag bind $tag <Enter> \
			"$::PALF.lba tag configure $tag -background $::ColorSpecs(PaletteHighlight,Background);\
		    $::PALF.lba tag configure $tag -foreground $::ColorSpecs(PaletteHighlight,Foreground)"
		    $::PALF.lba tag bind $tag <Leave> \
			"$::PALF.lba tag configure $tag -background $::ColorSpecs(PaletteGloss,Background);\
		    $::PALF.lba tag configure $tag -foreground $::ColorSpecs(PaletteGloss,Foreground)"
		    $::PALF.lba tag bind $tag <<B3>> \
			"$LinkCode"
		} else {
		    $::PALF.lba insert end [format " %s\n" $gloss]
		}
		$::PALF.lbb insert end "\040"
		foreach x $re {
		    $::PALF.lbb insert end [lindex $x 0] [list [lindex $x 1]]
		}
		$::PALF.lbb insert end "\n"
	    }
	}
    }
    if {$UserPalette($program,0) > 0} {
	$::PALF.lba insert end "______________________________________________________________\n"
	$::PALF.lbb insert end "____________________________\n"
    }
    foreach pe [array names ::UserPalette] {
	set pel [split $pe ","]
	set WhichProgram [lindex $pel 0];
	if {![string equal $WhichProgram $program]} {continue}
	set f [lindex $pel 1]; 
	if {[string equal $f 0]} {continue}
	DefineUserEtextProc $f [lindex $UserPalette($WhichProgram,$f) 1]
	set Body [lindex $UserPalette($WhichProgram,$f) 0]
	set LinkCode [list ShowInfo $f]
	set tag "link[incr linkNum]"
	$::PALF.lba insert end " $f\n" [list body $tag]
	$::PALF.lba tag bind $tag <Enter> "$::PALF.lba tag configure $tag -background $::ColorSpecs(PaletteHighlight,Background);\
		    $::PALF.lba tag configure $tag -foreground $::ColorSpecs(PaletteHighlight,Foreground)"
	$::PALF.lba tag bind $tag <Leave> \
		"$::PALF.lba tag configure $tag -background $::ColorSpecs(PaletteGloss,Background);\
		    $::PALF.lba tag configure $tag -foreground $::ColorSpecs(PaletteGloss,Foreground)"
	$::PALF.lba tag bind $tag <<B3>> \
		"$LinkCode"
    	$::PALF.lbb insert end " ";# This keeps the space from being within the tag.
	$::PALF.lbb insert end  $Body [list F]
	$::PALF.lbb insert end "\n"
    }
    $::PALF.lbb tag configure F -background $::ColorSpecs(Palette,Fixed)
    $::PALF.lbb tag configure V -background $::ColorSpecs(Palette,Variable)
    $::PALF.lba configure -state disabled
    $::PALF.lbb configure -state disabled
    balloonhelp_for $::PALF.lba  \
	[_ "Left click to select. Right click for further information."]
    balloonhelp_for $::PALF.lbb  \
	[_ "Left click to select. Right click to insert into regular expression.\n\Double left click to undo the insertion.\n"]
    set ::PaletteLineNumber 1;
    if {$PaletteToBeDisplayedP} {
	ShowPalette;
    }
}

proc WritePaletteToFile {} {
    global Program
    global program
    global InterfaceLocale
    global Features
    global PropertyList
    global FeatureTestP;
    global PropertyUse
    global UserPalette
    global Palette

    #See if we have a record of palette features for this program.
    if { [FeaturesUnSetP $program $InterfaceLocale] } {
	ShowMessage [_ "No feature list is available for this program and locale."]
	if {$FeatureTestP == 0} {
	    ShowMessage [_ "Feature testing is disabled."]
	}
	return;
    }
    #See if this program supports any palette features.
    set fcnt 0;
    foreach x $::PropertyList {
	if {$::PropertyUse($x,PaletteP)} {
	    set fcnt [expr $Features($x,$program,$InterfaceLocale) + $fcnt];
	}
    }
    set PaletteFeatures [expr $fcnt + $::UserPalette($program,0)];
    if {$PaletteFeatures == 0} {
	ShowMessage [_ "This program does not support any palette features."]
	return
    }

    #Open file
    set PaletteInfoSaveFile [tk_getSaveFile -initialfile \
			      [format [_ "%sPalette"] $Program]]
    if {[ string equal $PaletteInfoSaveFile ""]} {
	ShowMessage [_ "File selection cancelled."]
	return ;
    } else {
	if { [catch {open $PaletteInfoSaveFile "w+"} PaletteInfoSaveHandle]} {
	    ShowMessage [format \
		     [_ "Unable to open file %s in which to save palette information"] \
			     [MinimizeFileName $PaletteInfoSaveFile]];
	    return ;
	}
    }

    #Identify the precise program we are dealing with
    if {[string equal $Program agrep]} {
	if {$::ProgramInfo(agrep,TreAgrepP) == 1} {
	    set which "TRE Agrep"
	} elseif {$::ProgramInfo(agrep,TreAgrepP) == 0} {
	    set which "Wu-Manber Agrep"
	} else {
	    set which "Agrep";
	}
	set TitleName $which
    } else {
	set TitleName $::ButtonName
    }
    
    #Write out header
    puts $PaletteInfoSaveHandle [format \
	     [_ "Regular Expression Palette for %s in InterfaceLocale %s."] \
	     $TitleName $InterfaceLocale];
    puts $PaletteInfoSaveHandle [format \
	     [_ "Program version: %s"] $::ProgramInfo($::program,version)];
    puts $PaletteInfoSaveHandle [format \
	     [_ "Generated %s by Redet %s.\n\n"] [clock format [clock seconds]] $::Version];

    #Write out the internal palette
    foreach test $PropertyList {
	if {$PropertyUse($test,PaletteP)} {
	    if { $Features($test,$program,$InterfaceLocale) == 1} {
		if {![info exists Palette($test,gloss)]} {
		    continue ;
		}
		set gloss $Palette($test,gloss);
		set re [StripTclQuotes [StripTags $Palette($test,re)]];
		puts $PaletteInfoSaveHandle [format "%-50s\t%s" $gloss $re]
	    }
	}
    }
    #Write out the user palette
    if {$UserPalette($program,0) > 0} {
	puts $PaletteInfoSaveHandle "\#User-defined palette entries"
    }
    foreach x [array names UserPalette] {
	set el [split $x ","];
	set prg [lindex $el 0]; 
	if {![string equal $prg $program]} {continue}
	set en  [lindex $el 1]; 
	if {$en == 0} {continue}
 	puts $PaletteInfoSaveHandle \
 	    [format "%-50s\t%s\n" $en \
		 [StripTclQuotes [StripTags [lindex $::UserPalette($program,$en) 0]]]]
    }
     #Clean up
     close $PaletteInfoSaveHandle;
    ShowMessage [format [_ "Palette saved in file %s."] [MinimizeFileName $PaletteInfoSaveFile]]
} 

proc StripTags {s} {
    return [regsub -all "(^\{)|(\[\u0020\u0009\]\{)| \[FV\]\}" $s ""]
}

proc StripTclQuotes {s} {
    return [regsub -all "\\\\" [regsub -all "\\\]" [regsub -all "\\\[" [regsub -all "\\\}" \
	    [regsub -all "\\\{" $s \{] "\}"] "\["] "\]"] "\\"]
}


 proc MarkPaletteSelection {} {
     $::PALF.lba tag delete Selected
     $::PALF.lbb tag delete Selected
     $::PALF.lba tag add Selected $::PaletteLineNumber.0 $::PaletteLineNumber.end
     $::PALF.lbb tag add Selected $::PaletteLineNumber.0 $::PaletteLineNumber.end
     $::PALF.lba tag configure Selected -underline 1
     $::PALF.lbb tag configure Selected -underline 1
 }

 array set PStack {}
 set PStack($REG) [list]
 set PStack($SUB) [list]

 proc ClearPaletteUndoStacks {} {
     set ::PStack($::REG) [list]
     set ::PStack($::SUB) [list]
 }

 proc InsertPaletteEntry {} {
     set w $::InsertionTarget;
     set str [string trimleft [$::PALF.lbb get $::PaletteLineNumber.0 $::PaletteLineNumber.end]]
     if {[string equal $w $::SUB] == 0}  {
 	set w $::REG;
     }
     #Push the length of the entry on the stack
     lappend ::PStack($w) [string length $str];
     $w insert insert $str;
 }

 proc UndoPaletteEntry {} {
     set w $::InsertionTarget;
     if {[string equal $w $::SUB] == 0}  {
 	set w $::REG;
     }
     #Pop the stack
     set l $::PStack($w)
     set Last [expr [llength $l] -1];
     if {$Last < 0} {
 	ShowMessage [_ "Nothing remains to delete."]
 	return ;
     }
     set CharsToDelete [lindex $l $Last];
     set ::PStack($w) [lreplace $l $Last $Last];
     #Compute the range to delete and delete it.
     set ins [$w index insert]
     set FirstToDelete [expr $ins - $CharsToDelete]
     $w delete $FirstToDelete $ins;
 }

 proc ShowInfo {TopicList} {
     foreach k $TopicList { 
 	Explain$k
     }
 }

 proc WriteJournal {msg} {
     global JournalHandle;
     puts $JournalHandle $msg;
 }

 proc FlushJournal {} {
     global JournalHandle;
     flush $JournalHandle;
 }

 proc ShowMessage {msg} {
     if {[winfo exists .msg]} {
 	.msg configure -state normal;
 	.msg delete 1.0 end;
 	.msg insert 1.0 $msg;
 	.msg configure -state disabled;
     } else {
 	puts $msg;
     }
     WriteJournal $msg;
 }

 proc ClearMessageWindow {} {
      .msg configure -state normal
      .msg delete 1.0 end;
      .msg configure -state disabled
}

#Write data to temporary test file
proc WriteTestData {tdata} {
    global TestFile;

    if {[catch {open $TestFile "w"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to open %s."] $TestFile];
	return ;
    }
    puts -nonewline $TempDataHandle $tdata;
    close $TempDataHandle; 
}

# Check whether we already have tested this combination of
# program and locale. 
proc FeaturesUnSetP {pro loc} {
    global Features;
    if { [info exists Features(tested,$pro,$loc)] } {
	if {$Features(tested,$pro,$loc)} {
	    return 0;
	} else {
	    return 1;
	}
    }
    return 1;
}

proc DumpFeatures {pro loc} {
    global Features;

    set fn [format [_ "FeatureList-%s-%s"]  $pro $loc] ;
    set FeatureSaveFile [tk_getSaveFile -initialfile $fn];
    if {[string equal $FeatureSaveFile ""] == 1} {
	return ;
    } else {
        if { [catch {open $FeatureSaveFile "w+"} FeatureSaveHandle] != 0} {
	    ShowMessage [format [_ "Unable to open file %s in which to save features."] \
			     [MinimizeFileName $FeatureSaveFile]];
	    return ;
        }
    }
    set TF [list "F" "T"];
    puts $FeatureSaveHandle [format "Prorgram %s %s in locale %s using Redet %s\nunder %s %s"\
	 $pro $::ProgramInfo($::program,version) \
	 $loc $::Version [OSName] [clock format [clock seconds]]];
    # Extract just the entries for the current program and locale.
    # En passant we convert 0s and 1s to Fs and Ts.
    foreach idx [array names Features] {
	set triple [split $idx ","]
	if { [string equal [lindex $triple 1] $pro] } {
	    if { [string equal [lindex $triple 2]  $loc] } {
		set cd([lindex $triple 0]) [lindex $TF $Features($idx)];
	    }
	}
    }    
    # Now we write out the feature-value pairs in the order of PropertyList;
    foreach test $::PropertyList {
	if {[info exists cd($test)]} {
	    puts $FeatureSaveHandle [format "\t%-15s  %1s" $test $cd($test)];
	}
    }
    close $FeatureSaveHandle;
}

proc ShowTestProgress {cnt StartTime FeatureCnt} {
    if {[expr $cnt % 5] == 0} {
	if {[winfo exists .placard]} {
	    set TimeElapsed [expr [clock seconds] - $StartTime];
	    set TotalTime [expr double($TimeElapsed) * (double($FeatureCnt)/double($cnt))];
	    set TimeRemaining [expr $TotalTime - $TimeElapsed];
	    set RoundedTimeRemaining [expr round($TimeRemaining)];
	    set RoundedTotalTime [expr round($TotalTime)];
	    set ElapsedMinutes [expr $TimeElapsed / 60]
	    set ElapsedSeconds [expr $TimeElapsed % 60]
	    set TotalMinutes [expr $RoundedTotalTime / 60]
	    set TotalSeconds [expr $RoundedTotalTime % 60]
	    set RemainingMinutes [expr $RoundedTimeRemaining / 60]
	    set RemainingSeconds [expr $RoundedTimeRemaining % 60]

	    SetProgress .placard.progbar $cnt $FeatureCnt;
	    .placard.time configure -text\
		[format [_ "time elapsed: %1d minutes %2d seconds\nestimated total time: %1d minutes %2d seconds\nestimated time remaining: %1d minutes %2d seconds"]\
		     $ElapsedMinutes $ElapsedSeconds  $TotalMinutes $TotalSeconds $RemainingMinutes $RemainingSeconds]
	}
    }
}

proc ExplicateErrorStatus {} {
    global FeatureTestDebugP;
    global FeatureTestLogHandle;
    switch -exact -- [lindex $::errorCode 0] {
	CHILDKILLED {
	    foreach { - pid sigName msg } $::errorCode break
	    if {$FeatureTestDebugP} {
		puts $FeatureTestLogHandle [format "Child process %d died on signal %s" $pid $sigName];
		puts $FeatureTestLogHandle [format "Error message: %s" $msg];
	    }
	}
	CHILDSTATUS {
	    foreach { - pid code } $::errorCode break
	    if {$FeatureTestDebugP} {
		puts $FeatureTestLogHandle [format "Child process %d exited with error code %d" $pid $code];
	    }
	}
	CHILDSUSP {
	    foreach { - pid sigName msg } $::errorCode break
	    if {$FeatureTestDebugP} {
		puts $FeatureTestLogHandle [format "Child process %d has been suspended due to signal %d" $pid $sigName];
		puts $FeatureTestLogHandle [format "Error message: %s" $msg];
	    }
	}
	POSIX {
	    foreach { - errName msg } $::errorCode break
	    if {$FeatureTestDebugP} {
		puts $FeatureTestLogHandle \
		    [format "One of the kernel calls to launch the command failed with error %s" $errName];
		puts $FeatureTestLogHandle [format "Error message: %s" $msg];
	    }
	}
    }
}


proc SetCompoundFeatures {} {
    global Features;
    global program;
    global InterfaceLocale;

    set Features(alttype,$program,$InterfaceLocale) 0;
    if {$Features(pipebs,$program,$InterfaceLocale) == 1} {
	set Features(alttype,$program,$InterfaceLocale) 3; # (a\|b)
    }
    if {$Features(pipe,$program,$InterfaceLocale) == 1} {
	set Features(alttype,$program,$InterfaceLocale) 2; # (a|b)
    }
    if {$Features(pipedbs,$program,$InterfaceLocale) == 1} {
	set Features(alttype,$program,$InterfaceLocale) 6; # (a\\|b)
    }
    if {$Features(pipebsall,$program,$InterfaceLocale) == 1} {
	set Features(alttype,$program,$InterfaceLocale) 8; # \(a\|b\)
    }
    if {$Features(pipedbsall,$program,$InterfaceLocale) == 1} {
	set Features(alttype,$program,$InterfaceLocale) 7; # \\(a\\|b\\)
    }
    if {$Features(altcomma,$program,$InterfaceLocale) == 1} {
	set Features(alttype,$program,$InterfaceLocale) 4; # {a,b}
    }
    if {$Features(piperebol,$program,$InterfaceLocale) == 1} {
	set Features(alttype,$program,$InterfaceLocale) 5; # ("a"|"b")
    }
    # In programs that have them, sets are more efficient than alternation, so we
    # let sets override alternation if they are available.
    if {$Features(set,$program,$InterfaceLocale) == 1} {
	set Features(alttype,$program,$InterfaceLocale) 1;# [ab]
    }

    #Compound tests for Selfish quantifiers
    if {$Features(PossStarA,$program,$InterfaceLocale) && $Features(PossStarB,$program,$InterfaceLocale)} {
	set Features(PossStar,$program,$InterfaceLocale) 1;
    } else {
	set Features(PossStar,$program,$InterfaceLocale) 0;
    }

    if {$Features(PossPlusA,$program,$InterfaceLocale) && $Features(PossPlusB,$program,$InterfaceLocale)} {
	set Features(PossPlus,$program,$InterfaceLocale) 1;
    } else {
	set Features(PossPlus,$program,$InterfaceLocale) 0;
    }

    if {$Features(PossQMarkA,$program,$InterfaceLocale) && $Features(PossQMarkB,$program,$InterfaceLocale)} {
	set Features(PossQMark,$program,$InterfaceLocale) 1;
    } else {
	set Features(PossQMark,$program,$InterfaceLocale) 0;
    }

    if {$Features(PossAtLeastMA,$program,$InterfaceLocale) && $Features(PossAtLeastMB,$program,$InterfaceLocale)} {
	set Features(PossAtLeastM,$program,$InterfaceLocale) 1;
    } else {
	set Features(PossAtLeastM,$program,$InterfaceLocale) 0;
    }

    if {$Features(PossMToNA,$program,$InterfaceLocale) && \
	    $Features(PossMToNB,$program,$InterfaceLocale) && \
	    $Features(PossMToNC,$program,$InterfaceLocale)} {
	set Features(PossMToN,$program,$InterfaceLocale) 1;
    } else {
	set Features(PossMToN,$program,$InterfaceLocale) 0;
    }

    if {$Features(SelfishNoCaptureGroupA,$program,$InterfaceLocale) &&\
	    $Features(SelfishNoCaptureGroupB,$program,$InterfaceLocale) &&\
	    $Features(SelfishNoCaptureGroupC,$program,$InterfaceLocale) } {
	set Features(SelfishNoCaptureGroup,$program,$InterfaceLocale) 1;
    } else {
	set Features(SelfishNoCaptureGroup,$program,$InterfaceLocale) 0;
    }
    # Case-sensitivity
    if {$Features(CaseInsensitiveFlagSmallIAsciiLiteral,$program,$InterfaceLocale)} {
	set Features(CaseInsensitiveFlagSmallI,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveFlagSmallI,$program,$InterfaceLocale) 0;
    }

    if {$Features(CaseInsensitiveFlagSmallIuNonAsciiLiteral,$program,$InterfaceLocale)} {
	set Features(CaseInsensitiveFlagSmallIu,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveFlagSmallIu,$program,$InterfaceLocale) 0;
    }

    if {$Features(CaseInsensitiveCrosshatchAsciiLiteral,$program,$InterfaceLocale)} {
	set Features(CaseInsensitiveCrosshatch,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveCrosshatch,$program,$InterfaceLocale) 0;
    }

    if {$Features(CaseInsensitiveCrosshatchuNonAsciiLiteral,$program,$InterfaceLocale)} {
	set Features(CaseInsensitiveCrosshatchu,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveCrosshatchu,$program,$InterfaceLocale) 0;
    }

    if {$Features(CaseInsensitiveBSSmallCAsciiLiteral,$program,$InterfaceLocale)} {
	set Features(CaseInsensitiveBSSmallC,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveBSSmallC,$program,$InterfaceLocale) 0;
    }

    #Miscellaenous
    if {($Features(atsignonenext,$program,$InterfaceLocale) == 1) &&\
	    ($Features(group,$program,$InterfaceLocale) == 0)  &&\
	    ($Features(groupbs,$program,$InterfaceLocale) == 0)  &&\
	    ($Features(groupdbsnqq,$program,$InterfaceLocale) == 0)  &&\
	    ($Features(groupdbs,$program,$InterfaceLocale) == 0)  &&\
	    ($Features(ncgroup,$program,$InterfaceLocale) == 0)  &&\
	    ($Features(ncgroupdb,$program,$InterfaceLocale) == 0)} {
	set Features(ObligatoryQuantifierGroup,$program,$InterfaceLocale) 1;
    } else {
	set Features(ObligatoryQuantifierGroup,$program,$InterfaceLocale) 0;
    }
}

proc NullFeatures {program locale} {
    foreach test $::PropertyList {
	set ::Features($test,$program,$locale) 0;
    }
}

proc TestFeatures {} {
    global DoSubstitutionsP;
    global ExecCmd;
    global Program;
    global program;
    global Features;
    global RegexpResult;
    global ComparisonData;
    global ComparisonDataFromWindowP;
    global FeatureTestDebugP;
    global TestData;
    global Intended;
    global Regexp;
    global TestRegexp;
    global TestSubexp;
    global InterfaceLocale;
    global errorCode;
    global TestingFeaturesP;
    global FeatureTestP;

    if {$FeatureTestP == 0} {
	NullFeatures $program $InterfaceLocale
	ShowMessage [_ "Feature testing is disabled."];
	return;
    }
    if {[string equal $program agrep]} {
	WhichAgrep;
    }
    set TestingFeaturesP 1;
    PopupTestPatiencePlacard \
	[format [_ "Testing features of %1\$s in locale %2\$s\nand constructing palette.\nPlease be patient."]  $Program $InterfaceLocale] $::FirstTestP;
    update;
    set RedetFeatureTestFile [_ "FeatureTestLog"];
    set StartTime [clock seconds];

    #We need to prevent the comparison data from being read from 
    #the window, but it is perfectly possible that a user
    #will change programs while in edit mode, so we save
    #the comparison data source, set it to non-window, then
    #restore it when we are done.
    set SaveComparisonDataFromWindowP $ComparisonDataFromWindowP;
    set ComparisonDataFromWindowP 0;


    if {$FeatureTestDebugP} {
	if {[catch {open $RedetFeatureTestFile "w"} FeatureTestLogHandle ] != 0} {
	    ShowMessage [format [_ "Unable to open %s."] $RedetFeatureTestFile];
	    return ;
	}
	puts $FeatureTestLogHandle [format [_ "%s InterfaceLocale: %s"] \
			[clock format [clock seconds]] $::InterfaceLocale]
    }
    set tcnt 0;
    set FeatureCnt 0;
    foreach test $::PropertyList {
	if {$::PropertyUse($test,TestP)} {incr FeatureCnt}
    }
    #We can't do tests properly with global costs non-zero in those programs that
    #do approximate matching.
    if {[info exists ::ProgramInfo($::program,TotalCost)] } {
	set SavedTotalCost $::ProgramInfo($::program,TotalCost);
	set ::ProgramInfo($::program,TotalCost) 0;
    }
    set SavedDoSubstitutionsP $DoSubstitutionsP;
    set DoSubstitutionsP 0;#For now we have to run the tests in match mode no matter what.
    foreach test $::PropertyList {
	if {$::AbortFeatureTestP} {
	    set ::AbortFeatureTestP 0;
	    if {[info exists ::Features(tested,$program,$InterfaceLocale)]} {
		unset ::Features(tested,$program,$InterfaceLocale);
	    }
	    set DoSubstitutionsP $SavedDoSubstitutionsP;
	    set ComparisonData "";
	    set RegexpResult "";
	    set ComparisonDataFromWindowP $SaveComparisonDataFromWindowP;
	    destroy .placard;
	    set TestingFeaturesP 0;
	    if {$FeatureTestDebugP} {
		puts $FeatureTestLogHandle [_ "Test run aborted by user."];
		close $FeatureTestLogHandle;
	    }
	    ShowMessage [_ "Test run aborted by user."];
	    if {[SelectProgram $::InitialProgram] != 1} {
		after 5000; #Give the user a chance to see the message
		SelectProgram tcl
	    }
	    return ;
	}
	if {$::PropertyUse($test,TestP) == 0} {continue}

	#Skip tests that hang the program
	if {[info exists ::ProgramTestSkipList($program,$test)]} {
	    set ::Features($test,$program,$InterfaceLocale) 0;
	    continue;
	}

	incr tcnt;
	ShowTestProgress $tcnt $StartTime $FeatureCnt;update;
	if {$FeatureTestDebugP} {
	    puts -nonewline $FeatureTestLogHandle\
		[format "\n\[%3d/%3d\] %s - test %s" $tcnt $FeatureCnt $Program $test];
	    flush $FeatureTestLogHandle
	}
	WriteTestData $TestData($test);
	set Features($test,$program,$InterfaceLocale) 0;
	set RegexpResult "";
	set ComparisonData $Intended($test);
	#Set any program-specific parameters required for this test
	if {[info exists ::ProgramInfo($program,$test)]} {
	    set PropertyList $::ProgramInfo($program,$test);
	    foreach {property value} $PropertyList {
		#Save the current value so we can restore it after the test.
		lappend SavedPropertyList $property;
		lappend SavedPropertyList $::ProgramInfo($program,$property);
		#Temporarily substitute the value required for the test
		set ::ProgramInfo($program,$property) $value;
	    }
	}
	if {[string equal [string range $test 0 2] "Sub"]} {
	    if {[info exists ExecCmd($program,sub)]} {
		set SubExp $TestSubexp($test)
		set status [catch { $ExecCmd($program,sub) $TestRegexp($test) $SubExp} RegexpResult];
	    } else {
		if {$FeatureTestDebugP} {
		    puts $FeatureTestLogHandle "\tn/a - skipped"
		    flush $FeatureTestLogHandle
		}
		continue
	    }
	} else {
	    set SubExp "";
	    if {[info exists ExecCmd($program,match)]} {
		if {[info exists ExecCmd($program,match,$test)]} {
		    set tx $ExecCmd($program,match,$test);
		    set status [catch { $ExecCmd($program,match) $TestRegexp($test) $tx} RegexpResult];
		} else {
		    set status [catch { $ExecCmd($program,match) $TestRegexp($test)} RegexpResult];
		}
	    } else {
		if {$FeatureTestDebugP} {
		    puts $FeatureTestLogHandle "\tn/a - skipped"
		    flush $FeatureTestLogHandle
		}
		continue
	    }
	}
	set RegexpResult [string trimright $RegexpResult "\n"];
	#Restore any program-specific parameters required for this test
	if {[info exists ::ProgramInfo($program,$test)]} {
	    foreach {property value} $SavedPropertyList {
		set ::ProgramInfo($program,$property) $value;
	    }
	}
	# Command succeeded and wrote nothing to stderr.
	if { $status == 0} {
	    if {[string equal $program "bash"] || \
		    [string equal $program "fish"] || \
		    [string equal $program "ksh"] || \
		    [string equal $program "rc"] || \
		    [string equal $program "tcsh"] || \
		    [string equal $program "zsh"]} {
		set RegexpResult [lsort $RegexpResult]
		set ComparisonData [lsort $ComparisonData]
	    }
	    if {[string equal $RegexpResult $ComparisonData]} {
		set Features($test,$program,$InterfaceLocale) 1;
		if {$FeatureTestDebugP} {
		    puts $FeatureTestLogHandle "\t\tPassed"
		    puts $FeatureTestLogHandle "Regexp: $TestRegexp($test)\n"
		    if {[string equal $SubExp ""] == 0} {
			puts $FeatureTestLogHandle "Subexp: $SubExp\n"
		    }
		    puts $FeatureTestLogHandle [format "Result:\n%s\nIntended:\n%s" $RegexpResult $ComparisonData];
		    flush $FeatureTestLogHandle
		}
	    } else {
		set Features($test,$program,$InterfaceLocale) 0;
		if {$FeatureTestDebugP} {
		    puts $FeatureTestLogHandle "\t\tFailed on diff";
		    puts $FeatureTestLogHandle "Regexp: $TestRegexp($test)\n"
		    if {[string equal $SubExp ""] == 0} {
			puts $FeatureTestLogHandle "Subexp: $SubExp\n"
		    }
		    puts $FeatureTestLogHandle [format "Result:\n%s\nIntended:\n%s" $RegexpResult $ComparisonData];
		    flush $FeatureTestLogHandle
		}
	    }
	} elseif { [string equal $::errorCode NONE] } {
	    # The command exited with a normal status, but wrote something
	    # to stderr, which is included in RegexpResult.
	    set Features($test,$program,$InterfaceLocale) 0;
	    if {$FeatureTestDebugP} {
		puts $FeatureTestLogHandle "\tCommand exited normally but failed due to output to stderr: $errorCode";
		puts $FeatureTestLogHandle "RegexpResult = $RegexpResult";
		flush $FeatureTestLogHandle
	    }
	} else {
	    set Features($test,$program,$InterfaceLocale) 0;
	    if {$FeatureTestDebugP} {
		puts $FeatureTestLogHandle "\tCommand exited abnormally\nRegexpResult = $RegexpResult";
		flush $FeatureTestLogHandle
	    }
	    ExplicateErrorStatus;
	}
    }; #End of loop over feature tests

    # Implications
    if {$Features(taggedgroup,$program,$InterfaceLocale)} {
	set Features(taggedgroupref,$program,$InterfaceLocale) 1;
    } else {
	set Features(taggedgroupref,$program,$InterfaceLocale) 0;
    }

    if {$Features(group,$program,$InterfaceLocale)} {
	set Features(GroupNoWildcards,$program,$InterfaceLocale) 0;
    }

    if {$Features(dot,$program,$InterfaceLocale)} {
	set Features(DotAnySingle,$program,$InterfaceLocale) 0;
    }

    if {$Features(SubBackRefbs,$program,$InterfaceLocale) && \
	    $Features(SubBackRefParbs,$program,$InterfaceLocale)} {
	set Features(SubBackRefParbs,$program,$InterfaceLocale) 0;
    }

    if {$Features(xmldigit,$program,$InterfaceLocale)} {
	set Features(pdigit,$program,$InterfaceLocale) 0
    }
    if {$Features(xmldigitc,$program,$InterfaceLocale)} {
	set Features(pdigitc,$program,$InterfaceLocale) 0
    }
					
    # Replicate this for the other case insensitive features
    # Then change the Explain popups to use the generic features
    if {($Features(FlagQWideScope,$program,$InterfaceLocale)) ||\
	($Features(FlagCrosshatchWideScope,$program,$InterfaceLocale)) ||\
	($Features(FlagBSSmallCWideScope,$program,$InterfaceLocale))} {
	set Features(CaseInsensitiveFlagWideScope,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveFlagWideScope,$program,$InterfaceLocale) 0;
    }

    if {($Features(CaseInsensitiveFlagSmallIAsciiLiteral,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveCrosshatchAsciiLiteral,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveBSSmallCAsciiLiteral,$program,$InterfaceLocale))} {
	set Features(CaseInsensitiveAsciiLiteral,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveAsciiLiteral,$program,$InterfaceLocale) 0;
    }

    if {($Features(CaseInsensitiveFlagSmallINonAsciiLiteral,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveCrosshatchNonAsciiLiteral,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveBSSmallCNonAsciiLiteral,$program,$InterfaceLocale))} {
	set Features(CaseInsensitiveNonAsciiLiteral,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveNonAsciiLiteral,$program,$InterfaceLocale) 0;
    }

    if {($Features(CaseInsensitiveFlagSmallIAsciiClass,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveCrosshatchAsciiClass,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveBSSmallCAsciiClass,$program,$InterfaceLocale))} {
	set Features(CaseInsensitiveAsciiClass,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveAsciiClass,$program,$InterfaceLocale) 0;
    }

    if {($Features(CaseInsensitiveFlagSmallINonAsciiClass,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveCrosshatchNonAsciiClass,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveBSSmallCNonAsciiClass,$program,$InterfaceLocale))} {
	set Features(CaseInsensitiveNonAsciiClass,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveNonAsciiClass,$program,$InterfaceLocale) 0;
    }

    if {($Features(CaseInsensitiveFlagSmallIAsciiClassSymmetric,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveCrosshatchAsciiClassSymmetric,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveBSSmallCAsciiClassSymmetric,$program,$InterfaceLocale))} {
	set Features(CaseInsensitiveAsciiClassSymmetric,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveAsciiClassSymmetric,$program,$InterfaceLocale) 0;
    }

    if {($Features(CaseInsensitiveFlagSmallINonAsciiClassSymmetric,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveCrosshatchNonAsciiClassSymmetric,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveBSSmallCNonAsciiClassSymmetric,$program,$InterfaceLocale))} {
	set Features(CaseInsensitiveNonAsciiClassSymmetric,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveNonAsciiClassSymmetric,$program,$InterfaceLocale) 0;
    }

    if {($Features(CaseInsensitiveFlagSmallIOctal,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveCrosshatchOctal,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveBSSmallCOctal,$program,$InterfaceLocale))} {
	set Features(CaseInsensitiveOctal,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveOctal,$program,$InterfaceLocale) 0;
    }

    if {($Features(CaseInsensitiveFlagSmallIHex,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveCrosshatchHex,$program,$InterfaceLocale)) ||\
	($Features(CaseInsensitiveBSSmallCHex,$program,$InterfaceLocale))} {
	set Features(CaseInsensitiveHex,$program,$InterfaceLocale) 1;
    } else {
	set Features(CaseInsensitiveHex,$program,$InterfaceLocale) 0;
    }

    # We don't need to set to 0 in the else case because that will already have been done
    # when dollar was tested for.
#    if {$Features(AbsoluteEndOfString,$program,$InterfaceLocale)} {
#	set Features(dollar,$program,$InterfaceLocale) 1;
#    }

    if {$Features(CondLookaroundSimple,$program,$InterfaceLocale)} {
	set Features(CondPosLookaheadSimple,$program,$InterfaceLocale) 1;
	set Features(CondPosLookbackSimple,$program,$InterfaceLocale) 1;
	set Features(CondNegLookaheadSimple,$program,$InterfaceLocale) 1;
	set Features(CondNegLookbackSimple,$program,$InterfaceLocale) 1;
    } else {
	set Features(CondPosLookaheadSimple,$program,$InterfaceLocale) 0;
	set Features(CondPosLookbackSimple,$program,$InterfaceLocale) 0;
	set Features(CondNegLookaheadSimple,$program,$InterfaceLocale) 0;
	set Features(CondNegLookbackSimple,$program,$InterfaceLocale) 0;
    }

    if {$Features(CondLookaroundElse,$program,$InterfaceLocale)} {
	set Features(CondPosLookaheadElse,$program,$InterfaceLocale) 1;
	set Features(CondPosLookbackElse,$program,$InterfaceLocale) 1;
	set Features(CondNegLookaheadElse,$program,$InterfaceLocale) 1;
	set Features(CondNegLookbackElse,$program,$InterfaceLocale) 1;
    } else {
	set Features(CondPosLookaheadElse,$program,$InterfaceLocale) 0;
	set Features(CondPosLookbackElse,$program,$InterfaceLocale) 0;
	set Features(CondNegLookaheadElse,$program,$InterfaceLocale) 0;
	set Features(CondNegLookbackElse,$program,$InterfaceLocale) 0;
    }

    SetCompoundFeatures;

    #To force a feature to appear in the palette for debugging purposes,
    #Insert its name in place of F below and uncomment.
    #set Features(F,$program,$InterfaceLocale) 1;
#    set Features(W3CharClassSubtraction,$program,$InterfaceLocale) 1;#

    #Clean up
    set ComparisonData "";
    set RegexpResult "";
    set ComparisonDataFromWindowP $SaveComparisonDataFromWindowP;
    destroy .placard;
    set TestingFeaturesP 0;
    if {$FeatureTestDebugP} {
	puts $FeatureTestLogHandle [format [_ "Elapsed time: %d seconds."] [expr [clock seconds] - $StartTime]];
	close $FeatureTestLogHandle;
    }
    set DoSubstitutionsP $SavedDoSubstitutionsP;
    if {[info exists ::ProgramInfo($::program,TotalCost)] } {
	set ::ProgramInfo($::program,TotalCost) $SavedTotalCost;
    }
    set ::UpdateJavaByteCodeP 1;
    set ::FirstTestP 0;

    if {[string equal $program sed]} {
	set ::Features(tested,sed,$InterfaceLocale) 1;
	switch -exact --  $::ProgramInfo(sed,Which) {
	    minised {
		set ::Features(tested,minised,$InterfaceLocale) 1;
	    }
	    supersed {
		set ::Features(tested,ssed,$InterfaceLocale) 1;
	    }
	}
    } else {
	set ::Features(tested,$program,$InterfaceLocale) 1;
    }
    MarkProgramTested;
    #If the program has a control panel popup, retitle it in case
    #it was marked as untested.
    set wn [format ".pcp%s" $Program]
    if {[winfo exists $wn]} {
	$wn.title configure -text [_ [format "%s Settings" $Program]]
    }
}

#Shut down gracefully.
proc ShutDown {} {

    WriteJournal [format [_ "Session ended: %s\n"] [clock format [clock seconds]]];
    close $hist::HistoryListHandle;
    close $::JournalHandle;
    #Clean up temp files.
    #Use -f flag so that there is no error if a file does not exist.
    if {$::DebugP} {
	puts [format [_ "Temporary files left in %s. Clean up when you're done."] $::TempDir];
    } else {
	file delete -force $::CommandFile;
	file delete -force $::CSourceFile;
	file delete -force $::JavaMatchClassFile;
	file delete -force $::JavaMatchFile;
	file delete -force $::JavaSubClassFile;
	file delete -force $::JavaSubFile;
	file delete -force $::TestFile;
	file delete -force $::TempCompFile;
	file delete -force $::TempOutputFile;
	file delete -force $::TempSortFile;
	file delete -force $::TempGlobDir;
	file delete -force $::DiffResultFile;
	file delete -force $::EmacsWrapper
	file delete -force $::EmacsOutputFile
	file delete -force $::VersionFile
    }
    #Shutdown child browsers
    foreach pid $::BrowserPIDS {
	catch {exec kill $pid};
    }
    exit 0;
}

proc SaveRegexpAsHistory {} {
    global program;

    set rexp [string trim [$::REG get] "\n"];
    set sexp ""; # Just to be safe.
    set sexp [string trim [$::SUB get] "\n"];
    if {$rexp == ""} {
	ShowMessage [_ "There is no regular expression to save."];
	return;
    }
    set ReSaveFile [tk_getSaveFile -initialfile "Regexp"];
    if {$ReSaveFile != ""} {
	if {[catch {open $ReSaveFile "w"} ReSaveHandle ] != 0} {
	    ShowMessage [format [_ "Unable to open %s."] [MinimizeFileName $ReSaveFile]];
	    return;
	}
	puts $ReSaveHandle [format "%-*s%s%s%s%s" $hist::ProgramFieldWidth $program $hist::HistoryDelimiter $rexp $hist::HistoryDelimiter $sexp];
	close $ReSaveHandle;
	ShowMessage [format [_ "Regular expression saved in %s."] [MinimizeFileName $ReSaveFile]];
    }
}

proc SaveRegexpPlain {} {
    global program;

    set rexp [string trim [$::REG get] "\n"];
    if {$rexp == ""} {
	ShowMessage [_ "There is no regular expression to save."];
	return;
    }
    set ReSaveFile [tk_getSaveFile -initialfile "RegularExpression"];
    if {$ReSaveFile != ""} {
	if {[catch {open $ReSaveFile "w"} ReSaveHandle ] != 0} {
	    ShowMessage [format [_ "Unable to open %s."] [MinimizeFileName $ReSaveFile]];
	    return;
	}
	puts $ReSaveHandle $rexp;
	close $ReSaveHandle;
	ShowMessage [format [_ "Regular expression saved in %s."] [MinimizeFileName $ReSaveFile]];
    }
}

proc SaveSubexpPlain {} {
    global program;

    set sexp [string trim [$::SUB get] "\n"];
    if {$sexp == ""} {
	ShowMessage [_ "There is no substitution expression to save."];
	return;
    }
    set SeSaveFile [tk_getSaveFile -initialfile "SubstitutionExpression"];
    if {$SeSaveFile != ""} {
	if {[catch {open $SeSaveFile "w"} SeSaveHandle ] != 0} {
	    ShowMessage [format [_ "Unable to open %s."] [MinimizeFileName $SeSaveFile]];
	    return;
	}
	puts $SeSaveHandle $sexp;
	close $SeSaveHandle;
	ShowMessage [format [_ "Substitution expression saved in %s."] [MinimizeFileName $SeSaveFile]];
    }
}

proc SaveActualRegexp {} {
    if {$::PreviousActualRegexp == ""} {
	ShowMessage [_ "There is no actual regular expression to save."];
	return;
    }
    set ReSaveFile [tk_getSaveFile -initialfile "ActualRegularExpression"];
    if {$ReSaveFile != ""} {
	if {[catch {open $ReSaveFile "w"} ReSaveHandle ] != 0} {
	    ShowMessage [format [_ "Unable to open %s."] [MinimizeFileName $ReSaveFile]];
	    return;
	}
	puts $ReSaveHandle  $::PreviousActualRegexp
	close $ReSaveHandle;
	ShowMessage [format [_ "Regular expression saved in %s."] [MinimizeFileName $ReSaveFile]];
    }
}

proc SaveResults {} {
    global RegexpResult;
    global OutputFromWindowP;

    if {$OutputFromWindowP} {
	set RegexpResult [$::OUT get 1.0 end];
    }
    if {$RegexpResult == ""} {
	ShowMessage [_ "There is no output to save."];
	return ;
    }
    set OutputSaveFile [tk_getSaveFile -initialfile [_ "REDETOutput"]];
    if {$OutputSaveFile == ""} {
	ShowMessage [format [_ "Unable to open %s."] [MinimizeFileName $OutputSaveFile]];
	return ;
    }
    if {[catch {open $OutputSaveFile "w"} OutputSaveHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s to save regular expression output."] \
			 [MinimizeFileName $OutputSaveFile]];
	return ;
    }

    if {[string equal $::Pars(ResultEncoding) utf-8]} {
	#There's no point incurring the overhead of pwe if we don't need to
	fconfigure $OutputSaveHandle -encoding utf-8
	puts $OutputSaveHandle $RegexpResult;
	set msg [format [_ "Regular expression output saved in %s."] [MinimizeFileName $OutputSaveFile]];
    } else {
	if {[catch {PutWithEncoding $OutputSaveHandle $::Pars(ResultEncoding) $RegexpResult} msg] != 0} {
	} else {
	    PutNL $OutputSaveHandle
	    set msg [format [_ "Regular expression output saved in %s."] [MinimizeFileName $OutputSaveFile]];
	}
    }
    close $OutputSaveHandle;
    ShowMessage $msg
}

proc TogglePalette {} {
    global PaletteIsDisplayedP;
    global PaletteToBeDisplayedP;
    global Program;
    global PaletteFeatures;
    global FeatureTestP;

    if {$::TestingFeaturesP} {
	ShowMessage [_ "Testing of palette features is in progress. Please wait a moment."]
	return ;
    }

    if {$PaletteFeatures == 0} {
	if {$FeatureTestP == 0} {
	    ShowMessage [_ "Feature testing is disabled."];
	} else {
	    ShowMessage [format [_ "%s does not support any palette entries."] $Program];
	}
	return;
    }

    if {[winfo exists $::PALF.lba] == 0} {ConstructPalette;}

    if { $PaletteIsDisplayedP == 0} {
	ShowPalette;
	set PaletteIsDisplayedP 1;
	set PaletteToBeDisplayedP 1;
    } else {
	wm withdraw .pal
	set PaletteIsDisplayedP 0;
	set PaletteToBeDisplayedP 0;
    }
}



proc ShowPalette {} {
    wm deiconify .pal
}

# The following sets up a progress bar.
option add *Progress.undoneForeground black  widgetDefault
option add *Progress.undoneBackground white  widgetDefault
option add *Progress.doneForeground   white  widgetDefault
option add *Progress.doneBackground   \#EFAC49 widgetDefault
option add *Progress.borderWidth      3      widgetDefault
option add *Progress$.relief           sunken widgetDefault

namespace eval dkfprogress {
    namespace export Progress SetProgress

    proc Progress {w args} {
	uplevel 1 [list frame $w -class Progress] $args

	foreach {val} {
	    undoneForeground doneForeground
	    undoneBackground doneBackground
	} {
	    set class [string toupper [string index $val 0]\
		    ][string range $val 1 end]
	    set $val [option get $w $val $class]
	}

	set varname [namespace current]::progressPercent($w)
	frame $w.l -borderwidth 0 -background $undoneBackground
	label $w.l.l -textvariable $varname -borderwidth 0 \
		-foreground $undoneForeground -background $undoneBackground
	$w.l configure -height [expr {int([winfo reqheight $w.l.l]+2)}]
	frame $w.l.fill -background $doneBackground
	label $w.l.fill.l -textvariable $varname -borderwidth 0 \
		-foreground $doneForeground -background $doneBackground

	bind $w.l <Configure> [namespace code [list ProgressConf $w "%w"]]

	pack $w.l -fill both -expand 1
	place $w.l.l -relx 0.5 -rely 0.5 -anchor center
	place $w.l.fill -x 0 -y 0 -relheight 1 -relwidth 0
	place $w.l.fill.l -x 0 -rely 0.5 -anchor center

	SetProgress $w 0
	return $w
    }

    proc ProgressConf {w width} {
	place conf $w.l.fill.l -x [expr {int($width/2)}]
    }

    proc ColorSequence n {
	if {$n<0} {set n 0} elseif {$n>100} {set n 100}
	set green 0; 
	set red 0;
	set blue 0;
	set red  [expr int(2.55 *(100 - $n))];
	set green [expr  int(2.55 * $n)];
	return [format "#%02x%02x%02x" $red $green $blue];
    }

    proc SetProgress {win value {range 100}} {
	set progress [expr {int(100*$value)/int($range)}]
	set relwidth [expr {double($value)/double($range)}]
	variable progressPercent
	place conf $win.l.fill -relwidth $relwidth
	.placard.progbar.l.fill configure -bg [ColorSequence $progress];
	set progressPercent($win) "${progress}%"
	wm title .placard [format [_ "%3d%% Feature Test Progress"] $progress]
    }
}

namespace import dkfprogress::Progress dkfprogress::SetProgress

#This works, but it could probably be made more efficient if we figured out
#what the cause of the extra newlines is and eliminated them at the source.
proc CountChanges {a b} {
    if { [string length $a] < 1} {return 0;}
    if { [string length $b] < 1} {return 0;}
    set a [string trimright $a "\n"];
    set b [string trimright $b "\n"];
    set ALines [split $a "\n"];
    set BLines [split $b "\n"];
    set ALength [llength $ALines];
    set BLength [llength $BLines];
    if {$ALength != $BLength} {
	ShowMessage [_ "Substitution error: input and output do not contain the same number of lines"];
	puts [format "len(a) = %d\tlen(B) = %d" $ALength $BLength];
	return -1;
    }
    set ChangeCount 0;
    for {set i 0} {$i < $ALength} {incr i} {
	if { [string equal [lindex $ALines $i]  [lindex $BLines $i]] != 1} {
	    incr ChangeCount;
	}
    }
    return $ChangeCount;
}

proc GetChanges {a b} {
    set ChangedLines [list];
    set a [string trimright $a "\n"];
    set b [string trimright $b "\n"];
    set ALines [split $a "\n"];
    set BLines [split $b "\n"];
    set ALength [llength $ALines];
    set BLength [llength $BLines];
    if {$ALength != $BLength} {
	ShowMessage [format [_ "Possible substitution error: test lines %d != output lines %d"] $ALength $BLength];
    }
    if {$ALength < $BLength} {
	set len $ALength;
    } else {
	set len $BLength;
    }
    for {set i 0} {$i < $len} {incr i} {
	set BLine [lindex $BLines $i];
	if { [string equal [lindex $ALines $i]  $BLine] != 1} {
	    lappend ChangedLines $BLine;
	}
    }
    return $ChangedLines;
}

proc CountChars {t} {
    return  [llength [split $t ""]];
}
					
#This is MUCH faster than directly counting newline characters.
proc CountLines {s} {
    if { [string length $s] < 1} {return 0;}
    return [llength [split $s "\n"]];
}

proc ToggleSubstitutionMode {} {
    global DoSubstitutionsP;
    global m;
    global SubstitutionModeIndex;
    global Features;
    global program;

    if {$DoSubstitutionsP == 0} {
	set DoSubstitutionsP 1;
	ShowMessage [_ "Entering substitution mode."]
	$m.configure entryconfigure $SubstitutionModeIndex -label \
	    [_ "Change to Match Mode"];
	CheckModeCompatibility;
	if {$::StandardConfigurationP} {
	    set ::SideBySideLayoutP 1;
	    set ::RegSubSideBySideP 1;
	}
    } else {
	set DoSubstitutionsP 0;
	ShowMessage [_ "Entering match mode."]
	$m.configure entryconfigure $SubstitutionModeIndex -label \
	    [_ "Change to Substitution Mode"];
	CheckModeCompatibility;
	if {$::StandardConfigurationP} {
	    set ::SideBySideLayoutP 0;
	    set ::RegSubSideBySideP 0;
	}
    }
    SetRegReturnBinding;
    SetTitle $::Version [ProgramTimeDateStamp] $::InterfaceLocale $::DoSubstitutionsP;
    LayoutWindows;
}

proc InOutScrollLinkage {} {
    global DoSubstitutionsP;
    global OutputOnlyChangedLinesP;
    if {$DoSubstitutionsP} {
	if {$OutputOnlyChangedLinesP == 0} {
	    bind $::IND  <Motion>  {$::OUT yview moveto [lindex [$::IND yview] 0]}
	    bind $::OUT <Motion>  {$::IND yview moveto [lindex [$::OUT yview] 0]}
	    return ;
	}	      
    }
    bind $::IND  <Motion> "";  
    bind $::OUT <Motion> "";
}


#Character entry code begins here
#Set this to the path to character entry menu
set CEM .menubar.tools.charentry
#Set the default insertion target here.
set InsertionTarget $::REG;
set UseNoGlyphsP 0; #Should we include in widgets characters not in Code2000?
#Anywhere that you want to insert characters, set up a binding like this:
#bind WIDGETPATHNAME <FocusIn> {SetInsertionTargets WIDGETPATHNAME}

set DisplayConsonantChartColumnLabelsP 1
set DisplayConsonantChartRowLabelsP 1
set DisplayVowelChartColumnLabelsP 1
set DisplayVowelChartRowLabelsP 1

proc BindInsertionTarget {v} {
    bind $v <FocusIn> "+SetInsertionTargets $v"
}

option add *ipaec.Button.font CharacterEntryFont 100
option add *ipaec.Label.background  $ColorSpecs(IPAEntry,Background)
option add *ipaec.Button.background $ColorSpecs(IPAEntry,Background)
option add *ipaec.Button.foreground $ColorSpecs(IPAEntry,Foreground)
option add *ipaec.Label.relief raised

option add *ipaev.Button.font CharacterEntryFont 100
option add *ipaev.Label.background  $ColorSpecs(IPAEntry,Background)
option add *ipaev.Button.background $ColorSpecs(IPAEntry,Background)
option add *ipaev.Button.foreground $ColorSpecs(IPAEntry,Foreground)
option add *ipaev.Label.relief raised

option add *ipaea.Button.font AccentedLetterFont 100
option add *ipaea.Label.background  "\#E0E0E0"
option add *ipaea.Button.background "\#FFFFFF"
option add *ipaea.Button.foreground "\#000000"
option add *ipaea.Label.relief raised

option add *ipaed.Button.font DiacriticFont 100
#option add *ipaed.Label.background  $ColorSpecs(IPAEntry,Background)
option add *ipaed.Button.background "\#E0E0FF"
option add *ipaed.Label.background "\#E0E0E0"
option add *ipaed.Button.foreground "\#000000"
option add *ipaed.Label.relief raised

proc SetInsertionTargets {tgt} {
    set ::InsertionTarget $tgt;
    set ::CharByCodeInsertionTarget $tgt;
}

option add *ipae*.*Label.font CharacterEntryLabelFont 100
option add *ipaec.*Button.font CharacterEntryFont 100
namespace eval ipaentry {
    variable IPAECColumnLabelList [list];
    variable IPAECRowLabelList [list];
    variable IPAEVColumnLabelList [list];
    variable IPAEVRowLabelList [list];

    set row 0;
    variable poa $row;
    incr row;
    variable vlstop $row;
    incr row;
    variable vdstop $row;
    incr row;
    variable vdimplosive $row;
    incr row;
    variable click $row;
    incr row;
    variable nasal  $row;
    incr row;
    variable trill $row;
    incr row;
    variable tap $row;
    incr row;
    variable vlfric $row;
    incr row;
    variable vdfric $row;
    incr row;
    variable vlaffric $row;
    incr row;
    variable vdaffric $row;
    incr row;
    variable approx $row;
    incr row; 
    variable latapprox $row;
    variable lastrow $row;

    set col 0;
    variable manner $col; 
    incr col;
    variable labial $col; 
    incr col;
    variable labiodental $col; 
    incr col;
    variable dental $col; 
    incr col;
    variable alveolar $col;
    incr col;
    variable postalveolar $col; 
    incr col;
    variable retroflex $col; 
    incr col;
    variable palatal $col; 
    incr col;
    variable velar $col; 
    incr col;
    variable uvular $col; 
    incr col;
    variable pharyngeal $col; 
    incr col;
    variable epiglottal $col; 
    incr col;
    variable glottal $col;
    variable lastcolumn $col;

    proc cfesh {} {
	variable vlfric
	variable postalveolar
	eval [list [format ".ipaec.r%dc%d" $vlfric $postalveolar] configure -text "\u0161"];
    }
    proc cresh {} {
	variable vlfric
	variable postalveolar
	eval [list [format ".ipaec.r%dc%d" $vlfric $postalveolar] configure -text "\u0283"];
    }

    proc cfeshr {} {
	variable vlfric
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $vlfric $retroflex] configure -text "\u1E63"];
    }
    proc creshr {} {
	variable vlfric
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $vlfric $retroflex] configure -text "\u0282"];
    }

    proc cryod {} {
	variable approx
	variable palatal
	eval [list [format ".ipaec.r%dc%d" $approx $palatal] configure -text "j"];
    }

    proc cfyod {} {
	variable approx
	variable palatal
	eval [list [format ".ipaec.r%dc%d" $approx $palatal] configure -text "y"];
    }

    proc crny {} {
	variable nasal
	variable palatal
	eval [list [format ".ipaec.r%dc%d" $nasal $palatal] configure -text "\u0272"];
    }
    proc cfny {} {
	variable nasal
	variable palatal
	eval [list [format ".ipaec.r%dc%d" $nasal $palatal] configure -text "\u00F1"];
    }

    proc crch {} {
	variable vlaffric
	variable postalveolar
	eval [list [format ".ipaec.r%dc%d" $vlaffric $postalveolar] configure -text "t\u0283"];
    }
    proc cfch {} {
	variable vlaffric
	variable postalveolar
	eval [list [format ".ipaec.r%dc%d" $vlaffric $postalveolar] configure -text "\u010D"];
    }

    proc crchr {} {
	variable vlaffric
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $vlaffric $retroflex] configure -text "\u0288\u0282"];
    }

    proc cfchr {} {
	variable vlaffric
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $vlaffric $retroflex] configure -text "\u1E6D\u1E63"];
    }


    proc crdj {} {
	eval [list [format ".ipaec.r%dc%d" $ipaentry::vdaffric $ipaentry::postalveolar] configure -text "d\u0292"];
    }

    proc cfdj {} {
	eval [list [format ".ipaec.r%dc%d" $ipaentry::vdaffric $ipaentry::postalveolar] configure -text "\u01C6"];
    }

    proc crdjr {} {
	eval [list [format ".ipaec.r%dc%d" $ipaentry::vdaffric $ipaentry::retroflex] configure -text "\u0256\u0290"];
    }

    proc cfdjr {} {
	eval [list [format ".ipaec.r%dc%d" $ipaentry::vdaffric $ipaentry::retroflex] configure -text "\u1E0D\u1E93"];
    }

    proc crzh {} {
	variable vdfric
	variable postalveolar
	eval [list [format ".ipaec.r%dc%d" $vdfric $postalveolar] configure -text "\u0292"];
    }
    proc cfzh {} {
	variable vdfric
	variable postalveolar
	eval [list [format ".ipaec.r%dc%d" $vdfric $postalveolar] configure -text "\u017E"];
    }

    proc crtr {} {
	variable vlstop
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $vlstop $retroflex] configure -text "\u0288"];
    }
    proc cftr {} {
	variable vlstop
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $vlstop $retroflex] configure -text "\u1E6D"];
    }

    proc crdr {} {
	variable vdstop
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $vdstop $retroflex] configure -text "\u0256"];
    }
    proc cfdr {} {
	variable vdstop
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $vdstop $retroflex] configure -text "\u1E0D"];
    }


    proc crnr {} {
	variable nasal
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $nasal $retroflex] configure -text "\u0273"];
    }
    proc cfnr {} {
	variable nasal
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $nasal $retroflex] configure -text "\u1E47"];
    }


    proc crzhr {} {
	variable vdfric
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $vdfric $retroflex] configure -text "\u0290"];
    }
    proc cfzhr {} {
	variable vdfric
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $vdfric $retroflex] configure -text "\u1E93"];
    }

    proc crflapr {} {
	variable tap;
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $tap $retroflex] configure -text "\u027D"];
    }
    proc cfflapr {} {
	variable tap;
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $tap $retroflex] configure -text "\u1E5B"];
    }

    proc crlr {} {
	variable latapprox;
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $latapprox $retroflex] configure -text "\u026D"];
    }
    proc cflr {} {
	variable latapprox;
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $latapprox $retroflex] configure -text "\u1E37"];
    }

    proc crrr {} {
	variable approx;
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $approx $retroflex] configure -text "\u027B"];
    }
    proc cfrr {} {
	variable approx;
	variable retroflex
	eval [list [format ".ipaec.r%dc%d" $approx $retroflex] configure -text "\u1E5B"];
    }

    proc bhcham {w} {
	balloonhelp_for $w "The standard IPA character is shown by default. When the mouse\npointer is over the button, the \"North American\" variant is shown.\nRight click to insert the variant."
    }

    proc bhsp {w} {
	balloonhelp_for $w "The characters below and to the right are characters\nthat do not fit neatly into the chart."
    }

    proc UnpackConsonantColumnLabels {} {
	variable IPAECColumnLabelList;
	foreach l $IPAECColumnLabelList {
	    grid forget $l;
	}
    }

    proc PackConsonantColumnLabels {} {
	destroy .ipaec
	PopupIPAEntryC;
    }

    proc UnpackConsonantRowLabels {} {
	variable IPAECRowLabelList;
	foreach l $IPAECRowLabelList {
	    grid forget $l;
	}
    }

    proc PackConsonantRowLabels {} {
	destroy .ipaec;
	PopupIPAEntryC;
    }

    proc UnpackVowelColumnLabels {} {
	variable IPAEVColumnLabelList;
	foreach l $IPAEVColumnLabelList {
	    grid forget $l;
	}
    }

    proc PackVowelColumnLabels {} {
	destroy .ipaev;
	PopupIPAEntryV;
    }

    proc UnpackVowelRowLabels {} {
	variable IPAEVRowLabelList;
	foreach l $IPAEVRowLabelList {
	    grid forget $l;
	}
    }

    proc PackVowelRowLabels {} {
	destroy .ipaev;
	PopupIPAEntryV;
    }

    proc PopupIPAEntryC {} {
	variable poa
	variable vlstop 
	variable vdstop
	variable vdimplosive 
	variable click 
	variable nasal  
	variable trill 
	variable tap 
	variable vlfric 
	variable vdfric 
	variable vlaffric 
	variable vdaffric 
	variable approx 
	variable latapprox
	variable lastrow

	variable manner 
	variable labial 
	variable labiodental 
	variable dental 
	variable alveolar 
	variable postalveolar 
	variable retroflex 
	variable palatal 
	variable velar 
	variable uvular 
	variable pharyngeal 
	variable epiglottal 
	variable glottal
	variable lastcolumn

	variable IPAECColumnLabelList;
	variable IPAECRowLabelList;
	global DisplayConsonantChartColumnLabelsP
	global DisplayConsonantChartRowLabelsP

	set IPAECColumnLabelList [list];
	set IPAECRowLabelList [list];
	
	set xp 2;
	set yp 3;
	set spcolor 	\#c46276;
	toplevel .ipaec -borderwidth 3 -class CharEntry
	wm title .ipaec [_ "Consonant Symbols"]
	BindKeys .ipaec;
	set DownMsg [_ "Display IPA Consonant Chart"];
	set UpMsg   [_ "Remove IPA Consonant Chart"];
	bind .ipaec <Destroy> \
	    "set ::IPACIsDisplayedP 0;$::CEM entryconfigure $::ToggleIPACIndex -label \"$DownMsg\""
	bind .ipaec <Unmap> \
	    "set ::IPACIsDisplayedP 0;$::CEM entryconfigure $::ToggleIPACIndex -label \"$DownMsg\""
	bind .ipaec <Map> \
	    "set ::IPACIsDisplayedP 1;$::CEM entryconfigure $::ToggleIPACIndex -label \"$UpMsg\""
	set tmp [label [format ".ipaec.r%dc%d" $manner $poa] \
	  -text [_ "IPA\nConsonants"]  -padx 5 -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList $tmp;
	lappend IPAECRowLabelList $tmp;
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $labial] \
	    -text [_ "labial"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $labiodental] \
	    -text [_ "labio\ndental"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $dental] \
	    -text [_ "dental"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $alveolar] \
	    -text [_ "alveolar"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $postalveolar] \
	    -text [_ "post\nalveolar"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $retroflex] \
	    -text [_ "retro\nflex"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $palatal] \
	    -text [_ "palatal"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $velar] \
	    -text [_ "velar"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $uvular] \
	    -text [_ "uvular"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $pharyngeal] \
	    -text [_ "pharyn\ngeal"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $epiglottal] \
	    -text [_ "epi\nglottal"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAECColumnLabelList [label [format ".ipaec.r%dc%d" $manner $glottal] \
	    -text [_ "glottal"]   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]

	#Voiceless oral stops
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $vlstop $poa] \
	       -text [_ "voiceless stops"] -anchor w  -padx $xp -pady $yp \
	       -bg $::ColorSpecs(IPAHeadings,Background)]
	set cmd {$::InsertionTarget insert insert [list p]}
	set bn [format ".ipaec.r%dc%d"  $vlstop $labial]
	button $bn  -text "p" -padx $xp -pady $yp -command  $cmd \
	    -fg $::ColorSpecs(UserTextEntry,Foreground); #debug
	balloonhelpd_for $bn [_ "voiceless labial stop"]

	label [format ".ipaec.r%dc%d" $vlstop $labiodental] \
	    -text " " -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list t\u032A]}
	set bn [format ".ipaec.r%dc%d"  $vlstop $dental]
	button $bn  -text "t\u032A"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "voiceless dental stop"]

	set cmd {$::InsertionTarget insert insert [list t]}
	set bn [format ".ipaec.r%dc%d"  $vlstop $alveolar]
	button $bn -text "t"   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless alveolar stop"]

	label [format ".ipaec.r%dc%d"  $vlstop $postalveolar] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u0288]}
	set bn [format ".ipaec.r%dc%d"  $vlstop $retroflex]
	button $bn  -text \u0288   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u1E6D]}
	bind $bn <Enter> {ipaentry::cftr}
	bind $bn <Leave> {ipaentry::crtr}
	bhcham $bn;
	balloonhelpd_for $bn [_ "voiceless retroflex stop"]

	set cmd {$::InsertionTarget insert insert [list c]}
	set bn [format ".ipaec.r%dc%d"  $vlstop $palatal]
	button $bn -text "c"   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless palatal stop"]

	set cmd {$::InsertionTarget insert insert [list k]}
	set bn [format ".ipaec.r%dc%d" $vlstop $velar]
	button $bn -text "k" -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless velar stop"]

	set cmd {$::InsertionTarget insert insert [list q]}
	set bn [format ".ipaec.r%dc%d" $vlstop $uvular]
	button $bn  -text "q"   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless uvular stop"]

	label [format ".ipaec.r%dc%d" $vlstop $pharyngeal] -text " "   -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $vlstop $epiglottal] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u0294]}
	set bn [format ".ipaec.r%dc%d" $vlstop $glottal]
	button $bn -text \u0294   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless glottal stop"]

	#Voiced oral stops
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $vdstop $poa] \
	       -text [_ "voiced stops"] -anchor w   -padx $xp -pady $yp \
	       -bg $::ColorSpecs(IPAHeadings,Background)]
	set cmd {$::InsertionTarget insert insert [list b]}
	set bn [format ".ipaec.r%dc%d" $vdstop $labial]
	button $bn -text "b"   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced bilabial stop"]

	label [format ".ipaec.r%dc%d" $vdstop $labiodental] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list d\u032A]}
	set bn [format ".ipaec.r%dc%d" $vdstop $dental]
	button $bn -text "d\u032A"   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced dental stop"]

	set cmd {$::InsertionTarget insert insert [list d]}
	set bn [format ".ipaec.r%dc%d" $vdstop $alveolar]
	button  $bn -text "d"   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced alveolar stop"]

	label [format ".ipaec.r%dc%d"  $vdstop $postalveolar] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u0256]}
	set bn [format ".ipaec.r%dc%d"  $vdstop $retroflex]
	button $bn  -text \u0256   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u1E0D]}
	bind $bn <Enter> {ipaentry::cfdr}
	bind $bn <Leave> {ipaentry::crdr}
	bhcham $bn;
	balloonhelpd_for $bn [_ "voiced retroflex stop"]

	set cmd {$::InsertionTarget insert insert [list \u025F]}
	set bn [format ".ipaec.r%dc%d" $vdstop $palatal]
	button $bn -text \u025F   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced palatal stop"]


	set cmd {$::InsertionTarget insert insert [list g]}
	set bn [format ".ipaec.r%dc%d" $vdstop $velar]
	button $bn -text "g"   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced velar stop"]

	set cmd {$::InsertionTarget insert insert [list \u0262]}
	set bn [format ".ipaec.r%dc%d" $vdstop $uvular]
	button $bn -text \u0262  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced uvular stop"]

	label [format ".ipaec.r%dc%d" $vdstop $pharyngeal] -text " "  -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u02A1]}
	set bn [format ".ipaec.r%dc%d" $vdstop $epiglottal]
	button $bn -text \u02A1  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced epiglottal stop"]

	label [format ".ipaec.r%dc%d" $vdstop $glottal] -text " "  -padx $xp -pady $yp

	#Nasals
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $nasal $poa] \
	       -text [_ "nasals"] -anchor w -padx $xp -pady $yp \
	       -bg $::ColorSpecs(IPAHeadings,Background)]

	set cmd {$::InsertionTarget insert insert [list m]}
	set bn [format ".ipaec.r%dc%d" $nasal $labial]
	button $bn -text "m" -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "bilabial nasal"]

	set cmd {$::InsertionTarget insert insert [list \u0271]}
	set bn [format ".ipaec.r%dc%d" $nasal $labiodental]
	button $bn -text \u0271   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "labiodental nasal"]

	set cmd {$::InsertionTarget insert insert [list n\u032A]}
	set bn [format ".ipaec.r%dc%d" $nasal $dental]
	button $bn -text n\u032A   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "dental nasal"]

	set cmd {$::InsertionTarget insert insert [list n]}
	set bn [format ".ipaec.r%dc%d" $nasal $alveolar]
	button $bn -text "n"      -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "alveolar nasal"]

	label [format ".ipaec.r%dc%d"  $nasal $postalveolar] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u0273]}
	set bn [format ".ipaec.r%dc%d"  $nasal $retroflex]
	button $bn  -text \u0273   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u1E47]}
	bind $bn <Enter> {ipaentry::cfnr}
	bind $bn <Leave> {ipaentry::crnr}
	bhcham $bn;
	balloonhelpd_for $bn [_ "retroflex nasal"]

	set cmd {$::InsertionTarget insert insert [list \u0272]}
	set bn [format ".ipaec.r%dc%d" $nasal $palatal]
	button $bn  -text \u0272    -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u00F1]}
	bind $bn <Enter> {ipaentry::cfny}
	bind $bn <Leave> {ipaentry::crny}
	bhcham $bn;
	balloonhelpd_for $bn [_ "palatal nasal"]

	set cmd {$::InsertionTarget insert insert [list \u014B]}
	set bn [format ".ipaec.r%dc%d" $nasal $velar]
	button $bn -text \u014B    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "velar nasal"]

	set cmd {$::InsertionTarget insert insert [list \u0274]}
	set bn [format ".ipaec.r%dc%d" $nasal $uvular]
	button $bn -text \u0274    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "uvular nasal"]

	label [format ".ipaec.r%dc%d" $nasal $pharyngeal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $nasal $epiglottal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $nasal $glottal] -text " "    -padx $xp -pady $yp

	#Voiceless fricatives
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $vlfric $poa] \
	       -text [_ "voiceless fricatives"] -anchor w  -padx $xp -pady $yp \
	       -bg $::ColorSpecs(IPAHeadings,Background)]

	set cmd {$::InsertionTarget insert insert [list \u03C6]}
	set bn [format ".ipaec.r%dc%d" $vlfric $labial]
	button $bn -text \u03C6  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless bilabial fricative"]

	set cmd {$::InsertionTarget insert insert [list f]}
	set bn [format ".ipaec.r%dc%d" $vlfric $labiodental]
	button $bn  -text "f"   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless labiodental fricative"]

	set cmd {$::InsertionTarget insert insert [list \u03B8]}
	set bn [format ".ipaec.r%dc%d" $vlfric $dental]
	button $bn -text \u03B8   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless dental fricative"]

	set cmd {$::InsertionTarget insert insert [list "s"]}
	set bn [format ".ipaec.r%dc%d" $vlfric $alveolar]
	button $bn -text "s"  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless alveolar fricative"]

	set cmd {$::InsertionTarget insert insert [list \u0283]}
	set bn [format ".ipaec.r%dc%d" $vlfric $postalveolar];
	button $bn -text \u0283   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u0161]}
	bind $bn <Enter> {ipaentry::cfesh}
	bind $bn <Leave> {ipaentry::cresh}
	bhcham $bn;
	balloonhelpd_for $bn [_ "voiceless postalveolar fricative"]

	set cmd {$::InsertionTarget insert insert [list \u0282]}
	set bn [format ".ipaec.r%dc%d" $vlfric $retroflex];
	button $bn -text \u0282   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u1E63]}
	bind $bn <Enter> {ipaentry::cfeshr}
	bind $bn <Leave> {ipaentry::creshr}
	bhcham $bn;
	balloonhelpd_for $bn [_ "voiceless retroflex fricative"]

	set cmd {$::InsertionTarget insert insert [list \u0255]}
	set bn [format ".ipaec.r%dc%d" $vlfric $palatal]
	button $bn -text \u0255  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless palatal fricative"]

	set cmd {$::InsertionTarget insert insert [list "x"]}
	set bn [format ".ipaec.r%dc%d" $vlfric $velar]
	button $bn -text "x" -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless velar fricative"]

	set cmd {$::InsertionTarget insert insert [list "\u03C7"]}
	set bn [format ".ipaec.r%dc%d" $vlfric $uvular]
	button $bn -text "\u03C7"    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless uvular fricative"]

	set cmd {$::InsertionTarget insert insert [list \u0127]}
	set bn [format ".ipaec.r%dc%d" $vlfric $pharyngeal]
	button $bn -text \u0127 -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless pharyngeal fricative"]

	set cmd {$::InsertionTarget insert insert [list \u029C]}
	set bn [format ".ipaec.r%dc%d" $vlfric $epiglottal]
	button $bn -text \u029C   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless epiglottal fricative"]

	set cmd {$::InsertionTarget insert insert [list "h"]}
	set bn [format ".ipaec.r%dc%d" $vlfric $glottal]
	button $bn -text "h" -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless glottal fricative"]

	#Voiced fricatives
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $vdfric $poa] \
	       -text [_ "voiced fricatives"] -anchor w \
	       -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]

	set cmd {$::InsertionTarget insert insert [list \u03B2]}
	set bn [format ".ipaec.r%dc%d" $vdfric $labial]
	button $bn -text \u03B2  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced bilabial fricative"]

	set cmd {$::InsertionTarget insert insert [list v]}
	set bn [format ".ipaec.r%dc%d" $vdfric $labiodental]
	button $bn -text "v" -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced labiodental fricative"]

	set cmd {$::InsertionTarget insert insert [list "\u00F0"]}
	set bn [format ".ipaec.r%dc%d" $vdfric $dental]
	button $bn -text "\u00F0"    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced dental fricative"]

	set cmd {$::InsertionTarget insert insert [list "z"]}
	set bn [format ".ipaec.r%dc%d" $vdfric $alveolar]
	button $bn -text "z"   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced alveolar fricative"]

	set cmd {$::InsertionTarget insert insert [list \u0292]}
	set bn [format ".ipaec.r%dc%d" $vdfric $postalveolar]
	button $bn -text \u0292  -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u017E]}
	bind $bn <Enter> {ipaentry::cfzh}
	bind $bn <Leave> {ipaentry::crzh}
	bhcham $bn;
	balloonhelpd_for $bn [_ "voiced postalveolar fricative"]

	set cmd {$::InsertionTarget insert insert [list \u0290]}
	set bn [format ".ipaec.r%dc%d" $vdfric $retroflex]
	button $bn -text \u0290   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u1E93]}
	bind $bn <Enter> {ipaentry::cfzhr}
	bind $bn <Leave> {ipaentry::crzhr}
	bhcham $bn;
	balloonhelpd_for $bn [_ "voiced retroflex fricative"]

	set cmd {$::InsertionTarget insert insert [list \u029D]}
	set bn [format ".ipaec.r%dc%d" $vdfric $palatal]
	button $bn -text  \u029D  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced palatal fricative"]

	set cmd {$::InsertionTarget insert insert [list \u0263]}
	set bn [format ".ipaec.r%dc%d" $vdfric $velar]
	button $bn -text \u0263  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced velar fricative"]

	set cmd {$::InsertionTarget insert insert [list "\u0281"]}
	set bn [format ".ipaec.r%dc%d" $vdfric $uvular]
	button $bn -text "\u0281" -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced uvular fricative"]

	set cmd {$::InsertionTarget insert insert [list \u0295]}
	set bn [format ".ipaec.r%dc%d" $vdfric $pharyngeal]
	button $bn -text \u0295 -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced pharyngeal fricative"]

	set cmd {$::InsertionTarget insert insert [list \u02A2]}
	set bn [format ".ipaec.r%dc%d" $vdfric $epiglottal] 
	button $bn -text \u02A2    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced epiglottal fricative"]

	set cmd {$::InsertionTarget insert insert [list \u0266]}
	set bn [format ".ipaec.r%dc%d" $vdfric $glottal]
	button $bn -text \u0266    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced glottal fricative"]

	#trills
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $trill $poa] \
	       -text [_ "trills"] -anchor w   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	set cmd {$::InsertionTarget insert insert [list \u0299]}
	set bn [format ".ipaec.r%dc%d" $trill $labial]
	button  $bn -text \u0299      -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "bilabial trill"]

	label [format ".ipaec.r%dc%d" $trill $labiodental] -text " "   -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $trill $dental] -text " "   -padx $xp -pady $yp
	set cmd {$::InsertionTarget insert insert [list r]}
	set bn [format ".ipaec.r%dc%d" $trill $alveolar]
	button $bn -text "r"      -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "alveolar trill"]

	label [format ".ipaec.r%dc%d"  $trill $postalveolar] -text " "   -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d"  $trill $retroflex] -text " "   -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $trill $palatal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $trill $velar] -text " "    -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u0280]}
	set bn [format ".ipaec.r%dc%d" $trill $uvular]
	button $bn -text \u0280    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "uvular trill"]

	label [format ".ipaec.r%dc%d" $trill $pharyngeal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $trill $epiglottal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $trill $glottal] -text " "    -padx $xp -pady $yp

	#taps and flaps
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $tap $poa] \
	       -text [_ "taps/flaps"] -anchor w   -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	label [format ".ipaec.r%dc%d" $tap $labial] -text " "      -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $tap $labiodental] -text " "   -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $tap $dental] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u027E]}
	set bn [format ".ipaec.r%dc%d" $tap $alveolar]
	button $bn -text \u027E -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "uvular trill"]

	label [format ".ipaec.r%dc%d"  $tap $postalveolar] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u027D]}
	set bn [format ".ipaec.r%dc%d"  $tap $retroflex];
	button $bn -text \u027D   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u1E5B]}
	bind $bn <Enter> {ipaentry::cfflapr}
	bind $bn <Leave> {ipaentry::crflapr}
	bhcham $bn;
	balloonhelpd_for $bn [_ "retroflex tap"]

	label [format ".ipaec.r%dc%d" $tap $palatal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $tap $velar] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $tap $uvular] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $tap $pharyngeal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $tap $epiglottal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $tap $glottal] -text " "    -padx $xp -pady $yp

	#approximants
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $approx $poa] \
	       -text [_ "approximants"] -anchor w \
	       -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	label [format ".ipaec.r%dc%d" $approx $labial] -text " "      -padx $xp -pady $yp
	set cmd {$::InsertionTarget insert insert [list \u028B]}
	set bn [format ".ipaec.r%dc%d" $approx $labiodental]
	button $bn -text \u028B   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "labiodental approximant"]

	label [format ".ipaec.r%dc%d" $approx $dental] -text " "   -padx $xp -pady $yp
	set cmd {$::InsertionTarget insert insert [list \u0279]}
	set bn [format ".ipaec.r%dc%d" $approx $alveolar]
	button $bn -text  \u0279 -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "alveolar approximant"]

	label [format ".ipaec.r%dc%d"  $approx $postalveolar] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u027B]}
	set bn [format ".ipaec.r%dc%d"  $approx $retroflex]
	button $bn -text \u027B   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u1E5B]}
	bind $bn <Enter> {ipaentry::cfrr}
	bind $bn <Leave> {ipaentry::crrr}
	bhcham $bn;
	balloonhelpd_for $bn [_ "retroflex approximant"]

	set cmd {$::InsertionTarget insert insert [list "j"]}
	set bn [format ".ipaec.r%dc%d" $approx $palatal]
	button $bn -text "j"    -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list "y"]}
	bind $bn <Enter> {ipaentry::cfyod}
	bind $bn <Leave> {ipaentry::cryod}
	bhcham $bn;
	balloonhelpd_for $bn [_ "palatal approximant"]

	set cmd {$::InsertionTarget insert insert [list \u0270]}
	set bn [format ".ipaec.r%dc%d" $approx $velar]
	button $bn  -text \u0270    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "velar approximant"]

	label [format ".ipaec.r%dc%d" $approx $uvular] -text " "  \
	    -padx $xp -pady $yp -bg $spcolor
	label [format ".ipaec.r%dc%d" $approx $pharyngeal] -text " "  \
	    -padx $xp -pady $yp -bg $spcolor

	#label [format ".ipaec.r%dc%d" $approx $epiglottal] -text " "  \
	    -padx $xp -pady $yp -bg $spcolor
	#label [format ".ipaec.r%dc%d" $approx $glottal] -text " "   \
	    -padx $xp -pady $yp -bg $spcolor

	#lateral approximants
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $latapprox $poa] \
	       -text [_ "lateral approximants"] -anchor w \
	       -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	label [format ".ipaec.r%dc%d" $latapprox $labial] -text " "      -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $latapprox $labiodental] -text " "   -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $latapprox $dental] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list "l"]}
	set bn [format ".ipaec.r%dc%d" $latapprox $alveolar]
	button $bn -text "l"    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "alveolar lateral approximant"]

	label [format ".ipaec.r%dc%d"  $latapprox $postalveolar] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u026D]}
	set bn [format ".ipaec.r%dc%d"  $latapprox $retroflex]
	button $bn  -text \u026D   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u1E37]}
	bind $bn <Enter> {ipaentry::cflr}
	bind $bn <Leave> {ipaentry::crlr}
	bhcham $bn;
	balloonhelpd_for $bn [_ "retroflex lateral approximant"]

	set cmd {$::InsertionTarget insert insert [list \u028E]}
	set bn [format ".ipaec.r%dc%d" $latapprox $palatal]
	button $bn -text \u028E    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "palatal lateral approximant"]

	set cmd {$::InsertionTarget insert insert [list \u029F]}
	set bn [format ".ipaec.r%dc%d" $latapprox $velar]
	button $bn -text \u029F    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "velar lateral approximant"]

	label [format ".ipaec.r%dc%d" $latapprox $uvular] -text " "  \
	    -padx $xp -pady $yp -bg $spcolor
	#label [format ".ipaec.r%dc%d" $latapprox $pharyngeal] -text " "  \
	    -padx $xp -pady $yp -bg $spcolor
	#label [format ".ipaec.r%dc%d" $latapprox $epiglottal] -text " "  \
	    -padx $xp -pady $yp
	#label [format ".ipaec.r%dc%d" $latapprox $glottal] -text " "  \
	    -padx $xp -pady $yp

	#voiced implosives
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $vdimplosive $poa] \
	       -text [_ "voiced implosives"] -anchor w \
	       -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]

	set cmd {$::InsertionTarget insert insert [list \u0253]}
	set bn [format ".ipaec.r%dc%d" $vdimplosive $labial]
	button $bn -text \u0253 -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced bilabial implosive"]

	label [format ".ipaec.r%dc%d" $vdimplosive $labiodental] -text " " \
	    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $vdimplosive $dental] -text " "  \
	    -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u0257]}
	set bn [format ".ipaec.r%dc%d" $vdimplosive $alveolar]
	button $bn -text \u0257   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced alveolar implosive"]

	label [format ".ipaec.r%dc%d"  $vdimplosive $postalveolar] -text " " \
	    -padx $xp -pady $yp

	#Not officially recognized by IPA yet.
	set cmd {$::InsertionTarget insert insert [list \u1D91]}
	set bn [format ".ipaec.r%dc%d"  $vdimplosive $retroflex]
	button $bn -text \u1D91  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced retroflex implosive"]

	set cmd {$::InsertionTarget insert insert [list \u0284]}
	set bn [format ".ipaec.r%dc%d" $vdimplosive $palatal]
	button $bn -text \u0284  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced palatal implosive"]

	set cmd {$::InsertionTarget insert insert [list \u0260]}
	set bn [format ".ipaec.r%dc%d" $vdimplosive $velar]
	button $bn -text \u0260 -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced velar implosive"]

	set cmd {$::InsertionTarget insert insert [list \u029B]}
	set bn [format ".ipaec.r%dc%d" $vdimplosive $uvular]
	button $bn -text \u029B    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced uvular implosive"]

	label [format ".ipaec.r%dc%d" $vdimplosive $pharyngeal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $vdimplosive $epiglottal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $vdimplosive $glottal] -text " "    -padx $xp -pady $yp

	#clicks
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $click $poa] \
	       -text [_ "clicks"] -anchor w  -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]

	set cmd {$::InsertionTarget insert insert [list \u0298]}
	set bn [format ".ipaec.r%dc%d" $click $labial]
	button $bn -text \u0298      -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "labial click"]

	label [format ".ipaec.r%dc%d" $click $labiodental] -text " "   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list \u01C0]}
	set bn [format ".ipaec.r%dc%d" $click $dental]
	button $bn -text \u01C0   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "dental click"]

	set cmd {$::InsertionTarget insert insert [list \u01C2]}
	set bn [format ".ipaec.r%dc%d" $click $alveolar]
	button $bn -text \u01C2   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "alveolar click"]

	set cmd {$::InsertionTarget insert insert [list \u01C3]}
	set bn [format ".ipaec.r%dc%d"  $click $postalveolar]
	button $bn -text \u01C3 \
	    -padx $xp -pady $yp  -command $cmd
	balloonhelpd_for $bn [_ "postalveolar click"]

	label [format ".ipaec.r%dc%d"  $click $retroflex] -text " "   -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $click $palatal] -text " "  -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $click $velar] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $click $uvular] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $click $pharyngeal] -text " "    -padx $xp -pady $yp
	label [format ".ipaec.r%dc%d" $click $epiglottal] -text " "    -padx $xp -pady $yp
	set cmd {BackDelete $::InsertionTarget}
	set bn [format ".ipaec.r%dc%d" $click $glottal];
	button $bn -text [_ "Delete"]  -padx $xp -pady $yp -command $cmd -background "\#E0D0FF";
	set DeleteButton $bn;


	#Voiceless affricates
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $vlaffric $poa] \
	       -text [_ "voiceless affricates"] -anchor w -padx $xp -pady $yp \
	       -bg $::ColorSpecs(IPAHeadings,Background)]

	set cmd {$::InsertionTarget insert insert [list p\u03C6]}
	set bn [format ".ipaec.r%dc%d" $vlaffric $labial]
	button $bn -text "p\u03C6"      -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless bilabial affricate"]

	label [format ".ipaec.r%dc%d" $vlaffric $labiodental] -text "" -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list t\u03B8]}
	set bn [format ".ipaec.r%dc%d" $vlaffric $dental]
	button $bn -text "t\u03B8"   -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless dental affricate"]

	set cmd {$::InsertionTarget insert insert [list "ts"]}
	set bn [format ".ipaec.r%dc%d" $vlaffric $alveolar]
	button $bn -text "ts"    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless alveolar affricate"]

	set cmd {$::InsertionTarget insert insert [list t\u0283]}
	set bn [format ".ipaec.r%dc%d"  $vlaffric $postalveolar]
	button $bn -text "t\u0283"   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u010D]}
	bind $bn <Enter> {ipaentry::cfch}
	bind $bn <Leave> {ipaentry::crch}
	bhcham $bn;
	balloonhelpd_for $bn [_ "voiceless postalveolar affricate"]

	set cmd {$::InsertionTarget insert insert [list \u0288\u0282]}
	set bn [format ".ipaec.r%dc%d"  $vlaffric $retroflex]
	button $bn -text \u0288\u0282   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u1E6D\u1E63]}
	bind $bn <Enter> {ipaentry::cfchr}
	bind $bn <Leave> {ipaentry::crchr}
	bhcham $bn;
	balloonhelpd_for $bn [_ "voiceless retroflex affricate"]

	set cmd {$::InsertionTarget insert insert [list t\u0255]}
	set bn [format ".ipaec.r%dc%d" $vlaffric $palatal]
	button $bn -text t\u0255 -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless palatal affricate"]

	set cmd {$::InsertionTarget insert insert [list "kx"]}
	set bn [format ".ipaec.r%dc%d" $vlaffric $velar]
	button $bn -text "kx"    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless velar affricate"]

	set cmd {$::InsertionTarget insert insert [list "q\u03C7"]}
	set bn [format ".ipaec.r%dc%d" $vlaffric $uvular]
	button $bn -text "q\u03C7"    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiceless uvular affricate"]

	label [format ".ipaec.r%dc%d" $vlaffric $pharyngeal] -text "" \
	    -padx $xp -pady $yp -bg $spcolor
	label [format ".ipaec.r%dc%d" $vlaffric $epiglottal] -text "" \
	    -padx $xp -pady $yp -bg $spcolor
	label [format ".ipaec.r%dc%d" $vlaffric $glottal] -text "" \
	    -padx $xp -pady $yp -bg $spcolor

	#Voiced affricate
	lappend IPAECRowLabelList [label [format ".ipaec.r%dc%d" $vdaffric $poa] \
	       -text [_ "voiced affricates"] -anchor w -padx $xp -pady $yp \
	       -bg $::ColorSpecs(IPAHeadings,Background)]

	set cmd {$::InsertionTarget insert insert [list b\u03B2]}
	set bn [format ".ipaec.r%dc%d" $vdaffric $labial]
	button $bn -text b\u03B2      -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced bilabial affricate"]

	label [format ".ipaec.r%dc%d" $vdaffric $labiodental] -text ""   -padx $xp -pady $yp

	set cmd {$::InsertionTarget insert insert [list "d\u00F0"]}
	set bn [format ".ipaec.r%dc%d" $vdaffric $dental]
	button $bn -text "d\u00F0"    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced dental affricate"]

	set cmd {$::InsertionTarget insert insert [list "dz"]}
	set bn [format ".ipaec.r%dc%d" $vdaffric $alveolar]
	button  $bn -text "dz"  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced alveolar affricate"]

	set cmd {$::InsertionTarget insert insert [list d\u0292]}
	set bn [format ".ipaec.r%dc%d" $vdaffric $postalveolar]
	button $bn -text d\u0292  -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u01C6]}
	bind $bn <Enter> {ipaentry::cfdj}
	bind $bn <Leave> {ipaentry::crdj}
	bhcham $bn;
	balloonhelpd_for $bn [_ "voiced postalveolar affricate"]

	set cmd {$::InsertionTarget insert insert [list \u0256\u0290]}
	set bn [format ".ipaec.r%dc%d" $vdaffric $retroflex]
	button $bn -text \u0256\u0290   -padx $xp -pady $yp -command $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u1E0D\u1E93]}
	bind $bn <Enter> {ipaentry::cfdjr}
	bind $bn <Leave> {ipaentry::crdjr}
	bhcham $bn;
	balloonhelpd_for $bn [_ "voiced retroflex affricate"]

	set cmd {$::InsertionTarget insert insert [list d\u029D]}
	set bn [format ".ipaec.r%dc%d" $vdaffric $palatal]
	button $bn -text  d\u029D  -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced palatal affricate"]

	set cmd {$::InsertionTarget insert insert [list g\u0263]}
	set bn [format ".ipaec.r%dc%d" $vdaffric $velar]
	button $bn -text g\u0263    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced velar affricate"]

	set cmd {$::InsertionTarget insert insert [list "\u0262\u0281"]}
	set bn [format ".ipaec.r%dc%d" $vdaffric $uvular]
	button $bn -text "\u0262\u0281"    -padx $xp -pady $yp -command $cmd
	balloonhelpd_for $bn [_ "voiced uvular affricate"]

	label [format ".ipaec.r%dc%d" $vdaffric $pharyngeal] -text "" \
	    -padx $xp -pady $yp -bg $spcolor
	#label [format ".ipaec.r%dc%d" $vdaffric $epiglottal] -text "" \
	    -padx $xp -pady $yp -bg $spcolor
	#label [format ".ipaec.r%dc%d" $vdaffric $glottal] -text ""   \
	    -padx $xp -pady $yp -bg $spcolor

	set cmd {$::InsertionTarget insert insert [list "\u028D"]}
	button .ipaec.r13c10 -text \u028D -padx $xp -pady $yp -command $cmd
	balloonhelpd_for .ipaec.r13c10  [_ "Voiceless labio-velar fricative"]
	set cmd {$::InsertionTarget insert insert [list "\u0265"]}
	button .ipaec.r11c11 -text \u0265 -padx $xp -pady $yp -command $cmd
	balloonhelpd_for .ipaec.r11c11  [_ "Voiced labio-palatal approximant"]
	set cmd {$::InsertionTarget insert insert [list "\u0077"]}
	button .ipaec.r11c12 -text \u0077 -padx $xp -pady $yp -command $cmd
	balloonhelpd_for .ipaec.r11c12  [_ "Voiced labio-velar approximant"]
	set cmd {$::InsertionTarget insert insert [list "\u01C1"]}
	button .ipaec.r12c11 -text \u01C1 -padx $xp -pady $yp -command $cmd
	set cmd {$::InsertionTarget insert insert [list "\u02A0"]}
	button .ipaec.r12c12 -text \u02A0 -padx $xp -pady $yp -command $cmd
	set cmd {$::InsertionTarget insert insert [list "\u026C"]}
	button .ipaec.r13c11 -text \u026C -padx $xp -pady $yp -command $cmd
	set cmd {$::InsertionTarget insert insert [list "\u026E"]}
	button .ipaec.r13c12 -text \u026E -padx $xp -pady $yp -command $cmd

	for {set row 0} {$row <= $lastrow} {incr row} {
	    set line [list];
	    for {set col 0} {$col <= $lastcolumn} {incr col} {
		set cell [format ".ipaec.r%dc%d" $row $col]
		lappend line $cell
		if {[string equal [winfo class $cell] "Label"]} {
		    balloonhelp_for $cell  [_ "Left click to insert standard characters.\nRight click to insert alternative characters."]
		}
	    }
	    eval grid $line -sticky news;
	}
	balloonhelpd_for .ipaec.r12c11  [_ "Lateral click"]
	balloonhelpd_for .ipaec.r12c12  [_ "Voiceless uvular implosive"]
	balloonhelpd_for .ipaec.r13c11  [_ "Voiceless lateral fricative"]
	balloonhelpd_for .ipaec.r13c12  [_ "Voiced lateral fricative"]
	bhsp [format ".ipaec.r%dc%d" $latapprox $uvular]
	bhsp [format ".ipaec.r%dc%d" $approx $uvular]
	bhsp [format ".ipaec.r%dc%d" $approx $pharyngeal]
	bhsp [format ".ipaec.r%dc%d" $vlaffric $pharyngeal]
	bhsp [format ".ipaec.r%dc%d" $vlaffric $epiglottal]
	bhsp [format ".ipaec.r%dc%d" $vlaffric $glottal]
	bhsp [format ".ipaec.r%dc%d" $vdaffric $pharyngeal]
	balloonhelpd_for $DeleteButton [_ "No, there isn't a glottal click  called \"Delete\".\nThis is so that you can correct mistakes while using\nthe mouse, without having to go back to the keyboard."]
	after idle {
	    update idletasks
	    raise .ipaec;
	}
	if {!$DisplayConsonantChartColumnLabelsP} {UnpackConsonantColumnLabels}
	if {!$DisplayConsonantChartRowLabelsP} {UnpackConsonantRowLabels}
    }

    set row 0;
    variable frontness $row;
    incr row;
    variable close $row;
    incr row;
    variable closeclosemid $row;
    incr row;
    variable closemid $row;
    incr row;
    variable midmid $row;
    incr row;
    variable openmid $row;
    incr row;
    variable openopenmid $row;
    incr row;
    variable open $row;
    variable lastvrow $row;

    set col 0;
    variable height $col; 
    incr col;
    variable fronturd $col;
    incr col;
    variable frontrnd $col;
    incr col;
    variable centurd $col;
    incr col;
    variable centrnd $col;
    incr col;
    variable backurd $col;
    incr col;
    variable backrnd $col;
    variable lastvcolumn $col;

    proc vry {} {
	variable close
	variable frontrnd
	eval [list [format ".ipaev.r%dc%d" $close $frontrnd] configure -text "y"];
	}
    
    proc vfy {} {
	variable close
	variable frontrnd
	eval [list [format ".ipaev.r%dc%d" $close $frontrnd] configure -text "\u00FC"];
	}

    proc vrphi {} {
	variable frontrnd;
	variable closemid
	eval [list [format ".ipaev.r%dc%d" $closemid $frontrnd] configure -text "\u00F8"];
    }
    
    proc vfphi {} {
	variable frontrnd;
	variable closemid
	eval [list [format ".ipaev.r%dc%d" $closemid $frontrnd] configure -text "o\u0308"];
    }

    proc vroe {} {
	variable frontrnd;
	variable openmid
	eval [list [format ".ipaev.r%dc%d" $openmid $frontrnd] configure -text "\u0153"];
    }

    proc vfoe {} {
	variable frontrnd;
	variable openmid
	eval [list [format ".ipaev.r%dc%d" $openmid $frontrnd] configure -text "\u0254\0308"];
    }


    proc PopupIPAEntryV {} {
	variable frontness
	variable close
	variable closeclosemid
	variable closemid
	variable openmid
	variable midmid
	variable openopenmid
	variable open
	variable lastvrow

	variable height
	variable fronturd
	variable frontrnd
	variable centurd
	variable centrnd
	variable backurd
	variable backrnd
	variable lastvcolumn

	variable IPAEVColumnLabelList
	variable IPAEVRowLabelList
	global DisplayVowelChartColumnLabelsP
	global DisplayVowelChartRowLabelsP

	set xp 2;
	set yp 3;
	toplevel .ipaev -borderwidth 3
	wm title .ipaev [_ "Vowel Symbols"]
	BindKeys .ipaev;
	bind .ipaev <Destroy> {set ::IPAVIsDisplayedP 0}
	set DownMsg [_ "Display IPA Vowel Chart"];
	set UpMsg   [_ "Remove IPA Vowel Chart"];
	#Column headers
	set tmp [label [format ".ipaev.r%dc%d" $height $frontness] \
	     -text [_ "IPA\nVowels"]  -padx $xp -pady $yp -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAEVColumnLabelList $tmp;
	lappend IPAEVRowLabelList $tmp;
	lappend IPAEVColumnLabelList [label [format ".ipaev.r%dc%d" $height $fronturd] \
	     -text [_ "Front\nUnrounded"]  -padx $xp -pady $yp \
     	     -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAEVColumnLabelList [label [format ".ipaev.r%dc%d" $height $frontrnd] \
	     -text [_ "Front\nRounded"]  -padx $xp -pady $yp \
  	     -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAEVColumnLabelList [label [format ".ipaev.r%dc%d" $height $centurd] \
	     -text [_ "Central\nUnrounded"]  -padx $xp -pady $yp \
	     -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAEVColumnLabelList [label [format ".ipaev.r%dc%d" $height $centrnd] \
	     -text [_ "Central\nRounded"]  -padx $xp -pady $yp \
   	     -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAEVColumnLabelList [label [format ".ipaev.r%dc%d" $height $backurd] \
	     -text [_ "Back\nUnrounded"]  -padx $xp -pady $yp \
  	     -bg $::ColorSpecs(IPAHeadings,Background)]
	lappend IPAEVColumnLabelList [label [format ".ipaev.r%dc%d" $height $backrnd] \
	     -text [_ "Back\nRounded"]  -padx $xp -pady $yp \
  	     -bg $::ColorSpecs(IPAHeadings,Background)]


	#Close vowels
	lappend IPAEVRowLabelList [label [format ".ipaev.r%dc%d" $close $frontness] \
	   -text [_ "Close"] -anchor w  -padx $xp -pady $yp \
  	   -bg $::ColorSpecs(IPAHeadings,Background)]

	set cmd {$::InsertionTarget insert insert [list i]}
	set bn [format ".ipaev.r%dc%d"  $close $fronturd]
	button $bn -text "i"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close front unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list y]}
	set bn  [format ".ipaev.r%dc%d"  $close $frontrnd]
	button $bn -text "y"   -padx $xp -pady $yp -command  $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u00FC]}
	bind $bn <Enter> {ipaentry::vfy}
	bind $bn <Leave> {ipaentry::vry}
	balloonhelpd_for $bn [_ "close front rounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u0268]}
	set bn [format ".ipaev.r%dc%d"  $close $centurd]
	button  $bn -text "\u0268"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close central unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u0289]}
	set bn [format ".ipaev.r%dc%d"  $close $centrnd]
	button $bn -text "\u0289"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close central rounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u0268]}
	set bn [format ".ipaev.r%dc%d"  $close $backurd]
	button $bn -text "\u0268"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close back unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list u]}
	set bn [format ".ipaev.r%dc%d"  $close $backrnd]
	button $bn -text "u"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close back rounded vowel"]

	# Close close mid vowels
	lappend IPAEVRowLabelList [label [format ".ipaev.r%dc%d" $closeclosemid $frontness] \
	     -text [_ "Close Close Mid"] -anchor w  -padx $xp -pady $yp \
	  -bg $::ColorSpecs(IPAHeadings,Background)]
	set cmd {$::InsertionTarget insert insert [list I]}
	set bn [format ".ipaev.r%dc%d"  $closeclosemid $fronturd]
	button $bn -text "I"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close close mid front unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list Y]}
	set bn [format ".ipaev.r%dc%d"  $closeclosemid $frontrnd]
	button $bn -text "Y"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close close mid front rounded vowel"]

	set bn [format ".ipaev.r%dc%d"  $closeclosemid $centurd]
	label $bn -text ""   -padx $xp -pady $yp
	bhcham $bn

	set cmd {$::InsertionTarget insert insert [list \u028A]}
	set bn [format ".ipaev.r%dc%d"  $closeclosemid $centrnd]
	button $bn  -text "\u028A"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close close mid central rounded vowel"]

	set bn [format ".ipaev.r%dc%d"  $closeclosemid $backurd]
	label $bn -text ""   -padx $xp -pady $yp
	bhcham $bn

	set bn [format ".ipaev.r%dc%d"  $closeclosemid $backrnd]
	label $bn -text ""   -padx $xp -pady $yp
	bhcham $bn

	# Close mid vowels
	lappend IPAEVRowLabelList [label [format ".ipaev.r%dc%d" $closemid $frontness] \
	     -text [_ "Close Mid"] -anchor w  -padx $xp -pady $yp \
	  -bg $::ColorSpecs(IPAHeadings,Background)]
	set cmd {$::InsertionTarget insert insert [list e]}
	set bn [format ".ipaev.r%dc%d"  $closemid $fronturd]
	button $bn -text "e"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close mid front unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u00F8]}
	set bn [format ".ipaev.r%dc%d"  $closemid $frontrnd]
	button $bn -text "\u00F8"   -padx $xp -pady $yp -command  $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list o\u0308]}
	bind $bn <Enter> {ipaentry::vfphi}
	bind $bn <Leave> {ipaentry::vrphi}
	balloonhelpd_for $bn [_ "close mid front rounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u0258]}
	set bn [format ".ipaev.r%dc%d"  $closemid $centurd]
	button $bn -text "\u0258"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close mid central unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u0275]}
	set bn [format ".ipaev.r%dc%d"  $closemid $centrnd]
	button $bn  -text "\u0275"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close mid central rounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u0264]}
	set bn [format ".ipaev.r%dc%d"  $closemid $backurd]
	button $bn  -text "\u0264"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close mid back unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list o]}
	set bn [format ".ipaev.r%dc%d"  $closemid $backrnd]
	button $bn -text "o"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "close mid back rounded vowel"]

	# Mid mid vowels
	lappend IPAEVRowLabelList [label [format ".ipaev.r%dc%d" $midmid $frontness] \
	     -text [_ "Mid Mid"] -anchor w  -padx $xp -pady $yp \
	  -bg $::ColorSpecs(IPAHeadings,Background)]
	label [format ".ipaev.r%dc%d"  $midmid $fronturd] \
	     -text ""   -padx $xp -pady $yp
	label [format ".ipaev.r%dc%d"  $midmid $frontrnd] \
	     -text ""   -padx $xp -pady $yp
	set cmd {$::InsertionTarget insert insert [list \u0259]}
	set bn [format ".ipaev.r%dc%d"  $midmid $centurd]
	button $bn -text "\u0259"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "mid mid central unrounded vowel"]

	set cmd {BackDelete $::InsertionTarget}
	set bn [format ".ipaev.r%dc%d" $midmid $centrnd];
	button $bn -text [_ "Delete"]  \
	     -padx $xp -pady $yp -command $cmd -background "\#E0D0FF";
	set DeleteButton $bn;
	label [format ".ipaev.r%dc%d"  $midmid $backurd] -text ""   -padx $xp -pady $yp
	label [format ".ipaev.r%dc%d"  $midmid $backrnd] -text ""   -padx $xp -pady $yp

	# Open mid vowels
	lappend IPAEVRowLabelList [label [format ".ipaev.r%dc%d" $openmid $frontness] \
	     -text [_ "Open Mid"] -anchor w  -padx $xp -pady $yp \
  	     -bg $::ColorSpecs(IPAHeadings,Background)]
	set cmd {$::InsertionTarget insert insert [list \u025B]}
	set bn [format ".ipaev.r%dc%d"  $openmid $fronturd]
	button $bn -text \u025B   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open mid front unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u0153]}
	set bn [format ".ipaev.r%dc%d"  $openmid $frontrnd]
	button $bn -text "\u0153"   -padx $xp -pady $yp -command  $cmd
	bind $bn <<B3>> {$::InsertionTarget insert insert [list \u0254\u0308]}
	bind $bn <Enter> {ipaentry::vfoe}
	bind $bn <Leave> {ipaentry::vroe}
	balloonhelpd_for $bn [_ "open mid front rounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u025C]}
	set bn [format ".ipaev.r%dc%d"  $openmid $centurd]
	button $bn -text "\u025C"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open mid central unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u025E]}
	set bn [format ".ipaev.r%dc%d"  $openmid $centrnd]
	button $bn -text "\u025E"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open mid central rounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u028C]}
	set bn [format ".ipaev.r%dc%d"  $openmid $backurd]
	button $bn -text "\u028C"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open mid back unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u0254]}
	set bn [format ".ipaev.r%dc%d"  $openmid $backrnd]
	button $bn -text "\u0254"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open mid back rounded vowel"]

	# Open open mid vowels
	lappend IPAEVRowLabelList [label [format ".ipaev.r%dc%d" $openopenmid $frontness] \
	     -text [_ "Open Open Mid"] -anchor w  -padx $xp -pady $yp \
  	     -bg $::ColorSpecs(IPAHeadings,Background)]
	set cmd {$::InsertionTarget insert insert [list \u00E6]}
	set bn [format ".ipaev.r%dc%d"  $openopenmid $fronturd]
	button $bn -text \u00E6   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open open mid front unrounded vowel"]

	label [format ".ipaev.r%dc%d"  $openopenmid $frontrnd] -text ""   -padx $xp -pady $yp
	set cmd {$::InsertionTarget insert insert [list \u0250]}
	set bn [format ".ipaev.r%dc%d"  $openopenmid $centurd]
	button $bn  -text "\u0250"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open open mid central unrounded vowel"]

	label [format ".ipaev.r%dc%d"  $openopenmid $centrnd] \
		     -text ""   -padx $xp -pady $yp
	label [format ".ipaev.r%dc%d"  $openopenmid $backurd] \
	     -text ""   -padx $xp -pady $yp
	label [format ".ipaev.r%dc%d"  $openopenmid $backrnd] \
	     -text ""   -padx $xp -pady $yp

	# Open  vowels
	lappend IPAEVRowLabelList [label [format ".ipaev.r%dc%d" $open $frontness] \
	   -text [_ "Open"] -anchor w  -padx $xp -pady $yp \
	   -bg $::ColorSpecs(IPAHeadings,Background)]
	set cmd {$::InsertionTarget insert insert [list a]}
	set bn [format ".ipaev.r%dc%d"  $open $fronturd]
	button $bn -text "a"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open front unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u0276]}
	set bn [format ".ipaev.r%dc%d"  $open $frontrnd]
	button $bn -text "\u0276"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open front rounded vowel"]

	label [format ".ipaev.r%dc%d"  $open $centurd] \
	     -text ""   -padx $xp -pady $yp
	label [format ".ipaev.r%dc%d"  $open $centrnd] \
	     -text ""   -padx $xp -pady $yp
	set cmd {$::InsertionTarget insert insert [list \u0251]}
	set bn [format ".ipaev.r%dc%d"  $open $backurd]
	button $bn -text "\u0251"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open back unrounded vowel"]

	set cmd {$::InsertionTarget insert insert [list \u0252]}
	set bn [format ".ipaev.r%dc%d"  $open  $backrnd]
	button $bn -text "\u0252"   -padx $xp -pady $yp -command  $cmd
	balloonhelpd_for $bn [_ "open back rounded vowel"]

	for {set row 0} {$row <= $lastvrow} {incr row} {
	    set line [list];
	    for {set col 0} {$col <= $lastvcolumn} {incr col} {
		set cell [format ".ipaev.r%dc%d" $row $col]
		lappend line $cell
		if {$::TwoCaseP} {
		    balloonhelp_for $cell  \
			[_ "Left click to insert standard characters.\n\
Right click to insert alternative characters."]
		}
	    }
	    eval grid $line -sticky news;
	}
	balloonhelpd_for $DeleteButton [_ "No, there isn't a mid-mid central rounded vowel called \"Delete\".\nThis is so that you can correct mistakes while using\nthe mouse, without having to go back to the keyboard."]
	if {!$DisplayVowelChartColumnLabelsP} {UnpackVowelColumnLabels}
	if {!$DisplayVowelChartRowLabelsP} {UnpackVowelRowLabels}
    }

#Rearrange into functional groups, e.g. tone marks, vowel quality marks,
#etc. Separate IPA and non-IPA.

    proc PopupIPAEntryD {} {
	set PerRow 10;
	set BaseChar "o";
	set xp 2;
	set yp 3;
	toplevel .ipaed -borderwidth 3
	wm title .ipaed [_ "Phonetic Diacritics"]
	BindKeys .ipaed
	set DownMsg [_ "Display IPA Diacritic Chart"];
	set UpMsg   [_ "Remove IPA Diacritic Chart"];
	bind .ipaed <Destroy> \
	    "set ::IPADIsDisplayedP 0;$::CEM entryconfigure $::ToggleIPADIndex -label \"$DownMsg\""
	bind .ipaed <Unmap> \
	    "set ::IPADIsDisplayedP 0;$::CEM entryconfigure $::ToggleIPADIndex -label \"$DownMsg\""
	bind .ipaed <Map> \
	    "set ::IPADIsDisplayedP 1;$::CEM entryconfigure $::ToggleIPADIndex -label \"$UpMsg\""
	array set Diacritics [list\
				  0  {"\u02D0" "long"}\
				  1  {"\u02D1" "half long"}\
				  2  {"\u0303" "nasalized"}\
				  3  {"\u0324" "breathy voice"}\
				  4  {"\u0325" "voiceless"}\
				  5  {"\u032C" "voiced"}\
				  6  {"\u031A" "unreleased"}\
				  7  {"\u031C" "lower/open variety of vowel"}\
				  8  {"\u031D" "raised/closed variety of vowel"}\
				  9  {"\u031E" "lower/open variety of vowel"}\
				  10  {"\u031F" "advanced/fronted"}\
				  11  {"\u0320" "retracted/backed"}\
				  12  {"\u0321" "palatalized"}\
				  13  {"\u0322" "retroflex"}\
				  14  {"\u0323" "closer variety of vowel/retroflex"}\
				  15  {"\u0329" "syllabic"}\
				  16  {"\u032A" "dental"}\
				  17  {"\u032B" "labialized"}\
				  18  {"\u0330" "creaky voice"}\
				  19  {"\u0334" "velarized/pharyngealized"}\
				  20  {"\u0346" "dentolabial"}\
				  21  {"\u0347" "alveolar"}\
				  22  {"\u0348" "strong articulation"}\
				  23  {"\u0349" "weak articulation"}\
				  24  {"\u02CA" "high tone"}\
				  25  {"\u02CB" "low tone"}\
				  26  {"\u0302" "falling tone"}\
				  27  {"\u0304" "long"}\
				  28  {"\u0306" "short"}\
				  29  {"\u0308" "non-canonical backness"}\
				  30  {"\u02CC" "secondary stress"}\
				  31  {"\u02C8" "primary stress/downstep"}\
				  32  {"\u02B8" "palatalized"}\
				  33  {"\u02DE" "rhotacized"}\
				  34  {"\u0328" "nasalized"}\
				  35  {"\u034A" "denasal"}\
				  36  {"\u034B" "nasal escape"}\
				  37  {"\u034C" "velopharyngeal friction"}\
				  38  {"\u034D" "labial spreading"}\
				  39  {"\u034E" "whistled"}
				 ];

	set DiacriticCnt [llength [array names Diacritics]];
	set Rows [expr ceil(double($DiacriticCnt)/double($PerRow))]
	set Total [expr $PerRow * $Rows]
	#Generate buttons with blank labels for empty padding slots
	for {set k 0} {$k < $Total} {incr k} {
	    set row [expr $k/$PerRow]
	    set col [expr $k%$PerRow]
	    if {[info exist Diacritics($k)]} {
		button .ipaed.r${row}c${col} -text "$BaseChar[lindex $Diacritics($k) 0]"\
		    -padx $xp -pady $yp\
		    -command "\$::InsertionTarget insert insert  [lindex $Diacritics($k) 0]"
		balloonhelpd_for .ipaed.r${row}c${col} [_ [lindex $Diacritics($k) 1]]  
	    } else {
		label .ipaed.r${row}c${col} -text "";
	    }
	    set LastRow $row;
	    set LastCol $col;
	}
	#Lay the buttons and labels out in a grid.
	for {set row 0} {$row <= $LastRow} {incr row} {
	    set line [list];
	    for {set col 0} {$col <= $LastCol} {incr col} {
		set cell [format ".ipaed.r%dc%d" $row $col]
		lappend line $cell
	    }
	    eval grid $line -sticky news;
	}
    }

#Accented letters
    proc PopupIPAEntryA {} {
	set xp 3;
	set yp 3;
	toplevel .ipaea -borderwidth 4
	wm title .ipaea [_ "Accented Letters"]
	BindKeys .ipaea
	bind .ipaea <Destroy> {set ::IPAAIsDisplayedP 0}
	set DownMsg [_ "Display Accented Letter Chart"]
	set UpMsg   [_ "Remove Accented Letter Chart"]
	set AccentedLetters [list \
				 {"\u00E0" "a with grave" "\u00C0"}\
				 {"\u00E1" "a with acute" "\u00C1"}\
				 {"\u00E2" "a with circumflex" "\u00C2"}\
				 {"\u00E3" "a with tilde" "\u00C3"}\
				 {"\u00E4" "a with diaresis" "\u00C4"}\
				 {"\u00E5" "a with ring above" "\u00C5"}\
				 {"\u0101" "a with macron" "\u0100"}\
				 {"\u0103" "a with breve" "\u0102"}\
				 {"\u0105" "a with ogonek" "\u0104"}\
				 {"\u01CE" "a with caron" "A\u030C"}\
				 {"\u2C65" "a with stroke" "\u023A"}\
				 {"\u0227" "a with dot above" "\u0226"}\
				 {"\u1EA1" "a with dot below" "\u1EA0"}\
				 {"\u0201" "a with double grave" "\u0200"}\
				 {"\u0203" "a with inverted breve" "\u0202"}\
				 {"\u01DF" "a with diaresis and macron" "\u01DE"}\
				 {"\u01E1" "a with dot above and macron" "\u01E0"}\
				 {"\u01FB" "a with ring above and acute" "\u01FA"}\
				 {"\u01E3" "ash with macron" "\u01E2"}\
				 {"\u01FD" "ash with acute" "\u01FC"}\
				 {"\u0180" "b with stroke" "\u0243"}\
				 {"\u0183" "b with topbar" "\u0182"}\
				 {"\u1E03" "b with dot above" "\u1E02"}\
				 {"\u1E05" "b with dot below" "\u1E04"}\
				 {"\u1E07" "b with line below" "\u1E06"}\
				 {"\u0188" "c with hook" "\u0187"}\
				 {"\u0107" "c with acute" "\u0106"}\
				 {"\u0109" "c with circumflex" "\u0108"}\
				 {"\u010B" "c with dot above" "\u010A"}\
				 {"\u00E7" "c with cedilla" "\u00C7"}\
				 {"\u1E09" "c with cedilla and acute" "\u1E08"}\
				 {"\u010D" "c with caron" "\u010C"}\
				 {"\u023C" "c with stroke" "\u023B"}\
				 {"\u018C" "d with topbar" "\u018B"}\
				 {"\u010F" "d with caron" "\u010E"}\
				 {"\u0111" "d with stroke" "\u0110"}\
				 {"\u0221" "d with curl" "\uFFFD"}\
				 {"\u1E0B" "d with dot above" "\u1E0A"}\
				 {"\u1E0D" "d with dot below" "\u1E0C"}\
				 {"\u1E0F" "d with line below" "\u1E0E"}\
				 {"\u00E8" "e with grave" "\u00C8"}\
				 {"\u00E9" "e with acute" "\u00C9"}\
				 {"\u00EA" "e with circumflex" "\u00CA"}\
				 {"\u00EB" "e with diaresis" "\u00CB"}\
				 {"\u0113" "e with macron" "\u0112"}\
				 {"\u0115" "e with breve" "\u0114"}\
				 {"\u0117" "e with dot above" "\u0116"}\
				 {"\u1EB9" "e with dot below" "\u1EB8"}\
				 {"\u0119" "e with ogonek" "\u0118"}\
				 {"\u011B" "e with caron" "\u011A"}\
				 {"\u0247" "e with stroke" "\u0246"}\
				 {"\u0229" "e with cedilla" "\u0228"}\
				 {"\u0205" "e with double grave" "\u0204"}\
				 {"\u0207" "e with inverted breve" "\u0206"}\
				 {"\u01F5" "g with acute" "\u01F4"}\
				 {"\u011D" "g with circumflex" "\u011C"}\
				 {"\u011F" "g with breve" "\u011E"}\
				 {"\u0121" "g with dot above" "\u0000"}\
				 {"\u0123" "g with cedilla" "\u0122"}\
				 {"\u01E5" "g with stroke" "\u01E4"}\
				 {"\u01E7" "g with caron" "\u01E6"}\
				 {"\u021F" "h with caron" "\u021E"}\
				 {"\u0125" "h with circumflex" "\u0124"}\
				 {"\u0127" "h with stroke" "\u0126"}\
				 {"\u1E25" "h with dot below" "\u1E24"}\
				 {"\u00EC" "i with grave" "\u00CC"}\
				 {"\u00ED" "i with acute" "\u00CD"}\
				 {"\u00EE" "i with circumflex" "\u00CE"}\
				 {"\u00EF" "i with diaresis" "\u00CF"}\
				 {"\u0129" "i with tilde" "\u0128"}\
				 {"\u012B" "i with macron" "\u012A"}\
				 {"\u012D" "i with breve" "\u012C"}\
				 {"\u012F" "i with ogonek" "\u012E"}\
				 {"\u01D0" "i with caron" "\u01CF"}\
				 {"\u0209" "i with double grave" "\u0208"}\
				 {"\u020B" "i with inverted breve" "\u020A"}\
				 {"\u1ECB" "i with dot below" "\u1ECA"}\
				 {"\u0131" "dotless i" "\u0049"}\
				 {"\u0135" "j with circumflex" "\u0134"}\
				 {"\u01F0" "j with caron" "J\u030C"}\
				 {"\u0249" "j with stroke" "J\u0248"}\
				 {"\u01E9" "k with caron" "\u01E8"}\
				 {"\u0199" "k with hook" "\u0198"}\
				 {"\u0137" "k with cedilla " "\u0136"}\
				 {"\u1E33" "k with dot below" "\u1E32"}\
				 {"\u013A" "l with acute" "\u0139"}\
				 {"\u013C" "l with cedilla" "\u013B"}\
				 {"\u013E" "l with caron" "\u013D"}\
				 {"\u0140" "l with middle dot" "\u013F"}\
				 {"\u0142" "l with stroke" "\u0141"}\
				 {"\u019A" "l with bar" "\u023D"}\
				 {"\u0234" "l with curl" "\uFFFD"}\
				 {"\u1E37" "l with dot below" "\u1E36"}\
				 {"\u1E39" "l with dot below and macron" "\u01E38"}\
				 {"\u1E3B" "l with line below" "\u1E3A"}\
				 {"\u019B" "lambda with stroke" "\uFFFD"}\
				 {"\u1E3F" "m with acute" "\u1E3E"}\
				 {"\u1E43" "m with dot below" "\u1E42"}\
				 {"\u1E41" "m with dot above" "\u1E40"}\
				 {"\u0271" "m with hook" "\uFFFD"}\
				 {"\u0235" "n with a curl" "\uFFFD"}\
				 {"\u0146" "n with cedilla" "\u0145"}\
				 {"\u0148" "n with caron" "\u0147"}\
				 {"\u01F9" "n with grave" "\u01F8"}\
				 {"\u00F1" "n with tilde" "\u00D1"}\
				 {"\u019E" "n with long right leg" "\u0220"}\
				 {"\u0144" "n with acute" "\u0143"}\
				 {"\u1E45" "n with dot above" "\u1E44"}\
				 {"\u1E47" "n with dot below" "\u1E46"}\
				 {"\u1E49" "n with line below" "\u1E48"}\
				 {"\u00F2" "o with grave" "\u00D2"}\
				 {"\u00F3" "o with acute" "\uD3"}\
				 {"\u00F4" "o with circumflex" "\u00D4"}\
				 {"\u00F5" "o with tilde" "\u00D5"}\
				 {"\u00F6" "o with diaresis" "\u00D6"}\
				 {"\u00F8" "o with stroke" "\u00D8"}\
				 {"\u014D" "o with macron" "\u014C"}\
				 {"\u014F" "o with breve" "\u014E"}\
				 {"\u0151" "o with double acute" "\u0150"}\
				 {"\u01A1" "o with horn" "\u01A0"}\
				 {"\u01EB" "o with ogonek" "\u01EA"}\
				 {"\u01ED" "o with ogonek and macron" "\u01EC"}\
				 {"\u01D2" "o with caron" "\u01D1"}\
				 {"\u022B" "o with diaresis and macron" "\u022A"}\
				 {"\u022D" "o with tilde and macron" "\u022C"}\
				 {"\u022F" "o with dot above" "\u022E"}\
				 {"\u01FF" "o with stroke and acute" "\u01FE"}\
				 {"\u020D" "o with double grave" "\u020C"}\
				 {"\u020F" "o with inverted breve" "\u020E"}\
				 {"\u0231" "o with dot above and macron" "\u0230"}\
				 {"\u1ECD" "o with dot below" "\u1ECC"}\
				 {"\u0223" "ou" "\u0222"}\
			         {"\u01A5" "p with hook" "\u01A4"}\
				 {"\u0155" "r with acute" "\u0154"}\
				 {"\u0157" "r with cedilla" "\u0156"}\
				 {"\u0159" "r with caron" "\u0158"}\
				 {"\u024D" "r with stroke" "\u024C"}\
				 {"\u0211" "r with double grave" "\u0210"}\
				 {"\u0213" "r with inverted breve" "\u0214"}\
				 {"\u1E5B" "r with dot below" "\u1E5A"}\
				 {"\u027F" "reversed r with fishhook" "\uFFFD"}\
				 {"\u015B" "s with acute" "\u015A"}\
				 {"\u015D" "s with circumflex" "\u015C"}\
				 {"\u015F" "s with cedilla" "\u015E"}\
				 {"\u0161" "s with caron" "\u0160"}\
				 {"\u0219" "s with comma below" "\u0218"}\
				 {"\u1E63" "s with dot below" "\u1E62"}\
				 {"\u021B" "t with comma below" "\u021A"}\
				 {"\u01AB" "t with palatal hook" "\uFFFD"}\
				 {"\u01AD" "t with hook" "\u01AC"}\
				 {"\u0163" "t wwith cedilla" "\u0162"}\
				 {"\u0165" "t with caron" "\u0164"}\
				 {"\u0167" "t with stroke" "\u0166"}\
				 {"\u2C66" "t with diagonal stroke" "\u023E"}\
				 {"\u00F9" "u with grave" "\u00D9"}\
				 {"\u00FA" "u with acute" "\u00DA"}\
				 {"\u00FB" "u with circumflex" "\u00DB"}\
				 {"\u00FC" "u with diaresis" "\u00DC"}\
				 {"\u01D4" "u with caron" "\u01D3"}\
				 {"\u01D6" "u with diaresis and macron" "\u01D5"}\
				 {"\u01D8" "u with diaresis and acute" "\u01D7"}\
				 {"\u01DA" "u with diaresis and caron" "\u01D9"}\
				 {"\u01DC" "u with diaresis and grave" "\u01DB"}\
				 {"\u01B0" "u with horn" "\u01AF"}\
				 {"\u0169" "u with tilde" "\u0168"}\
				 {"\u016B" "u with macron" "\u016A"}\
				 {"\u016D" "u with breve" "\u016C"}\
				 {"\u016F" "u with ring above" "\u016E"}\
				 {"\u0171" "u with double acute" "\u0170"}\
				 {"\u0173" "u with ogonek" "\u0172"}\
				 {"\u0215" "u with double grave" "\u0214"}\
				 {"\u0217" "u with inverted breve" "\u0216"}\
				 {"\u1EE5" "u with dot below" "\u1EE4"}\
				 {"\u2C74" "v with curl" "\uFFFD"}\
				 {"\u0175" "w with circumflex" "\u0174"}\
				 {"\u01B4" "y with hook" "\u01B3"}\
				 {"\u00FD" "y with acute" "\u00DD"}\
				 {"\u00FF" "y with diaresis" "\u0278"}\
				 {"\u0233" "y with macron" "\u0232"}\
				 {"\u0177" "y with circumflex" "\u0176"}\
				 {"\u024F" "y with stroke" "\u024E"}\
				 {"\u017A" "z with acute" "\u0179"}\
				 {"\u017C" "z with dot above" "\u017B"}\
				 {"\u017E" "z with caron" "\u017D"}\
				 {"\u01B6" "z with stroke" "\u01B5"}\
				 {"\u0225" "z with hook" "\u0224"}\
				 {"\u0236" "t with curl" "\uFFFD"}\
				 {"\u01EF" "zh with caron" "\u01EE"}]

	if {$::UseNoGlyphsP} {
	    lappend AccentedLetters {"\u1D8D" "x with palatal hook" "X\u0321"}\
				 {"e\u0303" "e with tilde" "E\u0303"}\
				 {"\u1D6F" "m with middle tilde" "\uFFFD"}
	}
	
	#Sort by gloss
	set AccentedLetters [lsort -index 1 $AccentedLetters]

#Done through 0236

	set AccentedLetterCnt [llength $AccentedLetters];
	if {[info exists ::AccentedLettersPerRow]} {
	    set PerRow $::AccentedLettersPerRow
	} else {
	    set PerRow [expr int(1.3 * ceil(sqrt($AccentedLetterCnt)))]
	}
	set Rows [expr ceil(double($AccentedLetterCnt)/double($PerRow))]
	set Total [expr $PerRow * $Rows]
	#Generate buttons with blank labels for empty padding slots
	for {set k 0} {$k < $Total} {incr k} {
	    set row [expr $k/$PerRow]
	    set col [expr $k%$PerRow]
	    if {$k < $AccentedLetterCnt} {
		button .ipaea.r${row}c${col} -text "[lindex [lindex $AccentedLetters $k] 0]"\
		    -padx $xp -pady $yp\
		    -command "\$::InsertionTarget insert insert  [lindex [lindex $AccentedLetters $k] 0]"
		balloonhelpd_for .ipaea.r${row}c${col} [_ [lindex [lindex $AccentedLetters $k] 1] ]  
		set cap [lindex [lindex $AccentedLetters $k] 2]
		bind .ipaea.r${row}c${col} <<B3>> "\$::InsertionTarget insert insert $cap"
	    } else {
		label .ipaea.r${row}c${col} -text "";
	    }
	}
	set LastRow $row;
	set LastCol $col;
	set LastCell .ipaea.r${row}c${col}
	destroy $LastCell
	button $LastCell -image $::LeftArrowImage -command {BackDelete $::InsertionTarget}
	balloonhelpd_for $LastCell  [_ "Delete, so that you can correct mistakes while using\nthe mouse, without having to go back to the keyboard."]
	
	#Lay the buttons and labels out in a grid.
	for {set row 0} {$row <= $LastRow} {incr row} {
	    set line [list];
	    for {set col 0} {$col <= $LastCol} {incr col} {
		set cell [format ".ipaea.r%dc%d" $row $col]
		lappend line $cell
	    }
	    eval grid $line -sticky news;
	}
    }
}


set LeftArrowImage [image create photo -data {
R0lGODlhFAAUAIAAAAAAAL+/vyH5BAEAAAEALAAAAAAUABQAAAIqjI+py43gGIAxTVrNxXVz
54WTIopWGZ7oRq7X4o4wm2lvbX+ZjGv9/ysAADs=
}]

proc BackDelete {w} {
    if {[string equal [winfo class $w] "Text"]} {
	set Insert [$w index insert]
	set FirstHalf  [$w get 1.0 $Insert-1chars]
	set SecondHalf [string trimright [$w get insert end]]
	$w delete 1.0 end;
	$w insert 1.0 $FirstHalf$SecondHalf;
    } else {
	set delind [expr [$w index insert] -1];
	$w delete $delind;
    }
}

proc PopupCharEntryByCode {} {
    toplevel .charent -borderwidth 4 -relief raised
    BindKeys .charent;
    wm title .charent "Entry By Codepoint";
    after idle {
	update idletasks
	set xmax [winfo screenwidth .charent]
	set ymax [winfo screenheight .charent]
	set x0 [expr 1 * ($xmax -[winfo reqwidth .charent])/3];
	set y0 [expr 1 * ($ymax -[winfo reqheight .charent])/3];
	wm geometry .charent "+$x0+$y0";
    }
    label .charent.title -text [_ "Insert Character by Numerical Code"]
    frame .charent.ef;
    entry .charent.ef.ent -width 8 -font MainFont -relief flat -bg \#E0EEFF;
    label .charent.ef.prefix -text "0x" -font MainFont
    pack .charent.ef.prefix -side left  -expand 1 -fill x -anchor e
    pack .charent.ef.ent    -side right -expand 1 -fill x -anchor w
    button .charent.d  -text [_ "Dismiss"] -command {destroy .charent}
    button .charent.x  -text [_ "Delete"] -command [list BackDelete $::CharByCodeInsertionTarget]
    button .charent.i  -text [_ "Insert"] -command {InsertUnicode}
    pack .charent.title -side top
    pack .charent.ef -side top
    pack .charent.d -side left -expand 1 -fill both
    pack .charent.x -side left -expand 1 -fill both
    pack .charent.i -side right -expand 1 -fill both
    focus .charent.ef.ent;
    set DownMsg [_ "Display Widget for Entering Characters by Unicode Code"];
    set UpMsg   [_ "Remove Widget for Entering Characters by Unicode Code"];
    bind .charent <Destroy> \
	"set ::CharEntryByCodeIsDisplayedP 0;$::CEM entryconfigure $::ToggleCharEntryByCodeIndex -label \"$DownMsg\""
    bind .charent <Unmap> \
	"set ::CharEntryByCodeIsDisplayedP 0;$::CEM entryconfigure $::ToggleCharEntryByCodeIndex -label \"$DownMsg\""
    bind .charent <Map> \
	"set ::CharEntryByCodeIsDisplayedP 1;$::CEM entryconfigure $::ToggleCharEntryByCodeIndex -label \"$UpMsg\""
    bind .charent.ef.ent <Destroy> {set ::InsertionTarget $::REG}
    bind .charent.ef.ent <Return> {InsertUnicode}
    bind .charent.ef.ent <Control-k> {.charent.ef.ent delete 0 end;break}


    set charentbh  [_ "Enter a character by its Unicode code, as a sequence of four hexadecimal digits.\nFor example, you may specify \'\u0298\', the International Phonetic Alphabet\nsymbol for the bilabial click, as 0298, and the Chinese character \'\u4E39\' \"egg\" as 4E39.\nDo not type the prefix 0x shown to the left of the entry box.\nIt is entered for you automatically. Return inserts the current character.\nControl-k erases the current character code."]
    balloonhelp_for .charent $charentbh
    balloonhelp_for .charent.title $charentbh
    balloonhelp_for .charent.ef.ent $charentbh
    balloonhelp_for .charent.i $charentbh
    balloonhelp_for .charent.d $charentbh
    balloonhelp_for .charent.x $charentbh
    set ::CharEntryByCodeIsDisplayedP 1;
}

#Get entry from popup, validate it, and insert it into the insertion target.
proc InsertUnicode {} {
    ClearMessageWindow;
    set str [.charent.ef.ent get];
    if {[string length $str] == 0} {
	ShowMessage [_ "The empty string is not a valid Unicode codepoint"]
	return ;
    }
    #Validate
    set BadValueP 0;
    #Make sure all digits are hex and that prefix is appropriate.
    if {[regexp {[[:xdigit:]]{4,4}} $str] == 0} {
	ShowMessage [_ "$str is not a well-formed hexadecimal Unicode value"]
	return;
    }
    set str [format "0x%s" $str]
    if {[scan $str "%x" num] < 1} {
	ShowMessage [format [_ "Ill-formed code %s"] $str]
	return;
    }

    #Reject illegal codepoints.
    if {$num  >  65535} {
	ShowMessage [_ "Tcl/Tk may not support codepoints outside the BMP (Plane 0)."]
    }
    set BadValueP 0;
    set BadRanges [list\
  	       0x0750 0x077F\
	       0x07C0 0x08FF\
	       0x1380 0x139F\
	       0x18B0 0x18FF\
	       0x1980 0x19DF\
	       0x1A00 0x1CFF\
	       0x1D80 0x1DFF\
	       0x2C00 0x2E7F\
	       0x2FE0 0x2FEF\
	       0x31C0 0x31EF\
	       0x9FB0 0x9FFF\
	       0xA4D0 0xABFF\
	       0xD7B0 0xD7FF\
	       0xD800 0xDBFF\
	       0xDC00 0xDFFF\
	       0xFE10 0xFE1F\
	       0x10140 0x102FF\
	       0x104B0 0x107FF\
	       0x10840 0x1CFFF\
	       0x1D200 0x1D2FF\
	       0x1D360 0x1D3FF\
	       0x1D800 0x1FFFF\
	       0x2A6E0 0x2F7FF\
	       0x2FAB0 0x2FFFF\
	       0xE0080 0xE00FF\
	       0xE01F0 0xEFFFF\
	       0xFFFFE 0xFFFFF];

    for {set k 0} {$k < [llength $BadRanges]} {incr k} {
	if { ($num >= [lindex $BadRanges [expr 2 * $k]]) &&\
		 ($num <= [lindex $BadRanges [expr (2 * $k) + 1]])} { 
	    set BadValueP 1;
	    break; 
	}
    }
    if {$BadValueP} {
	ShowMessage [format [_ "%s is not a valid Unicode codepoint"] $str]
	return;
    }
    if {$num >= 1114110} {
	ShowMessage [_ "Warning: codepoints above 0x10FFFD have not been assigned as of version 4.0."]
    }

    #Insert
    $::CharByCodeInsertionTarget insert insert [format "%c" $num]
}


proc IndicateIPACUp {} {
	$::CEM entryconfigure $::ToggleIPACIndex \
	    -label [_ "Remove IPA Consonant Chart"];
	set ::IPACIsDisplayedP 1;
}

proc IndicateIPACDown {} {
	$::CEM entryconfigure $::ToggleIPACIndex \
	    -label [_ "Display IPA Consonant Chart"];
	set ::IPACIsDisplayedP 0;
}

proc ToggleIPAC {} {
    global IPACIsDisplayedP;
    global m;

    if { $IPACIsDisplayedP == 0} {
	if {[winfo exists .ipaec]} {
	    wm deiconify .ipaec;
	} else { 
	    ipaentry::PopupIPAEntryC;
	}
	IndicateIPACUp;
    } else {
	wm iconify .ipaec;
	IndicateIPACDown;
    }
}

proc IndicateIPAVUp {} {
	$::CEM entryconfigure $::ToggleIPAVIndex \
	    -label [_ "Remove IPA Vowel Chart"];
	set ::IPAVIsDisplayedP 1;
}

proc IndicateIPAVDown {} {
	$::CEM entryconfigure $::ToggleIPAVIndex \
	    -label [_ "Display IPA Vowel Chart"];
	set ::IPAVIsDisplayedP 0;
}

proc ToggleIPAV {} {
    global IPAVIsDisplayedP;
    global m;

    if { $IPAVIsDisplayedP == 0} {
	if {[winfo exists .ipaev]} {
	    wm deiconify .ipaev;
	} else { 
	    ipaentry::PopupIPAEntryV;
	}
	$::CEM entryconfigure $::ToggleIPAVIndex -label [_ "Remove IPA Vowel Chart"];
	set IPAVIsDisplayedP 1;
    } else {
	wm iconify .ipaev;
	$::CEM entryconfigure $::ToggleIPAVIndex -label [_ "Display IPA Vowel Chart"];
	set IPAVIsDisplayedP 0;
    }
}

proc IndicateIPADUp {} {
	$::CEM entryconfigure $::ToggleIPADIndex \
	    -label [_ "Remove IPA Diacritic Chart"];
	set ::IPADIsDisplayedP 1;
}

proc IndicateIPADDown {} {
	$::CEM entryconfigure $::ToggleIPADIndex \
	    -label [_ "Display IPA Diacritic Chart"];
	set ::IPADIsDisplayedP 0;
}

proc ToggleIPAD {} {
    global IPADIsDisplayedP;
    global m;

    if { $IPADIsDisplayedP == 0} {
	if {[winfo exists .ipaed]} {
	    wm deiconify .ipaed;
	} else { 
	    ipaentry::PopupIPAEntryD;
	}
	IndicateIPADUp
    } else {
	wm iconify .ipaed;
	IndicateIPADDown;
    }
}

proc IndicateIPAAUp {} {
	$::CEM entryconfigure $::ToggleIPAAIndex \
	    -label [_ "Remove Accented Letter Chart"];
	set ::IPAAIsDisplayedP 1;
}

proc IndicateIPAADown {} {
	$::CEM entryconfigure $::ToggleIPAAIndex \
	    -label [_ "Display Accented Letter Chart"];
	set ::IPAAIsDisplayedP 0;
}

proc ToggleIPAA {} {
    global m;

    if { $::IPAAIsDisplayedP == 0} {
	if {[winfo exists .ipaea]} {
	    wm deiconify .ipaea;
	} else { 
	    ipaentry::PopupIPAEntryA;
	}
	IndicateIPAAUp;
    } else {
	wm iconify .ipaea;
	IndicateIPAADown;
    }
}




proc IndicateCharEntryByCodeUp {} {
	$::CEM entryconfigure $::ToggleCharEntryByCodeIndex \
	    -label [_ "Remove Widget for Entering Characters by Unicode Code"];
	set ::CharEntryByCodeIsDisplayedP 1;
}

proc IndicateCharEntryByCodeDown {} {
	$::CEM entryconfigure $::ToggleCharEntryByCodeIndex \
	    -label [_ "Display Widget for Entering Characters by Unicode Code"];
	set ::CharEntryByCodeIsDisplayedP 0;
}

proc ToggleCharEntryByCode {} {
    global CharEntryByCodeIsDisplayedP;
    global m;

    if { $CharEntryByCodeIsDisplayedP == 0} {
	if {[winfo exists .charent]} {
	    wm deiconify .charent;
	    raise .charent;
	} else { 
	    PopupCharEntryByCode;
	}
	IndicateCharEntryByCodeUp;
    } else {
	wm iconify .charent;
	IndicateCharEntryByCodeDown;
    }
}

proc SetTestDataEncoding {s} {
    if {[lsearch -exact [encoding names] $s] >= 0} {
	set ::Pars(TestDataEncoding) $s;
    } else {
	ShowMessage [_ "The encoding $s is not recognized."]
    }
}

proc SetComparisonDataEncoding {s} {
    if {[lsearch -exact [encoding names] $s] >= 0} {
	set ::Pars(ComparisonDataEncoding) $s;
    } else {
	ShowMessage [_ "The encoding $s is not recognized."]
    }
}

proc SetResultEncoding {s} {
    if {[lsearch -exact [encoding names] $s] >= 0} {
	set ::Pars(ResultEncoding) $s;
    } else {
	ShowMessage [_ "The encoding $s is not recognized."]
    }
}

proc SetPaletteHeightLimit {s} {
    if {![string is integer -strict $s]} {return}
    if {$s < 3} {return}
    if {$s > 50} {return}
    set ::PaletteHeightLimit $s
}

proc SetDisplayConsonantChartColumnLabelsP {b} {
    global DisplayConsonantChartColumnLabelsP
    set DisplayConsonantChartColumnLabelsP [Boolean $b];
}

proc SetDisplayConsonantChartRowLabelsP {b} {
    global DisplayConsonantChartRowLabelsP
    set DisplayConsonantChartRowLabelsP [Boolean $b];
}

proc SetDisplayVowelChartColumnLabelsP {b} {
    global DisplayVowelChartColumnLabelsP
    set DisplayVowelChartColumnLabelsP [Boolean $b]
}

proc SetDisplayVowelChartRowLabelsP {b} {
    global DisplayVowelChartRowLabelsP
    set DisplayVowelChartRowLabelsP [Boolean $b]
}

proc ControlDisplayConsonantChartColumnLabels {} {
    if {$::DisplayConsonantChartColumnLabelsP} {
	ipaentry::PackConsonantColumnLabels;
    } else {
	ipaentry::UnpackConsonantColumnLabels;
    }
}

proc ControlDisplayConsonantChartRowLabels {} {
    if {$::DisplayConsonantChartRowLabelsP} {
	ipaentry::PackConsonantRowLabels;
    } else {
	ipaentry::UnpackConsonantRowLabels;
    }
}

proc ControlDisplayVowelChartColumnLabels {} {
    if {$::DisplayVowelChartColumnLabelsP} {
	ipaentry::PackVowelColumnLabels;
    } else {
	ipaentry::UnpackVowelColumnLabels;
    }
}

proc ControlDisplayVowelChartRowLabels {} {
    if {$::DisplayVowelChartRowLabelsP} {
	ipaentry::PackVowelRowLabels;
    } else {
	ipaentry::UnpackVowelRowLabels;
    }
}

proc SetAccentedLetterColumns {s} {
    if {$s > 1} {
	set ::AccentedLettersPerRow $s;
    }
}

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

#File     -> LineList	LoadCustomCharacterChart
#LineList -> CDEF	DefineCustomCharacterChart
#CDEF     -> Popup      PopupSpecialPalette

proc ReadCustomCharacterChartPopup {args} {
    if {[llength $args]} {
	set dl [LoadCustomCharacterChart [lindex $args 0]]
    } else {
	set dl [LoadCustomCharacterChart];
    }
    PopupSpecialPalette [DefineCustomCharacterChart $dl]
}

proc DefineCustomCharacterChartPopup {ll} {
    PopupSpecialPalette [DefineCustomCharacterChart $ll];
}

#Returns a linelist.
proc LoadCustomCharacterChart {args} {
    if {[llength $args]} {
	set fn [lindex $args 0]
    } else {
	set fn [tk_getOpenFile -title [_ "Load Custom Character Chart"]];
	if {[string equal $fn ""]} {
	    ShowMessage [_ "File selection cancelled."];
	    return ;
	}
    }
    if { [catch {open $fn "r"} fhd ] != 0} {
	ShowMessage [format [_ "Unable to open character chart definition file %s."] \
			 [MinimizeFileName $fn]];
	return ;
    }
    set LineCnt 0
    while { [gets $fhd line] > 0} {
	lappend Lines $line;
	incr LineCnt
    }
    close $fhd;
    if {$LineCnt < 1} {
	ShowMessage [_ "File %s is empty" $fn]
	return "";
    }
    ShowMessage [format [_ "Loaded custom character chart definition from %s."] [MinimizeFileName $fn]]
    return $Lines;
}


#This procedure takes a list of lines defining a custom
#character entry chart, which may have been read from a
#standalone file or may be an instant list in an
#init file, and generates an internal character chart
#definition, which it stores. It does not actualy
#create a display
proc DefineCustomCharacterChart {LineList {fn NONE}} {
    #The first line is special. It contains meta-information:
    #the title, the desired number of buttons per row,
    #and the proposed font family and size. Only the
    #title is obligatory.
    set line [lindex $LineList 0]
    set flds [split $line "|"]
    set FieldCnt [llength $flds];
    set Title [lindex $flds 0];
    #The remaining lines contain pairs of code sequences and glosses.
    set cd [list];
    set LineList [lrange $LineList 1 end]
    foreach line $LineList {
	set f [split $line "|"];
	set gloss [lindex $f 1];
	set c [string trim [lindex $f 0] \"];
	set cf [split $c];
	set str "\{\"";
	foreach n $cf {
	    append str [format "%s" $n]
	}
	append str "\""
	append str [format " \"%s\"\}" $gloss]
	lappend cd $str;
    }
    set info [list [join $cd]]
    if {$FieldCnt > 1} {
	lappend info [lindex $flds 1];	# Columns
    }
    if {$FieldCnt > 2} {
	lappend info [lindex $flds 2];	# Font family
    }
    if {$FieldCnt > 3} {
	lappend info [lindex $flds 3];	# Font size
    }
    if {![string equal $fn NONE]} {	# File name
	lappend info $fn;
    }
    set ::SpecialCharacterPalette($Title) $info;
    $::CEM add command -label $Title -command "PopupSpecialPalette $Title";
    incr ::CharacterEntryMenuItems;
    return $Title;
}

#Creates a popup chart from a stored definition.
set SccCnt 0;
proc PopupSpecialPalette {Title} {
    set name [format ".scc%d" $::SccCnt] 
    if {[info exists ::SpecialCharacterPalette($Title,WidgetName)]} {
	set w $::SpecialCharacterPalette($Title,WidgetName);
	if {[winfo exists $w]} {
	    wm deiconify $w;
	    raise $w;
	    return ;
	}
    }
    set cdefs [lindex $::SpecialCharacterPalette($Title) 0];
    set Items [llength $::SpecialCharacterPalette($Title)];
    if {$Items > 1} {
	set PerRow [lindex $::SpecialCharacterPalette($Title) 1];
    } else {
	set PerRow 5;
    }
    if {$Items > 2} {
	set FontFamily [lindex $::SpecialCharacterPalette($Title) 2];
    } else {
	set FontFamily $::FontInfo(CharacterEntryFont,family)
    }
    if {$Items > 3} {
	set FontSize [lindex $::SpecialCharacterPalette($Title) 3];
    } else {
	set FontSize $::FontInfo(CharacterEntryFont,size);
    }
    incr ::SccCnt;
    set xp 3;
    set yp 3;
    toplevel $name -borderwidth 4
    set ::SpecialCharacterPalette($Title,WidgetName) $name; 
    wm title $name $Title
    iwidgets::scrolledframe $name.sf -vscrollmode dynamic -hscrollmode dynamic \
	-height 180 -width 250
    set tf [$name.sf childsite]
    pack $name.sf -expand 1 -fill both
    BindKeys $name
    set msg [_ "Left click to insert the lower-case character.\nRight click to insert the upper-case character."]
    balloonhelp_for $name.sf $msg
    bind [$name.sf component vertsb] <<B3>> \
	"ScrollbarMoveBigIncrement [$name.sf component vertsb] 0.20 %x %y"
    set CdefCnt [llength $cdefs];
    set Rows [expr int(ceil(double($CdefCnt)/double($PerRow)))]
    set Total [expr $PerRow * $Rows]
    if {$CdefCnt == $Total} {
	incr Rows;
	set Total [expr $PerRow * $Rows]
    }
    set fontname [string trimleft $name .]Font
    font create $fontname -family $FontFamily -size $FontSize
    for {set k 0} {$k < $Total} {incr k} {
	set row [expr $k/$PerRow]
	set col [expr $k%$PerRow]
	if {$k < $CdefCnt} {
	    set csalt "";
	    set entry [lindex $cdefs $k];
	    set chstr [lindex $entry 0];
	    set gloss [lindex $entry 1];
	    set chstrParts [split $chstr ":"];
	    if {[llength $chstrParts] > 1} {
		set cs    [lindex $chstrParts 0];
		set csalt [lindex $chstrParts 1];
	    } else {
		set cs [lindex $chstr 0];
	    }
	    button $tf.r${row}c${col} -text $cs\
		-padx $xp -pady $yp -font $fontname\
		-command "\$::InsertionTarget insert insert $cs"
	    if {![string equal $csalt ""]} {
		bind $tf.r${row}c${col} <<B3>> "\$::InsertionTarget insert insert $csalt"
	    }
	    balloonhelpd_for $tf.r${row}c${col} $gloss;
	} else {
	    set ln $tf.r${row}c${col};
	    #Generate buttons with blank labels for empty padding slots
	    label $ln  -text "";
	}
    }
    set LastRow $row;
    set LastCol $col;
    set LastCell $tf.r${row}c${col}
    destroy $LastCell
    button $LastCell -image $::LeftArrowImage -command {BackDelete $::InsertionTarget}
    balloonhelpd_for $LastCell  [_ "Delete, so that you can correct mistakes while using\nthe mouse, without having to go back to the keyboard."]
    
    #Lay the buttons and labels out in a grid.
    for {set row 0} {$row <= $LastRow} {incr row} {
	set line [list];
	for {set col 0} {$col <= $LastCol} {incr col} {
	    set cell [format "%s.r%dc%d" $tf $row $col]
	    lappend line $cell
	}
	eval grid $line -sticky news;
    }
    return $name;
}


proc ExecuteRegexp {} {
    global OutputOnlyChangedLinesP;
    global InData;
    global Program;
    global program;
    global InterfaceLocale;
    global ExecCmd;
    global InputDataFromWindowP;
    global RegexpResult;
    global PipeP;
    global TempOutputFile;
    global errorCode;
    global DoSubstitutionsP;
    global PreviousActualRegexp;
    global Features;
    global UserClassesEnabledP;

    if {$::TestingFeaturesP} {
	ShowMessage [_ "Execution is impossible until feature testing is complete."]
	return ;
    }
    ClearMessageWindow;
    $::OUT configure -state normal
    $::OUT delete 1.0 end;

    #Get the data from the window if in edit mode
    if {$InputDataFromWindowP} {
	set InData [$::IND get 1.0 end];
    }
    if {$InData == ""} {
	ShowMessage [_ "There is no test data on which to run the regular expression!"];
#	return;
    }
    #The next bit is a little complicated because we trigger regexp execution
    #on carriage return, resulting in the potential presence of more than one
    #line in the regexp window.
    #First we get the whole contents of the regexp window.
    set Regexp [$::REG get];
    #Clear the regexp window.
    $::REG delete 0 end;
    #Now we parse out just the one line we want, which is the last one,
    set Regexp [string range $Regexp [expr [string last "\n" $Regexp] + 1] end];
    #And put that single line back into the regexp window.
    $::REG insert 0 [string trimright $Regexp];

    if {$Regexp == ""} {
	ShowMessage [_ "There is no regular expression to execute."];
	return;
    }

    if {[CheckModeCompatibility] == 0} {
	return ;
    }

    set Subexp ""; # This simplifies keeping the history list.
    if {$DoSubstitutionsP} { 
	set Subexp [$::SUB get];
	if {$Subexp == ""} {
	    ShowMessage [_ "There is no substitution pattern to execute."];
	    return ;
	}
    }
    hist::AddToHistoryList $Regexp $Subexp $program;
    hist::AddToHistoryFile $Regexp $Subexp $program;
    if {[winfo exists .hl]} {hist::ConstructHistory}
    WriteJournal [format [_ "Regular expression as entered: %s"] $Regexp];
    if {$UserClassesEnabledP} {
	if {[WarnAboutDelimiters $Regexp]} {
	    return ;
	}
	if {[FeaturesUnSetP $program $InterfaceLocale] == 0} {	
	    if {$Features(alttype,$program,$InterfaceLocale) > 0} {
		set Regexp [InstantiateUserClasses $Regexp $Features(alttype,$program,$InterfaceLocale)]
		if {[string length $Regexp] == 0} {
		    ShowMessage [_ "Regular Expression is null after user class instantiation."];
		    DisplayActualRegexp ""; # Clear actual regexp display.
		    return ;
		}
	    }
	}
    }
    WriteJournal [format [_ "Regular expression actually executed: %s"] $Regexp];
    if {$DoSubstitutionsP} {WriteJournal [format [_ "Substitution expression: %s"] $Subexp]}
    DisplayActualRegexp $Regexp;
    set PreviousActualRegexp $Regexp;
    WriteTestData $InData ;
    #Here is where we actually execute the regexp
    if {$DoSubstitutionsP} {
	set status [catch { $ExecCmd($program,sub) $Regexp $Subexp} RegexpResult];
	set Expressions [list $Regexp $Subexp];
    } else {
	set status [catch { $ExecCmd($program,match) $Regexp} RegexpResult];
	set Expressions [list $Regexp];
    }
    switch -exact -- $::ExecutionFlag {
	CommandInfo {
	    dmsg "Expressions = $Expressions"
	    dmsg "RegexpResult = $RegexpResult"
	    WriteExecutionInfo $Expressions $RegexpResult
	    set RegexpResult "";
	    return
	}
	CommandLine {
	    ShowMessage [lindex $RegexpResult 0];
	    set RegexpResult "";
	    return
	}
    }
    if { [expr ($status == 0) || [string equal $::errorCode NONE]]} {
	if {$DoSubstitutionsP} {
	    if {$OutputOnlyChangedLinesP} {
		if {[string equal $program sed]} {
		    set MatchCnt [CountLines $RegexpResult];
		} else {
		    set ResultList [GetChanges $InData $RegexpResult];
		    set MatchCnt [llength $ResultList];
		    set RegexpResult [join $ResultList "\n"];
		}
	    } else {
		set MatchCnt [CountChanges $InData $RegexpResult];
	    }
	} else {
	    set MatchCnt [CountLines $RegexpResult];
	}

	if {$DoSubstitutionsP} {
	    set action [_ "substitution"];
	} else {
	    set action [_ "regular expression"];
	}
	if {$MatchCnt > 1} {
	    set msg  [format [_ "Executed %1\$s using %2\$s - %3\$s matches"] \
			  $action $Program [DelimitNumber $MatchCnt]];

	} elseif {$MatchCnt == 1} {
	    set msg [format [_ "Executed %1\$s using %2\$s - 1 match"] $action $Program];
	} else {
	    set msg [format [_ "Executed %1\$s using %2\$s - 0 matches"] $action $Program];
	}
	ShowMessage $msg;
	resc::CacheResult $RegexpResult $program $Regexp $Subexp;
	if {[winfo exists .cacentry]} {
	    resc::UpdateCacheDisplay;
	}
        $::OUT insert end $RegexpResult;
	if {$PipeP} {
	    puts $RegexpResult;
	    flush stdout;
	}
	ShowDiffResult 1;
    } else {				# Command exited abnormally
	ShowMessage [format [_ "Executed regular expression using %s - 0 matches due to error exit"] $Program];
	puts stderr "Program exited abnormally";
	ExplicateErrorStatus;
    }
    $::OUT configure -state disabled
    if {$::AutoClearRegexpP} {
	ClearRegexp;
    }
}


#Figure out whether the program called sed is GNU sed, minised, or super sed or another.
proc WhichSed {} {
    if {[catch {exec sed --version} vinfo] != 0} {
	#We have encountered a sed other than GNU sed or super sed or something GNU-ish
	if {[catch {exec sed} vinfo] == 0} {
	    if {[string length $vinfo] == 0} {
		set ::ProgramInfo(sed,Which) minised;
		set ::ExecCmd(sed,match) ExecuteMatchMinised
		set ::ExecCmd(sed,sub) ExecuteSubMinised
	    } else {
		set ::ProgramInfo(sed,Which) bsdsed;
	    }
	}
    } else {
	set vl [lindex [split $vinfo "\n"] 0]
	set FirstVersionWord [string trim [lindex [split $vl] 0]]
	if {[string equal "super-sed" $FirstVersionWord]} {
	    set ::ProgramInfo(sed,Which) supersed;
	    set ::ExecCmd(sed,match) ExecuteMatchSsed
	    set ::ExecCmd(sed,sub) ExecuteSubSsed
	} elseif {[string equal "GNU" $FirstVersionWord]} {
	    set ::ProgramInfo(sed,Which) gnused;
	} else {
	    set ::ProgramInfo(sed,Which) othersed;
	}
    }
}

proc WhichAgrep {} {
    set tf [file join $::TempDir tf]
    catch [list exec agrep 2> $tf]
    if {[catch {open $tf "r"} tfh] != 0} {
	ShowMessage [_ "WhichAgrep: unable to open file in $::TempDir"]
	set ::ProgramInfo(agrep,TreAgrepP) -1 
	return ;
    }
    gets $tfh msg
    close $tfh
    set FirstWord [lindex [split $msg] 0]
    if {[string equal $FirstWord "Usage:"]} {
	set ::ProgramInfo(agrep,TreAgrepP) 1
	ShowMessage [_ "Detected TRE Agrep"]
    } elseif {[string equal $FirstWord "usage:"]} {
	set ::ProgramInfo(agrep,TreAgrepP) 0 
	ShowMessage [_ "Detected Wu-Manber Agrep"]
    } else {
	set ::ProgramInfo(agrep,TreAgrepP) -1 
	ShowMessage [_ "Failed to detect a recognizable version of agrep."]
    }
}

option add  *pcpAgrep.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpAgrep.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpAgrep.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpAgrep.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpAgrep.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpAgrep.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpAgrep.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;
set agrepErrLim 0
set agrepDelWei 0
set agrepInsWei 0
set agrepSubWei 0

proc PopupAgrepControls {} { 
    set w .pcpAgrep
    if {[winfo exist .pcpAgrep]} {
	if {![winfo ismapped .pcpAgrep]} {
	    wm deiconify .pcpAgrep;
	    raise .pcpAgrep
	} else {
	    wm iconify .pcpAgrep;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Agrep
    after idle {
	raise .pcpAgrep
	update idletasks
	set xmax [winfo screenwidth .pcpAgrep]
	set ymax [winfo screenheight .pcpAgrep]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpAgrep]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpAgrep]))];
	wm geometry .pcpAgrep "+$x0+$y0";
    }
    if {![info exist ::ProgramInfo(agrep,TreAgrepP)]} {
	WhichAgrep;
    }
    if {$::ProgramInfo(agrep,TreAgrepP)} {
	set which "TRE Agrep"
	set genmsg \
	    [_ "Set command-line options for agrep.\nNote that in TRE Agrep weights and maximum\ntotal cost can be set in-line for each group."]
    } elseif {$::ProgramInfo(agrep,TreAgrepP) == 0} {
	set which "Wu-Manber Agrep"
	set genmsg [_ "Set command-line options for agrep."]
    } else {
	ShowMessage [_ "Agrep is not available or is not in your path."]
	return ;
    }
    set title [format "%s\n%s" [_ "Agrep Settings"] $which]
    if {[FeaturesUnSetP agrep $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont
    frame $w.main
    checkbutton $w.main.caseInsensitiveckb -text [_ "Case Insensitive?"] \
	-variable agrepCasIns -onvalue 1 -offvalue 0
    checkbutton $w.main.bestResultckb -text [_ "Near Misses?"] \
	-variable agrepBesRes -onvalue 1 -offvalue 0

    frame $w.main.app -relief ridge -border 2
    label $w.main.app.tit -text [_ "Approximate Matching"] -relief raised -border 1
    iwidgets::spinint $w.main.app.tcost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Total Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpAgrep.main.app.tcost up} \
	-decrement {.pcpAgrep.main.app.tcost down} \
	-invalid {};# Prevents irritating flashing or ringing of bell
    iwidgets::spinint $w.main.app.icost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Insertion Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpAgrep.main.app.icost up} \
	-decrement {.pcpAgrep.main.app.icost down} \
	-invalid {};
    iwidgets::spinint $w.main.app.dcost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Deletion Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpAgrep.main.app.dcost up} \
	-decrement {.pcpAgrep.main.app.dcost down} \
	-invalid {};
    iwidgets::spinint $w.main.app.scost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Substitution Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpAgrep.main.app.scost up} \
	-decrement {.pcpAgrep.main.app.scost down} \
	-invalid {};
    pack $w.main.app.tit -side top  -expand 0 -fill none -pady 5 -padx 4 -ipadx 4 -ipady 2
    pack $w.main.app.tcost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    pack $w.main.app.icost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    pack $w.main.app.dcost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    pack $w.main.app.scost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    $w.main.app.tcost clear
    $w.main.app.tcost insert 0 $::ProgramInfo(agrep,TotalCost); 
    $w.main.app.icost clear
    $w.main.app.icost insert 0 $::ProgramInfo(agrep,InsertionCost); 
    $w.main.app.dcost clear
    $w.main.app.dcost insert 0 $::ProgramInfo(agrep,DeletionCost); 
    $w.main.app.scost clear
    $w.main.app.scost insert 0 $::ProgramInfo(agrep,SubstitutionCost); 
    pack $w.main.app                      -side bottom -expand 1 -fill both \
	-padx 3 -pady 5
    pack $w.main.caseInsensitiveckb -side top    -expand 1 -fill y \
	-padx 3 -pady 3 -anchor w
    pack $w.main.bestResultckb      -side top    -expand 1 -fill y \
	-padx 3 -pady 3 -anchor w

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveAgrepInfo
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 4
    pack $w.cntls.save -side right -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 10

    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    if { ([FeaturesUnSetP agrep $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,agrep,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.caseInsensitiveckb $msg
    set msg [_ "How many error units should each deletion cost?"]
    balloonhelp_for $w.main.app.dcost $msg
    set msg [_ "How many error units should each insertion cost?"]
    balloonhelp_for $w.main.app.icost $msg
    set msg [_ "How many error units should each substitution cost?"]
    balloonhelp_for $w.main.app.scost $msg
    set msg [_ "In the absence of exact matches, produce the best results?"]
    balloonhelp_for $w.main.bestResultckb $msg
    set msg [_ "What is the maximum total error cost permitted?"]
    balloonhelp_for $w.main.app.tcost $msg
}

proc SaveAgrepInfo {} { 
    set ::ProgramInfo(agrep,TotalCost) [.pcpAgrep.main.app.tcost get]
    set ::ProgramInfo(agrep,InsertionCost) [.pcpAgrep.main.app.icost get]
    set ::ProgramInfo(agrep,DeletionCost) [.pcpAgrep.main.app.dcost get]
    set ::ProgramInfo(agrep,SubstitutionCost) [.pcpAgrep.main.app.scost get]
    if {$::agrepCasIns} {
	set ::ProgramInfo(agrep,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(agrep,CaseInsensitiveP) 0
    }
    if {$::agrepBesRes} {
	set ::ProgramInfo(agrep,BestResults) 1
    } else {
	set ::ProgramInfo(agrep,BestResults) 0
    }
}

option add  *pcpCgrep.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpCgrep.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpCgrep.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpCgrep.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpCgrep.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpCgrep.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpCgrep.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;



option add  *pcpBash.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpBash.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpBash.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpBash.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpBash.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpBash.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpBash.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

option add  *pcpArena.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpArena.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpArena.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpArena.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpArena.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpArena.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpArena.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupArenaControls {} { 
    set w .pcpArena
    if {[winfo exist .pcpArena]} {
	if {![winfo ismapped .pcpArena]} {
	    wm deiconify .pcpArena;
	    raise .pcpArena
	} else {
	    wm iconify .pcpArena;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Arena
    after idle {
	raise .pcpArena
	update idletasks
	set xmax [winfo screenwidth .pcpArena]
	set ymax [winfo screenheight .pcpArena]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpArena]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpArena]))];
	wm geometry .pcpArena "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for Arena."]
    set title [_ "Arena Settings"]
    if {[FeaturesUnSetP arena $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.arenaCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable ::ProgramInfo(arena,CaseInsensitiveP) -onvalue 1 -offvalue 0
    checkbutton $w.main.arenaExpandedckb -text [_ "Verbose"] \
	-variable ::ProgramInfo(arena,VerboseP) -onvalue 1 -offvalue 0
    grid $w.main.arenaCaseInsensitiveckb -row 0 -column 0 -sticky w
    grid $w.main.arenaExpandedckb -row 1 -column 0 -sticky w

    frame $w.cntls
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.title $w.main $w.cntls -side top -expand 1 -fill both -pady 4 -padx 15 -ipadx 5
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    if { ([FeaturesUnSetP arena $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,arena,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.arenaCaseInsensitiveckb $msg;
    set msg [_ "Ignore whitespace and comments within regular expression?"]
    balloonhelp_for $w.main.arenaExpandedckb $msg;
}

proc PopupBashControls {} { 
    set w .pcpBash
    if {[winfo exist .pcpBash]} {
	if {![winfo ismapped .pcpBash]} {
	    wm deiconify .pcpBash;
	    raise .pcpBash
	} else {
	    wm iconify .pcpBash;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Bash
    after idle {
	raise .pcpBash
	update idletasks
	set xmax [winfo screenwidth .pcpBash]
	set ymax [winfo screenheight .pcpBash]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpBash]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpBash]))];
	wm geometry .pcpBash "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for bash."]
    set title [_ "Bash Settings"]
    if {[FeaturesUnSetP bash $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.bashCaseInsensitiveGlobPckb -text [_ "Case Insensitive Glob"] \
	-variable bashCaseInsensitiveGlobP -onvalue 1 -offvalue 0
    set ::bashCaseInsensitiveGlob $::ProgramInfo(bash,CaseInsensitiveGlobP)
    checkbutton $w.main.bashExtendedPckb -text [_ " Extended"] \
	-variable bashExtendedP -onvalue 1 -offvalue 0
    set ::bashExtendedP $::ProgramInfo(bash,ExtendedP)
    #Uncomment the following if we add support for matching in switches and conditions.
    if {0} {
	checkbutton $w.main.bashCaseInsensitiveMatchPckb -text [_ "Case Insensitive Match"] \
	    -variable bashCaseInsensitiveMatchP -onvalue 1 -offvalue 0
	set ::bashCaseInsensitiveMatch $::ProgramInfo(bash,CaseInsensitiveMatchP)
	grid $w.main.bashCaseInsensitiveMatchPckb -row 1 -column 0 -sticky w -pady 2
    }
    grid $w.main.bashCaseInsensitiveGlobPckb -row 0 -column 0 -sticky w -pady 2
    grid $w.main.bashExtendedPckb -row 2 -column 0 -sticky w -pady 2

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveBashInfo
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 4
    pack $w.cntls.save -side right -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 10
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    if { ([FeaturesUnSetP bash $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,bash,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.bashCaseInsensitiveGlobPckb $msg;
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Use extended regular expressions"]
    balloonhelp_for $w.main.bashExtendedPckb $msg;
    #   set msg [_ "Match without regard to case in case and conditional statements?"]
    #   balloonhelp_for $w.main.bashCaseInsensitiveMatchPckb $msg;
}

proc SaveBashInfo {} { 
    if {$::bashCaseInsensitiveGlobP} {
	set ::ProgramInfo(bash,CaseInsensitiveGlobP) 1
    } else {
	set ::ProgramInfo(bash,CaseInsensitiveGlobP) 0
    }
    #Uncomment the following if we add support for matching in switches and conditions.
    if {0} {
	if {$::bashCaseInsensitiveMatchP} {
	    set ::ProgramInfo(bash,CaseInsensitiveMatchP) 1
	} else {
	    set ::ProgramInfo(bash,CaseInsensitiveMatchP) 0
	}
    }
    if {$::bashExtendedP} {
	set ::ProgramInfo(bash,ExtendedP) 1
    } else {
	set ::ProgramInfo(bash,ExtendedP) 0
    }
}


option add  *pcpBusyBoxEgrep.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpBusyBoxEgrep.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpBusyBoxEgrep.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpBusyBoxEgrep.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpBusyBoxEgrep.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpBusyBoxEgrep.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpBusyBoxEgrep.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupBusyBoxEgrepControls {} { 
    set w .pcpBusyBoxEgrep
    if {[winfo exist .pcpBusyBoxEgrep]} {
	if {![winfo ismapped .pcpBusyBoxEgrep]} {
	    wm deiconify .pcpBusyBoxEgrep;
	    raise .pcpBusyBoxEgrep
	} else {
	    wm iconify .pcpBusyBoxEgrep;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w BusyBoxEgrep
    after idle {
	raise .pcpBusyBoxEgrep
	update idletasks
	set xmax [winfo screenwidth .pcpBusyBoxEgrep]
	set ymax [winfo screenheight .pcpBusyBoxEgrep]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpBusyBoxEgrep]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpBusyBoxEgrep]))];
	wm geometry .pcpBusyBoxEgrep "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for Busybox Egrep."]
    set title [_ "BusyBoxEgrep Settings"]
    if {[FeaturesUnSetP BusyBoxEgrep $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.busyboxegrepCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable ::ProgramInfo(BusyBoxEgrep,CaseInsensitiveP) -onvalue 1 -offvalue 0
    checkbutton $w.main.busyboxegrepComplementckb -text [_ "Complement"] \
	-variable ::ProgramInfo(BusyBoxEgrep,Complement) -onvalue 1 -offvalue 0
    grid $w.main.busyboxegrepCaseInsensitiveckb -row 0 -column 0 -sticky w -pady 2
    grid $w.main.busyboxegrepComplementckb -row 1 -column 0 -sticky w -pady 2

    frame $w.cntls
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 8
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 8
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 8
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    if { ([FeaturesUnSetP busyboxegrep $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,busyboxegrep,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.busyboxegrepCaseInsensitiveckb $msg;
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Emit only strings not matching the regular expression?"]
    balloonhelp_for $w.main.busyboxegrepComplementckb $msg;
}

proc PopupCgrepControls {} { 
    set w .pcpCgrep
    if {[winfo exist .pcpCgrep]} {
	if {![winfo ismapped .pcpCgrep]} {
	    wm deiconify .pcpCgrep;
	    raise .pcpCgrep
	} else {
	    wm iconify .pcpCgrep;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Cgrep
    after idle {
	raise .pcpCgrep
	update idletasks
	set xmax [winfo screenwidth .pcpCgrep]
	set ymax [winfo screenheight .pcpCgrep]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpCgrep]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpCgrep]))];
	wm geometry .pcpCgrep "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for cgrep."]
    set title [_ "Cgrep Settings"]
    if {[FeaturesUnSetP cgrep $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.cgrepCaseInsensitiveckb -text [_ "Case Insensitive?"] \
	-variable ProgramInfo(cgrep,CaseInsensitiveP) -onvalue 1 -offvalue 0
    checkbutton $w.main.cgrepComplementckb -text [_ "Complement?"] \
	-variable ProgramInfo(cgrep,Complement) -onvalue 1 -offvalue 0
    checkbutton $w.main.cgrepExtendedckb -text [_ "Extended Notation?"] \
	-variable ProgramInfo(cgrep,ExtendedP) -onvalue 1 -offvalue 0

    frame $w.main.app -relief ridge -border 2
    label $w.main.app.tit -text [_ "Approximate Matching"] -relief raised -border 1
    iwidgets::spinint $w.main.app.tcost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Total Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpCgrep.main.app.tcost up} \
	-decrement {.pcpCgrep.main.app.tcost down} \
	-invalid {};# Prevents irritating flashing or ringing of bell
    iwidgets::spinint $w.main.app.icost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Insertion Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpCgrep.main.app.icost up} \
	-decrement {.pcpCgrep.main.app.icost down} \
	-invalid {};
    iwidgets::spinint $w.main.app.dcost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Deletion Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpCgrep.main.app.dcost up} \
	-decrement {.pcpCgrep.main.app.dcost down} \
	-invalid {};
    iwidgets::spinint $w.main.app.scost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Substitution Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpCgrep.main.app.scost up} \
	-decrement {.pcpCgrep.main.app.scost down} \
	-invalid {};
    pack $w.main.app.tit -side top  -expand 0 -fill none -pady 5 -padx 4 -ipadx 4 -ipady 2
    pack $w.main.app.tcost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    pack $w.main.app.icost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    pack $w.main.app.dcost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    pack $w.main.app.scost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    $w.main.app.tcost clear
    $w.main.app.tcost insert 0 $::ProgramInfo(cgrep,TotalCost); 
    $w.main.app.icost clear
    $w.main.app.icost insert 0 $::ProgramInfo(cgrep,InsertionCost); 
    $w.main.app.dcost clear
    $w.main.app.dcost insert 0 $::ProgramInfo(cgrep,DeletionCost); 
    $w.main.app.scost clear
    $w.main.app.scost insert 0 $::ProgramInfo(cgrep,SubstitutionCost); 
    pack $w.main.app                      -side bottom -expand 1 -fill both \
	-padx 3 -pady 5
    pack $w.main.cgrepCaseInsensitiveckb -side top    -expand 1 -fill y \
	-padx 3 -pady 3 -anchor w
    pack $w.main.cgrepComplementckb      -side top    -expand 1 -fill y \
	-padx 3 -pady 3 -anchor w
    pack $w.main.cgrepExtendedckb      -side top    -expand 1 -fill y \
	-padx 3 -pady 3 -anchor w

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveCgrepInfo
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 4
    pack $w.cntls.save -side right -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 10
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.main.app $genmsg
    balloonhelp_for $w.main.app.tcost $genmsg
    balloonhelp_for $w.main.app.icost $genmsg
    balloonhelp_for $w.main.app.dcost $genmsg
    balloonhelp_for $w.main.app.scost $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    if { ([FeaturesUnSetP cgrep $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,cgrep,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.cgrepCaseInsensitiveckb $msg;
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Emit only strings not matching the regular expression?"]
    balloonhelp_for $w.main.cgrepComplementckb $msg;
    set msg [_ "Recognize extended regular expression notation instead of basic?"]
    balloonhelp_for $w.main.cgrepExtendedckb $msg;
}


proc SaveCgrepInfo {} { 
    set ::ProgramInfo(cgrep,TotalCost) [.pcpCgrep.main.app.tcost get]
    set ::ProgramInfo(cgrep,InsertionCost) [.pcpCgrep.main.app.icost get]
    set ::ProgramInfo(cgrep,DeletionCost) [.pcpCgrep.main.app.dcost get]
    set ::ProgramInfo(cgrep,SubstitutionCost) [.pcpCgrep.main.app.scost get]
}

option add  *pcpGlark.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpGlark.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpGlark.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpGlark.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpGlark.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpGlark.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpGlark.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupGlarkControls {} { 
    set w .pcpGlark
    if {[winfo exist .pcpGlark]} {
	if {![winfo ismapped .pcpGlark]} {
	    wm deiconify .pcpGlark;
	    raise .pcpGlark
	} else {
	    wm iconify .pcpGlark;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Glark
    after idle {
	raise .pcpGlark
	update idletasks
	set xmax [winfo screenwidth .pcpGlark]
	set ymax [winfo screenheight .pcpGlark]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpGlark]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpGlark]))];
	wm geometry .pcpGlark "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for Glark."]
    set title [_ "Glark Settings"]
    if {[FeaturesUnSetP glark $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title -font PopupTitleFont
    frame $w.main
    checkbutton $w.main.glarkCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable glarkCaseInsensitive -onvalue 1 -offvalue 0
    set ::glarkCaseInsensitive $::ProgramInfo(glark,CaseInsensitiveP)

    checkbutton $w.main.glarkMatchOnlyckb -text [_ "Emit Only Matching Portion"] \
	-variable glarkMatchOnly -onvalue 1 -offvalue 0
    set ::glarkMatchOnly $::ProgramInfo(glark,EmitMatchOnly)

    checkbutton $w.main.glarkComplementckb -text [_ "Complement"] \
	-variable glarkComplement -onvalue 1 -offvalue 0
    set ::glarkComplement $::ProgramInfo(glark,Complement)

    checkbutton $w.main.glarkMatchEntireLineckb -text [_ "Match Entire Line"] \
	-variable glarkMatchEntireLine -onvalue 1 -offvalue 0
    set ::glarkMatchEntireLine $::ProgramInfo(glark,MatchEntireLine)

    grid $w.main.glarkCaseInsensitiveckb -row 1 -column 0 -sticky w -columnspan 3 -pady 3
    grid $w.main.glarkComplementckb -row 2 -column 0 -sticky w -columnspan 3 -pady 3
    grid $w.main.glarkMatchOnlyckb -row 3 -column 0 -sticky w -columnspan 3 -pady 3
    grid $w.main.glarkMatchEntireLineckb -row 4 -column 0 -sticky w -columnspan 3 -pady 3

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveGlarkInfo
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 4
    pack $w.cntls.save -side right -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.main  -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.cntls -side top -expand 1 -fill both -padx 8 -pady {8 4}
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Emit only the portion of the string that\nactually matched, not the whole line."]
    balloonhelp_for $w.main.glarkMatchOnlyckb $msg;
    if { ([FeaturesUnSetP glark $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,glark,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.glarkCaseInsensitiveckb $msg;
    set msg [_ "Emit only strings not matching the regular expression?"]
    balloonhelp_for $w.main.glarkComplementckb $msg;
    set msg [_ "Emit only strings that match the entire line?"]
    balloonhelp_for $w.main.glarkMatchEntireLineckb $msg;
}

proc SaveGlarkInfo {} { 
    if {$::glarkCaseInsensitive} {
	set ::ProgramInfo(glark,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(glark,CaseInsensitiveP) 0
    }
    if {$::glarkComplement} {
	set ::ProgramInfo(glark,Complement) 1
    } else {
	set ::ProgramInfo(glark,Complement) 0
    }
    if {$::glarkMatchOnly} {
	set ::ProgramInfo(glark,EmitMatchOnly) 1
    } else {
	set ::ProgramInfo(glark,EmitMatchOnly) 0
    }
    if {$::glarkMatchEntireLine} {
	set ::ProgramInfo(glark,MatchEntireLine 1
    } else {
	set ::ProgramInfo(glark,MatchEntireLine) 0
    }
    TestFeatures;
}

option add  *pcpGrep.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpGrep.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpGrep.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpGrep.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpGrep.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpGrep.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpGrep.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupGrepControls {} { 
    set w .pcpGrep
    if {[winfo exist .pcpGrep]} {
	if {![winfo ismapped .pcpGrep]} {
	    wm deiconify .pcpGrep;
	    raise .pcpGrep
	} else {
	    wm iconify .pcpGrep;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Grep
    after idle {
	raise .pcpGrep
	update idletasks
	set xmax [winfo screenwidth .pcpGrep]
	set ymax [winfo screenheight .pcpGrep]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpGrep]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpGrep]))];
	wm geometry .pcpGrep "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for grep."]
    set title [_ "Grep Settings"]
    if {[FeaturesUnSetP grep $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    radiobutton $w.main.grepBasic -text [_ "Basic"] \
	-variable grepNotation -value Basic
    radiobutton $w.main.grepExtended -text [_ "Extended"] \
	-variable grepNotation -value Extended
    radiobutton $w.main.grepPerl -text [_ "Perl"] \
	-variable grepNotation -value Perl
    $w.main.grepExtended select;

    checkbutton $w.main.grepCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable grepCaseInsensitive -onvalue 1 -offvalue 0
    set ::grepCaseInsensitive $::ProgramInfo(grep,CaseInsensitiveP)

    checkbutton $w.main.grepMatchOnlyckb -text [_ "Emit Only Matching Portion"] \
	-variable grepMatchOnly -onvalue 1 -offvalue 0
    set ::grepMatchOnly $::ProgramInfo(grep,EmitMatchOnly)

    checkbutton $w.main.grepComplementckb -text [_ "Complement"] \
	-variable grepComplement -onvalue 1 -offvalue 0
    set ::grepComplement $::ProgramInfo(grep,Complement)

    grid $w.main.grepBasic 	   -row 0 -column 0 -sticky w -pady 3 -padx 2
    grid $w.main.grepExtended	   -row 0 -column 1 -sticky w -pady 3 -padx 2
    grid $w.main.grepPerl	   -row 0 -column 2 -sticky w -pady 3 -padx 2
    grid $w.main.grepCaseInsensitiveckb -row 1 -column 0 -sticky w -columnspan 3 -pady 3
    grid $w.main.grepComplementckb -row 2 -column 0 -sticky w -columnspan 3 -pady 3
    grid $w.main.grepMatchOnlyckb -row 3 -column 0 -sticky w -columnspan 3 -pady 3

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveGrepInfo
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.cntls.save -side right -expand 0 -fill none
    pack $w.title -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.main  -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.cntls -side top -expand 1 -fill both -padx 8 -pady {8 4}
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Use basic regular expression notation."]
    balloonhelp_for $w.main.grepBasic $msg;
    set msg [_ "Use extended regular expression notation."]
    balloonhelp_for $w.main.grepExtended $msg;
    set msg [_ "Use PERL 5 regular expression notation."]
    balloonhelp_for $w.main.grepPerl $msg;
    set msg [_ "Emit only the portion of the string that\nactually matched, not the whole line."]
    balloonhelp_for $w.main.grepMatchOnlyckb $msg;
    if { ([FeaturesUnSetP grep $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,grep,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.grepCaseInsensitiveckb $msg;
    set msg [_ "Emit only strings not matching the regular expression?"]
    balloonhelp_for $w.main.grepComplementckb $msg;
}

proc SaveGrepInfo {} { 
    if {$::grepCaseInsensitive} {
	set ::ProgramInfo(grep,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(grep,CaseInsensitiveP) 0
    }
    if {$::grepComplement} {
	set ::ProgramInfo(grep,Complement) 1
    } else {
	set ::ProgramInfo(grep,Complement) 0
    }
    if {$::grepMatchOnly} {
	set ::ProgramInfo(grep,EmitMatchOnly) 1
    } else {
	set ::ProgramInfo(grep,EmitMatchOnly) 0
    }
    set ::ProgramInfo(grep,Notation) $::grepNotation;
    TestFeatures;
}

option add  *pcpGawk.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpGawk.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpGawk.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpGawk.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpGawk.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpGawk.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpGawk.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupGawkControls {} { 
    set w .pcpGawk
    if {[winfo exist .pcpGawk]} {
	if {![winfo ismapped .pcpGawk]} {
	    wm deiconify .pcpGawk;
	    raise .pcpGawk
	} else {
	    wm iconify .pcpGawk;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Gawk
    after idle {
	raise .pcpGawk
	update idletasks
	set xmax [winfo screenwidth .pcpGawk]
	set ymax [winfo screenheight .pcpGawk]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpGawk]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpGawk]))];
	wm geometry .pcpGawk "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for gawk."]
    set title [_ "Gawk Settings"]
    if {[FeaturesUnSetP gawk $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    radiobutton $w.main.gawkGNU -text [_ "GNU"] \
	-variable gawkNotation -value GNU
    radiobutton $w.main.gawkPosix -text [_ "Posix"] \
	-variable gawkNotation -value Posix
    radiobutton $w.main.gawkTraditional -text [_ "Traditional"] \
	-variable gawkNotation -value Traditional
    $w.main.gawkGNU select;

    checkbutton $w.main.gawkCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable gawkCaseInsensitive -onvalue 1 -offvalue 0
    checkbutton $w.main.gawkIntervalExpressionsckb -text [_ "Accept Interval Expressions"] \
	-variable gawkIntervalExpressions -onvalue 1 -offvalue 0
    set ::gawkCaseInsensitive $::ProgramInfo(gawk,CaseInsensitiveP)
    set ::gawkIntervalExpressions $::ProgramInfo(gawk,IntervalExpressions)
    grid $w.main.gawkGNU 	   		-row 0 -column 0 -sticky w -pady 3 -padx 2
    grid $w.main.gawkPosix	   		-row 0 -column 1 -sticky w -pady 3 -padx 2
    grid $w.main.gawkTraditional   		-row 0 -column 2 -sticky w -pady 3 -padx 2
    grid $w.main.gawkCaseInsensitiveckb		-row 1 -column 0 -sticky w -columnspan 3 -pady 3
    grid $w.main.gawkIntervalExpressionsckb	-row 2 -column 0 -sticky w -columnspan 3 -pady 3

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveGawkInfo
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.cntls.save -side right -expand 0 -fill none
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 8
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 8
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 8
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Use GNU extended regular expression notation."]
    balloonhelp_for $w.main.gawkGNU $msg;
    set msg [_ "Use POSIX regular expression notation."]
    balloonhelp_for $w.main.gawkPosix $msg;
    set msg [_ "Use traditional awk regular expression notation."]
    balloonhelp_for $w.main.gawkTraditional $msg;
    set msg [_ "Accept interval expressions."]
    balloonhelp_for $w.main.gawkIntervalExpressionsckb $msg;
    if { ([FeaturesUnSetP gawk $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,gawk,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.gawkCaseInsensitiveckb $msg;
}

proc SaveGawkInfo {} { 
    if {$::gawkCaseInsensitive} {
	set ::ProgramInfo(gawk,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(gawk,CaseInsensitiveP) 0
    }
    if {$::gawkIntervalExpressions} {
	set ::ProgramInfo(gawk,IntervalExpressions) 1
    } else {
	set ::ProgramInfo(gawk,IntervalExpressions) 0
    }
    set ::ProgramInfo(gawk,Notation) $::gawkNotation;
    TestFeatures;
}

option add  *pcpEgrep.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpEgrep.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpEgrep.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpEgrep.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpEgrep.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpEgrep.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpEgrep.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupEgrepControls {} { 
    set w .pcpEgrep
    if {[winfo exist .pcpEgrep]} {
	if {![winfo ismapped .pcpEgrep]} {
	    wm deiconify .pcpEgrep;
	    raise .pcpEgrep
	} else {
	    wm iconify .pcpEgrep;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Egrep
    after idle {
	raise .pcpEgrep
	update idletasks
	set xmax [winfo screenwidth .pcpEgrep]
	set ymax [winfo screenheight .pcpEgrep]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpEgrep]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpEgrep]))];
	wm geometry .pcpEgrep "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for egrep."]
    set title [_ "Egrep Settings"]
    if {[FeaturesUnSetP egrep $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.egrepCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable egrepCaseInsensitive -onvalue 1 -offvalue 0
    set ::egrepCaseInsensitive $::ProgramInfo(egrep,CaseInsensitiveP)
    checkbutton $w.main.egrepMatchOnlyckb -text [_ "Emit Only Match"] \
	-variable egrepMatchOnly -onvalue 1 -offvalue 0
    set ::egrepMatchOnly $::ProgramInfo(egrep,EmitMatchOnly)
    checkbutton $w.main.egrepComplementckb -text [_ "Complement"] \
	-variable egrepComplement -onvalue 1 -offvalue 0
    set ::egrepComplement $::ProgramInfo(egrep,Complement)

    grid $w.main.egrepCaseInsensitiveckb -row 0 -column 0 -sticky w -pady 2
    grid $w.main.egrepComplementckb -row 1 -column 0 -sticky w -pady 2
    grid $w.main.egrepMatchOnlyckb -row 2 -column 0 -sticky w -pady 2

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveEgrepInfo
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 4
    pack $w.cntls.save -side right -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 10
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    if { ([FeaturesUnSetP egrep $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,egrep,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.egrepCaseInsensitiveckb $msg;
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Emit only the portion of the string that\nactually matched, not the whole line."]
    balloonhelp_for $w.main.egrepMatchOnlyckb $msg;
    set msg [_ "Emit only strings not matching the regular expression?"]
    balloonhelp_for $w.main.egrepComplementckb $msg;
}

proc SaveEgrepInfo {} { 
    if {$::egrepCaseInsensitive} {
	set ::ProgramInfo(egrep,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(egrep,CaseInsensitiveP) 0
    }
    if {$::egrepComplement} {
	set ::ProgramInfo(egrep,Complement) 1
    } else {
	set ::ProgramInfo(egrep,Complement) 0
    }
    if {$::egrepMatchOnly} {
	set ::ProgramInfo(egrep,EmitMatchOnly) 1
    } else {
	set ::ProgramInfo(egrep,EmitMatchOnly) 0
    }
}

option add  *pcpEmacs.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpEmacs.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpEmacs.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpEmacs.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpEmacs.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpEmacs.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpEmacs.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupEmacsControls {} { 
    set w .pcpEmacs
    if {[winfo exist .pcpEmacs]} {
	if {![winfo ismapped .pcpEmacs]} {
	    wm deiconify .pcpEmacs;
	    raise .pcpEmacs
	} else {
	    wm iconify .pcpEmacs;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Emacs
    after idle {
	raise .pcpEmacs
	update idletasks
	set xmax [winfo screenwidth .pcpEmacs]
	set ymax [winfo screenheight .pcpEmacs]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpEmacs]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpEmacs]))];
	wm geometry .pcpEmacs "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for emacs."]
    set title [_ "Emacs Settings"]
    if {[FeaturesUnSetP emacs $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.emacsFoldCaseMatchPckb -text [_ "Fold Case Match"] \
	-variable emacsFoldCaseMatchP -onvalue 1 -offvalue 0
    set ::emacsFoldCaseMatchP $::ProgramInfo(emacs,FoldCaseMatchP)
    checkbutton $w.main.emacsFoldCaseReplacePckb -text [_ "Fold Case Replace"] \
	-variable emacsFoldCaseReplaceP -onvalue 1 -offvalue 0
    set ::emacsFoldCaseReplaceP $::ProgramInfo(emacs,FoldCaseReplaceP)

    grid $w.main.emacsFoldCaseMatchPckb -row 0 -column 0 -sticky w -pady 2
    grid $w.main.emacsFoldCaseReplacePckb -row 1 -column 0 -sticky w -pady 2

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveEmacsInfo
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.cntls.save -side right -expand 0 -fill none
    pack $w.title  -side top -expand 1 -fill both -pady 4 -padx 8
    pack $w.main  -side top -expand 1 -fill both -pady 4 -padx 8
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 8
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Case insensitive match?"]
    balloonhelp_for $w.main.emacsFoldCaseMatchPckb $msg;
    set msg [_ "Case insensitive substitution?"]
    balloonhelp_for $w.main.emacsFoldCaseReplacePckb $msg;
}

proc SaveEmacsInfo {} { 
    if {$::emacsFoldCaseMatchP} {
	set ::ProgramInfo(emacs,FoldCaseMatchP) 1
    } else {
	set ::ProgramInfo(emacs,FoldCaseMatchP) 0
    }
    if {$::emacsFoldCaseReplaceP} {
	set ::ProgramInfo(emacs,FoldCaseReplaceP) 1
    } else {
	set ::ProgramInfo(emacs,FoldCaseReplaceP) 0
    }
}

option add  *pcpFgrep.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpFgrep.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpFgrep.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpFgrep.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpFgrep.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpFgrep.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpFgrep.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupFgrepControls {} { 
    set w .pcpFgrep
    if {[winfo exist .pcpFgrep]} {
	if {![winfo ismapped .pcpFgrep]} {
	    wm deiconify .pcpFgrep;
	    raise .pcpFgrep
	} else {
	    wm iconify .pcpFgrep;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Fgrep
    after idle {
	raise .pcpFgrep
	update idletasks
	set xmax [winfo screenwidth .pcpFgrep]
	set ymax [winfo screenheight .pcpFgrep]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpFgrep]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpFgrep]))];
	wm geometry .pcpFgrep "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for fgrep."]
    set title [_ "Fgrep Settings"]
    if {[FeaturesUnSetP fgrep $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.fgrepCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable fgrepCaseInsensitive -onvalue 1 -offvalue 0
    set ::fgrepCaseInsensitive $::ProgramInfo(fgrep,CaseInsensitiveP)
    checkbutton $w.main.fgrepMatchOnlyckb -text [_ "Emit Only Match"] \
	-variable fgrepMatchOnly -onvalue 1 -offvalue 0
    set ::fgrepMatchOnly $::ProgramInfo(fgrep,EmitMatchOnly)
    checkbutton $w.main.fgrepComplementckb -text [_ "Complement"] \
	-variable fgrepComplement -onvalue 1 -offvalue 0
    set ::fgrepComplement $::ProgramInfo(fgrep,Complement)

    grid $w.main.fgrepCaseInsensitiveckb -row 0 -column 0 -sticky w -pady 2
    grid $w.main.fgrepComplementckb -row 1 -column 0 -sticky w -pady 2
    grid $w.main.fgrepMatchOnlyckb -row 2 -column 0 -sticky w -pady 2

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveFgrepInfo
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.cntls.save -side right -expand 0 -fill none
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 8
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 8
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 8
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    if { ([FeaturesUnSetP fgrep $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,fgrep,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.fgrepCaseInsensitiveckb $msg;
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Emit only the portion of the string that\nactually matched, not the whole line."]
    balloonhelp_for $w.main.fgrepMatchOnlyckb $msg;
    set msg [_ "Emit only strings not matching the regular expression?"]
    balloonhelp_for $w.main.fgrepComplementckb $msg;
}

proc SaveFgrepInfo {} { 
    if {$::fgrepCaseInsensitive} {
	set ::ProgramInfo(fgrep,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(fgrep,CaseInsensitiveP) 0
    }
    if {$::fgrepComplement} {
	set ::ProgramInfo(fgrep,Complement) 1
    } else {
	set ::ProgramInfo(fgrep,Complement) 0
    }
    if {$::fgrepMatchOnly} {
	set ::ProgramInfo(fgrep,EmitMatchOnly) 1
    } else {
	set ::ProgramInfo(fgrep,EmitMatchOnly) 0
    }
}


option add  *pcpIci.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpIci.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpIci.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpIci.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpIci.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpIci.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpIci.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupIciControls {} { 
    set w .pcpIci
    if {[winfo exist .pcpIci]} {
	if {![winfo ismapped .pcpIci]} {
	    wm deiconify .pcpIci;
	    raise .pcpIci
	} else {
	    wm iconify .pcpIci;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Ici
    after idle {
	raise .pcpIci
	update idletasks
	set xmax [winfo screenwidth .pcpIci]
	set ymax [winfo screenheight .pcpIci]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpIci]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpIci]))];
	wm geometry .pcpIci "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for ici."]
    set title [_ "Ici Settings"]
    if {[FeaturesUnSetP ici $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.iciCaseInsensitivePckb -text [_ "Case Insensitive"] \
	-variable iciCaseInsensitiveP -onvalue 1 -offvalue 0
    set ::iciCaseInsensitive $::ProgramInfo(ici,CaseInsensitiveP)
    checkbutton $w.main.iciVerbosePckb -text [_ "Verbose"] \
	-variable iciVerboseP -onvalue 1 -offvalue 0
    set ::iciVerboseP $::ProgramInfo(ici,VerboseP)
    grid $w.main.iciCaseInsensitivePckb -row 0 -column 0 -sticky w -pady 2
    grid $w.main.iciVerbosePckb -row 2 -column 0 -sticky w -pady 2

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveIciInfo
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 4
    pack $w.cntls.save -side right -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 10
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    if { ([FeaturesUnSetP ici $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,ici,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.iciCaseInsensitivePckb $msg;
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Ignore whitespace and comments?"]
    balloonhelp_for $w.main.iciVerbosePckb $msg;
}

proc SaveIciInfo {} { 
    if {$::iciCaseInsensitiveP} {
	set ::ProgramInfo(ici,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(ici,CaseInsensitiveP) 0
    }
    if {$::iciVerboseP} {
	set ::ProgramInfo(ici,VerboseP) 1
    } else {
	set ::ProgramInfo(ici,VerboseP) 0
    }
}

option add  *pcpJava.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpJava.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpJava.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpJava.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpJava.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpJava.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpJava.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupJavaControls {} { 
    set w .pcpJava
    if {[winfo exist .pcpJava]} {
	if {![winfo ismapped .pcpJava]} {
	    wm deiconify .pcpJava;
	    raise .pcpJava
	} else {
	    wm iconify .pcpJava;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Java
    after idle {
	raise .pcpJava
	update idletasks
	set xmax [winfo screenwidth .pcpJava]
	set ymax [winfo screenheight .pcpJava]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpJava]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpJava]))];
	wm geometry .pcpJava "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for java."]
    set title [_ "Java Settings"]
    if {[FeaturesUnSetP java $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.javaCanonEQckb -text \
	[_ "Use Canonical Equivalence?"] \
	-variable javaCanonEQ -onvalue 1 -offvalue 0
    checkbutton $w.main.javaCaseInsensitiveckb -text \
	[_ "Match ASCII Without Regard to Case?"] \
	-variable javaCaseInsensitive -onvalue 1 -offvalue 0
    checkbutton $w.main.javaUnicodeCaseckb -text \
	[_ "Match Unicode Without Regard to Case?"] \
	-variable javaUnicodeCase -onvalue 1 -offvalue 0
    set ::javaCanonEQ $::ProgramInfo(java,CanonEQ)
    set ::javaCaseInsensitive $::ProgramInfo(java,CaseInsensitiveP)
    set ::javaUnicodeCase $::ProgramInfo(java,UnicodeCase)

    grid $w.main.javaCanonEQckb -row 0 -column 0 -sticky w -pady 3
    grid $w.main.javaCaseInsensitiveckb -row 1 -column 0 -sticky w -pady 3
    grid $w.main.javaUnicodeCaseckb -row 2 -column 0 -sticky w -pady 3

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveJavaInfo
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 4
    pack $w.cntls.save -side right -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.main  -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.cntls -side top -expand 1 -fill both -padx 8 -pady {8 4}
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Set the Pattern.Canon_EQ regexp compilation flag?"]
    balloonhelp_for $w.main.javaCanonEQckb $msg;
    set msg [_ "Match ASCII characters without regard to case?"]
    balloonhelp_for $w.main.javaCaseInsensitiveckb $msg;
    set msg [_ "Match all Unicode characters without regard to case?"]
    balloonhelp_for $w.main.javaUnicodeCaseckb $msg;
}

proc SaveJavaInfo {} { 
    if {$::javaCanonEQ} {
	set ::ProgramInfo(java,CanonEQ) 1
    } else {
	set ::ProgramInfo(java,CanonEQ) 0
    }
    if {$::javaCaseInsensitive} {
	set ::ProgramInfo(java,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(java,CaseInsensitiveP) 0
    }
    if {$::javaUnicodeCase} {
	set ::ProgramInfo(java,UnicodeCase) 1
    } else {
	set ::ProgramInfo(java,UnicodeCase) 0
    }
    set ::UpdateJavaByteCodeP 1;
}

option add  *pcpJgrep.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpJgrep.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpJgrep.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpJgrep.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpJgrep.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpJgrep.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpJgrep.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupJgrepControls {} { 
    set w .pcpJgrep
    if {[winfo exist .pcpJgrep]} {
	if {![winfo ismapped .pcpJgrep]} {
	    wm deiconify .pcpJgrep;
	    raise .pcpJgrep
	} else {
	    wm iconify .pcpJgrep;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Jgrep
    after idle {
	raise .pcpJgrep
	update idletasks
	set xmax [winfo screenwidth .pcpJgrep]
	set ymax [winfo screenheight .pcpJgrep]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpJgrep]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpJgrep]))];
	wm geometry .pcpJgrep "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for jgrep."]
    set title [_ "Jgrep Settings"]
    if {[FeaturesUnSetP jgrep $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.jgrepCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable jgrepCaseInsensitive -onvalue 1 -offvalue 0
    set ::jgrepCaseInsensitive $::ProgramInfo(jgrep,CaseInsensitiveP)

    grid $w.main.jgrepCaseInsensitiveckb -row 0 -column 0 -sticky w

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveJgrepInfo
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.cntls.save -side right -expand 0 -fill none
    pack $w.title $w.main $w.cntls -side top -expand 1 -fill both -pady 4 -padx 15 -ipadx 5
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    if { ([FeaturesUnSetP jgrep $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,jgrep,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.jgrepCaseInsensitiveckb $msg;
}

proc SaveJgrepInfo {} { 
    if {$::jgrepCaseInsensitive} {
	set ::ProgramInfo(jgrep,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(jgrep,CaseInsensitiveP) 0
    }
}

option add  *pcpMysql.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpMysql.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpMysql.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpMysql.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpMysql.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpMysql.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpMysql.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupMysqlControls {} { 
    set w .pcpMysql
    if {[winfo exist .pcpMysql]} {
	if {![winfo ismapped .pcpMysql]} {
	    wm deiconify .pcpMysql;
	    raise .pcpMysql
	} else {
	    wm iconify .pcpMysql;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Mysql
    after idle {
	raise .pcpMysql
	update idletasks
	set xmax [winfo screenwidth .pcpMysql]
	set ymax [winfo screenheight .pcpMysql]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpMysql]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpMysql]))];
	wm geometry .pcpMysql "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for mysql."]
    set title [_ "Mysql Settings"]
    if {[FeaturesUnSetP mysql $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    radiobutton $w.main.mysqlSQLWildcards -text [_ "SQL Wildcards"] \
	-variable ProgramInfo(mysql,RegexpP) -value 0
    radiobutton $w.main.mysqlRegexps -text [_ "Regular Expressions"] \
	-variable ProgramInfo(mysql,RegexpP) -value 1
    pack $w.main.mysqlSQLWildcards -side top -expand 1 -fill y -pady {3 1} -anchor w
    pack $w.main.mysqlRegexps      -side top -expand 1 -fill y -pady {1 3} -anchor w
    frame $w.cntls
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 8
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 8
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 8
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Use SQL wildcards."]
    balloonhelp_for $w.main.mysqlSQLWildcards $msg;
    set msg [_ "Use regular expressions."]
    balloonhelp_for $w.main.mysqlRegexps $msg;
}

trace add variable ProgramInfo(mysql,RegexpP) write ChangeMysql

proc ChangeMysql {e o n} {
    if {[string equal $::program mysql]} {
	TestFeatures;
	ConstructPalette;
    }
}

option add  *pcpNrgrep.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpNrgrep.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpNrgrep.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpNrgrep.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpNrgrep.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpNrgrep.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpNrgrep.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupNrgrepControls {} { 
    set w .pcpNrgrep
    if {[winfo exist .pcpNrgrep]} {
	if {![winfo ismapped .pcpNrgrep]} {
	    wm deiconify .pcpNrgrep;
	    raise .pcpNrgrep
	} else {
	    wm iconify .pcpNrgrep;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Nrgrep
    after idle {
	raise .pcpNrgrep
	update idletasks
	set xmax [winfo screenwidth .pcpNrgrep]
	set ymax [winfo screenheight .pcpNrgrep]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpNrgrep]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpNrgrep]))];
	wm geometry .pcpNrgrep "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for nrgrep."]
    if {[FeaturesUnSetP nrgrep $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text [_ "Nrgrep Settings"] -relief groove -border 1 -font PopupTitleFont
    frame $w.main
    checkbutton $w.main.nrgrepCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable nrgrepCaseInsensitiveP -onvalue 1 -offvalue 0
    set ::nrgrepCaseInsensitiveP $::ProgramInfo(nrgrep,CaseInsensitiveP)
    checkbutton $w.main.nrgrepComplementckb -text [_ "Complement"] \
	-variable nrgrepComplementP -onvalue 1 -offvalue 0
    set ::nrgrepComplementP $::ProgramInfo(nrgrep,ComplementP)

    frame $w.main.app -relief ridge -border 2
    label $w.main.app.tit -text [_ "Approximate Matching"] -relief raised -border 1
    iwidgets::spinint $w.main.app.cost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext Cost \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment IncrementCost -decrement DecrementCost \
	-invalid {};# Prevents irritating flashing or ringing of bell
    checkbutton $w.main.app.nrgrepInsertionckb -text [_ "Insertions"] \
	-variable nrgrepInsertionsP -onvalue 1 -offvalue 0
    set ::nrgrepInsertionsP $::ProgramInfo(nrgrep,InsertionsP)
    checkbutton $w.main.app.nrgrepDeletionckb -text [_ "Deletions"] \
	-variable nrgrepDeletionsP -onvalue 1 -offvalue 0
    set ::nrgrepDeletionsP $::ProgramInfo(nrgrep,DeletionsP)
    checkbutton $w.main.app.nrgrepSubstitutionckb -text [_ "Substitutions"] \
	-variable nrgrepSubstitutionsP -onvalue 1 -offvalue 0
    set ::nrgrepSubstitutionsP $::ProgramInfo(nrgrep,SubstitutionsP)
    checkbutton $w.main.app.nrgrepTranspositionckb -text [_ "Transpositions"] \
	-variable nrgrepTranspositionsP -onvalue 1 -offvalue 0
    set ::nrgrepTranspositionsP $::ProgramInfo(nrgrep,TranspositionsP)
    pack $w.main.app.tit -side top  -expand 0 -fill none -pady 5 -padx 4 -ipadx 4 -ipady 2
    pack $w.main.app.cost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    pack \
	$w.main.app.nrgrepInsertionckb \
	$w.main.app.nrgrepDeletionckb \
	$w.main.app.nrgrepSubstitutionckb \
	$w.main.app.nrgrepTranspositionckb \
	-side top -expand 1 -fill y -anchor w -padx 4  -pady 2
    $w.main.app.cost insert 0 $::ProgramInfo(nrgrep,TotalCost); 

    pack $w.main.app                      -side bottom -expand 1 -fill both \
	-padx 3 -pady 5
    pack $w.main.nrgrepCaseInsensitiveckb -side top    -expand 1 -fill y \
	-padx 3 -pady 3 -anchor w
    pack $w.main.nrgrepComplementckb      -side top    -expand 1 -fill y \
	-padx 3 -pady 3 -anchor w

    frame $w.cntls;
    button $w.cntls.save -text [_ "Save"] -command SaveNrgrepInfo
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 5
    pack $w.cntls.save -side right -expand 0 -fill none -padx 5

    pack $w.title -side top -expand 1 -fill both -pady {8 4} -padx 35 -ipadx 5 -ipady 3
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 20
    pack $w.cntls -side top -expand 1 -fill both -pady {4 8} -padx 20
    #balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    if { ([FeaturesUnSetP nrgrep $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,nrgrep,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.nrgrepCaseInsensitiveckb $msg;
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Emit only strings not matching the regular expression?"]
    balloonhelp_for $w.main.nrgrepComplementckb $msg;
}

proc IncrementCost {} {
    .pcpNrgrep.main.app.cost up
}

proc DecrementCost {} {
    .pcpNrgrep.main.app.cost down
}

proc SaveNrgrepInfo {} { 
    set ::ProgramInfo(nrgrep,TotalCost) [.pcpNrgrep.main.app.cost get]
    if {$::nrgrepCaseInsensitiveP} {
	set ::ProgramInfo(nrgrep,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(nrgrep,CaseInsensitiveP) 0
    }
    if {$::nrgrepComplementP} {
	set ::ProgramInfo(nrgrep,ComplementP) 1
    } else {
	set ::ProgramInfo(nrgrep,ComplementP) 0
    }
    if {$::nrgrepInsertionsP} {
	set ::ProgramInfo(nrgrep,InsertionsP) 1
    } else {
	set ::ProgramInfo(nrgrep,InsertionsP) 0
    }
    if {$::nrgrepDeletionsP} {
	set ::ProgramInfo(nrgrep,DeletionsP) 1
    } else {
	set ::ProgramInfo(nrgrep,DeletionsP) 0
    }
    if {$::nrgrepSubstitutionsP} {
	set ::ProgramInfo(nrgrep,SubstitutionsP) 1
    } else {
	set ::ProgramInfo(nrgrep,SubstitutionsP) 0
    }
    if {$::nrgrepTranspositionsP} {
	set ::ProgramInfo(nrgrep,TranspositionsP) 1
    } else {
	set ::ProgramInfo(nrgrep,TranspositionsP) 0
    }
}

option add  *pcpPatmatch.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpPatmatch.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpPatmatch.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpPatmatch.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpPatmatch.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpPatmatch.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpPatmatch.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupPatmatchControls {} { 
    set w .pcpPatmatch
    if {[winfo exist .pcpPatmatch]} {
	if {![winfo ismapped .pcpPatmatch]} {
	    wm deiconify .pcpPatmatch;
	    raise .pcpPatmatch
	} else {
	    wm iconify .pcpPatmatch;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Patmatch
    after idle {
	raise .pcpPatmatch
	update idletasks
	set xmax [winfo screenwidth .pcpPatmatch]
	set ymax [winfo screenheight .pcpPatmatch]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpPatmatch]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpPatmatch]))];
	wm geometry .pcpPatmatch "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for patmatch."]
    if {[FeaturesUnSetP patmatch $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text [_ "Patmatch Settings"] -relief groove -border 1 \
	-font PopupTitleFont
    frame $w.main
    set rf [frame $w.main.res -relief ridge -border 2]
    label $rf.tit -text [_ "Residue"] -relief raised -border 1
    radiobutton $rf.nuc -variable ProgramInfo(patmatch,ResidueType) -value n \
	-text [_ "Nucleotides"] -indicatoron 0
    radiobutton $rf.pep -variable ProgramInfo(patmatch,ResidueType) -value p \
	-text [_ "Proteins"] -indicatoron 0
    radiobutton $rf.com -variable ProgramInfo(patmatch,ResidueType) -value c \
	-text [_ "Crick Strand"] -indicatoron 0
    pack $rf.tit -side top -expand 0 -fill none -padx 5 -pady 6 -anchor w
    pack $rf.nuc -side left -expand 1 -fill both -padx 5 -pady {4 6}
    pack $rf.pep -side left -expand 1 -fill both -padx 5 -pady {4 6}
    pack $rf.com -side left -expand 1 -fill both -padx 5 -pady {4 6}
    set ap [frame $w.main.app -relief ridge -border 2]
    label $ap.tit -text [_ "Approximate Matching"] -relief raised -border 1
    iwidgets::spinint $ap.mismatches \
	-labelpos w \
	-width 3 \
	-range {0 10} \
	-wrap 0 \
	-labeltext Mismatches \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment IncrementMismatches -decrement DecrementMismatches \
	-invalid {};# Prevents irritating flashing or ringing of bell
    $ap.mismatches delete 0 end
    $ap.mismatches insert 0 $::ProgramInfo(patmatch,MismatchNumber);
    checkbutton $ap.ins -text [_ "Insertions"] \
	-variable patmatchInsertionsP -onvalue 1 -offvalue 0 -indicatoron 1
    set ::patmatchInsertionsP [expr [string first i $::ProgramInfo(patmatch,MismatchTypes)] >= 0]
    checkbutton $ap.del -text [_ "Deletions"] \
	-variable patmatchDeletionsP -onvalue 1 -offvalue 0 -indicatoron 1
    set ::patmatchDeletionsP [expr [string first d $::ProgramInfo(patmatch,MismatchTypes)] >= 0]
    checkbutton $ap.sub -text [_ "Substitutions"] \
	-variable patmatchSubstitutionsP -onvalue 1 -offvalue 0 -indicatoron 1
    set ::patmatchSubstitutionsP [expr [string first s $::ProgramInfo(patmatch,MismatchTypes)] >= 0]
    pack $ap.tit -side top  -anchor w\
	-expand 0 -fill none -pady 5 -padx 4 -ipadx 4 -ipady 2
    pack $ap.mismatches \
	-side top -expand 1 -fill y -anchor w -padx 4  -pady 7
    pack $ap.ins \
	-side left -expand 1 -fill y -anchor w -padx 4  -pady {5 7}
    pack $ap.del  \
	-side left -expand 1 -fill y -anchor w -padx 4  -pady {5 7}
    pack $ap.sub \
	-side left -expand 1 -fill y -anchor w -padx 4  -pady {5 7}

    pack $ap  -side bottom -expand 1 -fill both -padx 3 -pady 3
    pack $rf         -side bottom -expand 1 -fill both 	-padx 3 -pady 3
    frame $w.cntls;
    button $w.cntls.save -text [_ "Save"] -command SavePatmatchInfo
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx {15 3}
    pack $w.cntls.save -side right -expand 0 -fill none -padx {3 15}

    pack $w.title -side top -expand 1 -fill both -pady {8 4} -padx 35 -ipadx 5 -ipady 3
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 20
    pack $w.cntls -side top -expand 1 -fill both -pady {4 8} -padx 20
    #balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Choose the type of residue you wish to search."]
    balloonhelp_for $rf $msg
    balloonhelp_for $rf.tit $msg
    balloonhelp_for $rf.nuc $msg
    balloonhelp_for $rf.pep $msg
    balloonhelp_for $rf.com $msg
    set msg [_ "Set the maximum number of mismatches permitted."]
    balloonhelp_for $ap.mismatches $msg;
    set msg [_ "Choose which types of mismatches are permitted."]
    balloonhelp_for $ap.ins $msg
    balloonhelp_for $ap.del $msg
    balloonhelp_for $ap.sub $msg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
}

proc IncrementMismatches {} {
    .pcpPatmatch.main.app.mismatches up
}

proc DecrementMismatches {} {
    .pcpPatmatch.main.app.mismatches down
}

proc SavePatmatchInfo {} { 
    set ::ProgramInfo(patmatch,MismatchNumber) [.pcpPatmatch.main.app.mismatches get]
    if {$::patmatchInsertionsP} {
	append ostr i
    }
    if {$::patmatchDeletionsP} {
	append ostr d
    }
    if {$::patmatchSubstitutionsP} {
	append ostr s
    }
    set ::ProgramInfo(patmatch,MismatchTypes) $ostr;
}

option add  *pcpPerl.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpPerl.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpPerl.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpPerl.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpPerl.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpPerl.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpPerl.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

option add  *pcpNumgrep.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpNumgrep.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpNumgrep.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpNumgrep.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpNumgrep.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpNumgrep.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpNumgrep.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupNumgrepControls {} { 
    set w .pcpNumgrep
    if {[winfo exist .pcpNumgrep]} {
	if {![winfo ismapped .pcpNumgrep]} {
	    wm deiconify .pcpNumgrep;
	    raise .pcpNumgrep
	} else {
	    wm iconify .pcpNumgrep;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Numgrep
    after idle {
	raise .pcpNumgrep
	update idletasks
	set xmax [winfo screenwidth .pcpNumgrep]
	set ymax [winfo screenheight .pcpNumgrep]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpNumgrep]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpNumgrep]))];
	wm geometry .pcpNumgrep "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for numgrep."]
    set title [_ "Numgrep Settings"]
    if {[FeaturesUnSetP numgrep $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.numgrepOutputNumberByNumberckb -text [_ "Output Number By Number"] \
	-variable numgrepOutputNumberByNumber -onvalue 1 -offvalue 0
    set ::numgrepOutputNumberByNumber $::ProgramInfo(numgrep,OutputNumberByNumberP)

    grid $w.main.numgrepOutputNumberByNumberckb -row 0 -column 0 -sticky w

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveNumgrepInfo
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.cntls.save -side right -expand 0 -fill none
    pack $w.title $w.main $w.cntls -side top -expand 1 -fill both -pady 4 -padx 15 -ipadx 5
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Print the matching numbers one per line\neven if they are on a single line?"]
    balloonhelp_for $w.main.numgrepOutputNumberByNumberckb $msg;
}

proc SaveNumgrepInfo {} { 
    if {$::numgrepOutputNumberByNumber} {
	set ::ProgramInfo(numgrep,OutputNumberByNumberP) 1
    } else {
	set ::ProgramInfo(numgrep,OutputNumberByNumberP) 0
    }
}

proc PopupPerlControls {} { 
    set w .pcpPerl
    if {[winfo exist .pcpPerl]} {
	if {![winfo ismapped .pcpPerl]} {
	    wm deiconify .pcpPerl;
	    raise .pcpPerl
	} else {
	    wm iconify .pcpPerl;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Perl
    after idle {
	raise .pcpPerl
	update idletasks
	set xmax [winfo screenwidth .pcpPerl]
	set ymax [winfo screenheight .pcpPerl]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpPerl]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpPerl]))];
	wm geometry .pcpPerl "+$x0+$y0";
    }
    set genmsg [_ "Set options for perl."]
    set title [_ "Perl Settings"]
    if {[FeaturesUnSetP perl $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.perlUnicodeLocaleDependentPckb \
	-text [_ "Make Unicode Support\nInterfaceLocale Dependent?"] \
	-variable perlUnicodeLocaleDependentP -onvalue 1 -offvalue 0
    set ::perlUnicodeLocaleDependentP $::ProgramInfo(perl,UnicodeLocaleDependentP)

    grid $w.main.perlUnicodeLocaleDependentPckb -row 0 -column 0 -sticky w

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SavePerlInfo
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.cntls.save -side right -expand 0 -fill none
    pack $w.title $w.main $w.cntls -side top -expand 1 -fill both -pady 4 -padx 10 -ipadx 5
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Make Unicode support locale dependent?"]
    balloonhelp_for $w.main.perlUnicodeLocaleDependentPckb $msg;
}

proc SavePerlInfo {} { 
    if {$::perlUnicodeLocaleDependentP} {
	set ::ProgramInfo(perl,UnicodeLocaleDependentP) 1
    } else {
	set ::ProgramInfo(perl,UnicodeLocaleDependentP) 0
    }
}

proc PerlUnicodeDepUpdate {n e o} {
    TestFeatures;
    LabelMenus;
}

option add  *pcpPython.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpPython.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpPython.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpPython.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpPython.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpPython.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpPython.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupPythonControls {} { 
    set w .pcpPython
    if {[winfo exist .pcpPython]} {
	if {![winfo ismapped .pcpPython]} {
	    wm deiconify .pcpPython;
	    raise .pcpPython
	} else {
	    wm iconify .pcpPython;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Python
    after idle {
	raise .pcpPython
	update idletasks
	set xmax [winfo screenwidth .pcpPython]
	set ymax [winfo screenheight .pcpPython]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpPython]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpPython]))];
	wm geometry .pcpPython "+$x0+$y0";
    }
    set genmsg [_ "Set options for python."]
    set title [_ "Python Settings"]
    if {[FeaturesUnSetP python $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.pythonRawStringPckb -text [_ "Pass Expressions as\nRaw Strings?"] \
	-variable pythonRawStringP -onvalue 1 -offvalue 0
    set ::pythonRawStringP $::ProgramInfo(python,RawStringP)

    grid $w.main.pythonRawStringPckb -row 0 -column 0 -sticky w

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SavePythonInfo
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.cntls.save -side right -expand 0 -fill none
    pack $w.title -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.main  -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.cntls -side top -expand 1 -fill both -padx 8 -pady {8 4}
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Pass expressions as raw strings?"]
    balloonhelp_for $w.main.pythonRawStringPckb $msg;
}

proc SavePythonInfo {} { 
    if {$::pythonRawStringP} {
	set ::ProgramInfo(python,RawStringP) 1
    } else {
	set ::ProgramInfo(python,RawStringP) 0
    }
}

option add  *pcpSed.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpSed.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpSed.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpSed.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpSed.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpSed.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpSed.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupSedControls {} { 
    if {[string equal $::ProgramInfo(sed,Which) supersed]} {
	PopupSsedControls
	return
    }
    if {[string equal $::ProgramInfo(sed,Which) minised]} {
	ShowMessage [_ "This version of sed does not support any options."]
	return
    }
    set w .pcpSed
    if {[winfo exist .pcpSed]} {
	if {![winfo ismapped .pcpSed]} {
	    wm deiconify .pcpSed;
	    raise .pcpSed
	} else {
	    wm iconify .pcpSed;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Sed
    after idle {
	raise .pcpSed
	update idletasks
	set xmax [winfo screenwidth .pcpSed]
	set ymax [winfo screenheight .pcpSed]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpSed]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpSed]))];
	wm geometry .pcpSed "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for sed."]
    set title [_ "Sed Settings"]
    if {[FeaturesUnSetP sed $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.sedExtendedRegexpckb -text \
	[_ "Use Extended Regular\nExpression Notation?"] \
	-variable sedExtendedRegexp -onvalue 1 -offvalue 0
    set ::sedExtendedRegexp $::ProgramInfo(sed,ExtendedRegexp)

    grid $w.main.sedExtendedRegexpckb -row 0 -column 0 -sticky w

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveSedInfo
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.cntls.save -side right -expand 0 -fill none
    pack $w.title -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.main  -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.cntls -side top -expand 1 -fill both -padx 8 -pady {8 4}
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Use extended regular expression notation?"]
    balloonhelp_for $w.main.sedExtendedRegexpckb $msg;
}

proc SaveSedInfo {} { 
    if {$::sedExtendedRegexp} {
	set ::ProgramInfo(sed,ExtendedRegexp) 1
    } else {
	set ::ProgramInfo(sed,ExtendedRegexp) 0
    }
    TestFeatures;
}

option add  *pcpSsed.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpSsed.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpSsed.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpSsed.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpSsed.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpSsed.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpSsed.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupSsedControls {} { 
    set w .pcpSsed
    if {[winfo exist .pcpSsed]} {
	if {![winfo ismapped .pcpSsed]} {
	    wm deiconify .pcpSsed;
	    raise .pcpSsed
	} else {
	    wm iconify .pcpSsed;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Ssed
    after idle {
	raise .pcpSsed
	update idletasks
	set xmax [winfo screenwidth .pcpSsed]
	set ymax [winfo screenheight .pcpSsed]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpSsed]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpSsed]))];
	wm geometry .pcpSsed "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for ssed."]
    set title [_ "Ssed Settings"]
    if {[FeaturesUnSetP ssed $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main

    checkbutton $w.main.ssedPOSIXckb -text [_ "Adhere to POSIX - no GNU extensions"] \
	-variable ::ProgramInfo(ssed,POSIX) -onvalue 1 -offvalue 0

    radiobutton $w.main.ssedrdb1 -text [_ "basic"] \
	-variable ::ProgramInfo(ssed,RegexpType) -value "basic"
    radiobutton $w.main.ssedrdb2 -text [_ "extended"] \
	-variable ::ProgramInfo(ssed,RegexpType) -value "extended"
    radiobutton $w.main.ssedrdb3 -text [_ "perl"] \
	-variable ::ProgramInfo(ssed,RegexpType) -value "perl"

    grid $w.main.ssedPOSIXckb -row 0 -column 0 -sticky w -pady 2 -columnspan 3
    grid $w.main.ssedrdb1     -row 1 -column 0 -sticky w -pady 2
    grid $w.main.ssedrdb2     -row 1 -column 1 -sticky w -pady 2
    grid $w.main.ssedrdb3     -row 1 -column 2 -sticky w -pady 2

    frame $w.cntls
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 10

    set msg [_ "Use only POSIX features - disable GNU extensions."]
    balloonhelp_for $w.main.ssedPOSIXckb $msg
    set msg [_ "Use basic regular expressions."]
    balloonhelp_for $w.main.ssedrdb1 $msg
    set msg [_ "Use extended regular expressions."]
    balloonhelp_for $w.main.ssedrdb2 $msg
    set msg [_ "Use PERL5 regular expressions."]
    balloonhelp_for $w.main.ssedrdb3 $msg
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
}

proc UpdateSsedPalette {e o n} {
    TestFeatures
    ConstructPalette
}

option add  *pcpTcl.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpTcl.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpTcl.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpTcl.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpTcl.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpTcl.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpTcl.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupTclControls {} { 
    set w .pcpTcl
    if {[winfo exist .pcpTcl]} {
	if {![winfo ismapped .pcpTcl]} {
	    wm deiconify .pcpTcl;
	    raise .pcpTcl
	} else {
	    wm iconify .pcpTcl;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Tcl
    after idle {
	raise .pcpTcl
	update idletasks
	set xmax [winfo screenwidth .pcpTcl]
	set ymax [winfo screenheight .pcpTcl]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpTcl]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpTcl]))];
	wm geometry .pcpTcl "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for tcl."]
    set title [_ "Tcl Settings"]
    if {[FeaturesUnSetP tcl $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.tclCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable ::ProgramInfo(tcl,CaseInsensitiveP) -onvalue 1 -offvalue 0
    checkbutton $w.main.tclEmitMatchOnlyckb -text [_ "Emit Match Only"] \
	-variable ::ProgramInfo(tcl,EmitMatchOnlyP) -onvalue 1 -offvalue 0
    checkbutton $w.main.tclExpandedckb -text [_ "Verbose"] \
	-variable ::ProgramInfo(tcl,ExpandedP) -onvalue 1 -offvalue 0
    grid $w.main.tclCaseInsensitiveckb -row 0 -column 0 -sticky w
    grid $w.main.tclEmitMatchOnlyckb -row 1 -column 0 -sticky w
    grid $w.main.tclExpandedckb -row 2 -column 0 -sticky w

    frame $w.cntls
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.title $w.main $w.cntls -side top -expand 1 -fill both -pady 4 -padx 15 -ipadx 5
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    if { ([FeaturesUnSetP tcl $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,tcl,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.tclCaseInsensitiveckb $msg;
    set msg [_ "Emit only the portion of the string that\nactually matched, not the whole line."]
    balloonhelp_for $w.main.tclEmitMatchOnlyckb $msg;
    set msg [_ "Ignore whitespace and comments within regular expression?"]
    balloonhelp_for $w.main.tclExpandedckb $msg;
}

option add  *pcpTr.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpTr.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpTr.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpTr.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpTr.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpTr.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpTr.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupTrControls {} { 
    set w .pcpTr
    if {[winfo exist .pcpTr]} {
	if {![winfo ismapped .pcpTr]} {
	    wm deiconify .pcpTr;
	    raise .pcpTr
	} else {
	    wm iconify .pcpTr;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Tr
    after idle {
	raise .pcpTr
	update idletasks
	set xmax [winfo screenwidth .pcpTr]
	set ymax [winfo screenheight .pcpTr]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpTr]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpTr]))];
	wm geometry .pcpTr "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for Tr."]
    set title [_ "Tr Settings"]
    if {[FeaturesUnSetP tr $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.trComplementckb -text [_ "Complement Set One?"] \
	-variable trComplement -onvalue 1 -offvalue 0
    set ::trComplement $::ProgramInfo(tr,Complement)

    checkbutton $w.main.trSqueezeckb -text [_ "Squeeze Repeats?"] \
	-variable trSqueeze -onvalue 1 -offvalue 0
    set ::trSqueeze $::ProgramInfo(tr,Squeeze)

    checkbutton $w.main.trTruncateckb -text [_ "Truncate Set One to Length\nof Set Two?"] \
	-variable trTruncate -onvalue 1 -offvalue 0
    set ::trTruncate $::ProgramInfo(tr,Truncate)

    grid $w.main.trComplementckb -row 0 -column 0 -sticky w -pady 3
    grid $w.main.trSqueezeckb    -row 1 -column 0 -sticky w -pady 3
    grid $w.main.trTruncateckb   -row 2 -column 0 -sticky w -pady 3

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveTrInfo
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none
    pack $w.cntls.save -side right -expand 0 -fill none
    pack $w.title -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.main  -side top -expand 1 -fill both -padx 8 -pady 4
    pack $w.cntls -side top -expand 1 -fill both -padx 8 -pady {8 4}
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Map the characters not in set one rather than \
 	those in set one?"]
    balloonhelp_for $w.main.trComplementckb $msg;
    set msg [_ "Replace sequences of more than one of the same character in\n\
 	set one with a single token."];
    balloonhelp_for $w.main.trSqueezeckb $msg;
    set msg [_ "Truncate the length of set one to the length of set two."];
    balloonhelp_for $w.main.trTruncateckb $msg;
}

proc SaveTrInfo {} { 
    if {$::TrComplement} {
	set ::ProgramInfo(Tr,Complement) 1
    } else {
	set ::ProgramInfo(Tr,Complement) 0
    }
    if {$::TrSqueeze} {
	set ::ProgramInfo(Tr,Squeeze) 1
    } else {
	set ::ProgramInfo(Tr,Squeeze) 0
    }
    if {$::TrTruncate} {
	set ::ProgramInfo(Tr,Truncate) 1
    } else {
	set ::ProgramInfo(Tr,Truncate) 0
    }
}

option add  *pcpVim.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpVim.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpVim.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpVim.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpVim.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpVim.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpVim.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupVimControls {} { 
    set w .pcpVim
    if {[winfo exist .pcpVim]} {
	if {![winfo ismapped .pcpVim]} {
	    wm deiconify .pcpVim;
	    raise .pcpVim
	} else {
	    wm iconify .pcpVim;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Vim
    after idle {
	raise .pcpVim
	update idletasks
	set xmax [winfo screenwidth .pcpVim]
	set ymax [winfo screenheight .pcpVim]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpVim]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpVim]))];
	wm geometry .pcpVim "+$x0+$y0";
    }
    set genmsg [_ "Set options for vim."]
    set title [_ "Vim Settings"]
    if {[FeaturesUnSetP vim $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.vimCaseInsensitiveckb -text [_ "Case Insensitive"] \
	-variable ::ProgramInfo(vim,CaseInsensitiveP) -onvalue 1 -offvalue 0
    checkbutton $w.main.vimSmartCaseckb -text [_ "Smart Case"] \
	-variable ::ProgramInfo(vim,SmartCaseP) -onvalue 1 -offvalue 0
    checkbutton $w.main.vimSubstitutionGlobalckb -text [_ "Substitution Global"] \
	-variable ::ProgramInfo(vim,SubstitutionGlobalP) -onvalue 1 -offvalue 0

    grid $w.main.vimCaseInsensitiveckb -row 0 -column 0 -sticky w -pady 2
    grid $w.main.vimSmartCaseckb  -row 1 -column 0 -sticky w -pady 2
    grid $w.main.vimSubstitutionGlobalckb -row 2 -column 0 -sticky w -pady 2

    frame $w.cntls
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side right -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 10
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    if { ([FeaturesUnSetP vim $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,vim,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.vimCaseInsensitiveckb $msg;
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Make lower case in pattern match any case but\nupper case in pattern match only upper case?"]
    balloonhelp_for $w.main.vimSmartCaseckb $msg;
    set msg [_ "Apply substitutions to every match or just the first?"]
    balloonhelp_for $w.main.vimSubstitutionGlobalckb $msg;
}


option add  *pcpWMAgrep.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpWMAgrep.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpWMAgrep.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpWMAgrep.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpWMAgrep.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpWMAgrep.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpWMAgrep.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;
set wmagrepErrLim 0
set wmagrepDelWei 0
set wmagrepInsWei 0
set wmagrepSubWei 0

proc PopupWMAgrepControls {} { 
    set w .pcpWMAgrep
    if {[winfo exist .pcpWMAgrep]} {
	if {![winfo ismapped .pcpWMAgrep]} {
	    wm deiconify .pcpWMAgrep;
	    raise .pcpWMAgrep
	} else {
	    wm iconify .pcpWMAgrep;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w WMAgrep
    after idle {
	raise .pcpWMAgrep
	update idletasks
	set xmax [winfo screenwidth .pcpWMAgrep]
	set ymax [winfo screenheight .pcpWMAgrep]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpWMAgrep]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpWMAgrep]))];
	wm geometry .pcpWMAgrep "+$x0+$y0";
    }
    if {![info exist ::ProgramInfo(wmagrep,TreWMAgrepP)]} {
	WhichWMAgrep;
    }
    if {$::ProgramInfo(wmagrep,TreWMAgrepP)} {
	set which "TRE WMAgrep"
	set genmsg \
	    [_ "Set command-line options for wmagrep."]
    } elseif {$::ProgramInfo(wmagrep,TreWMAgrepP) == 0} {
	set which "Wu-Manber agrep"
	set genmsg [_ "Set command-line options for wmagrep."]
    } else {
	ShowMessage [_ "WMAgrep is not available or is not in your path."]
	return ;
    }
    set title [format "%s\n%s" [_ "WMAgrep Settings"] $which]
    if {[FeaturesUnSetP wmagrep $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont
    frame $w.main
    checkbutton $w.main.caseInsensitiveckb -text [_ "Case Insensitive?"] \
	-variable wmagrepCasIns -onvalue 1 -offvalue 0
    checkbutton $w.main.bestResultckb -text [_ "Near Misses?"] \
	-variable wmagrepBesRes -onvalue 1 -offvalue 0

    frame $w.main.app -relief ridge -border 2
    label $w.main.app.tit -text [_ "Approximate Matching"] -relief raised -border 1
    iwidgets::spinint $w.main.app.tcost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Total Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpWMAgrep.main.app.tcost up} \
	-decrement {.pcpWMAgrep.main.app.tcost down} \
	-invalid {};# Prevents irritating flashing or ringing of bell
    iwidgets::spinint $w.main.app.icost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Insertion Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpWMAgrep.main.app.icost up} \
	-decrement {.pcpWMAgrep.main.app.icost down} \
	-invalid {};
    iwidgets::spinint $w.main.app.dcost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Deletion Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpWMAgrep.main.app.dcost up} \
	-decrement {.pcpWMAgrep.main.app.dcost down} \
	-invalid {};
    iwidgets::spinint $w.main.app.scost \
	-labelpos e \
	-width 3 \
	-range {0 100} \
	-wrap 0 \
	-labeltext "Substitution Cost" \
	-textbackground $::ColorSpecs(ProgramSpecificControls,Select) \
	-increment {.pcpWMAgrep.main.app.scost up} \
	-decrement {.pcpWMAgrep.main.app.scost down} \
	-invalid {};
    pack $w.main.app.tit -side top  -expand 0 -fill none -pady 5 -padx 4 -ipadx 4 -ipady 2
    pack $w.main.app.tcost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    pack $w.main.app.icost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    pack $w.main.app.dcost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    pack $w.main.app.scost -side top -expand 1 -fill y -anchor w -padx 4  -pady 5
    $w.main.app.tcost clear
    $w.main.app.tcost insert 0 $::ProgramInfo(wmagrep,TotalCost); 
    $w.main.app.icost clear
    $w.main.app.icost insert 0 $::ProgramInfo(wmagrep,InsertionCost); 
    $w.main.app.dcost clear
    $w.main.app.dcost insert 0 $::ProgramInfo(wmagrep,DeletionCost); 
    $w.main.app.scost clear
    $w.main.app.scost insert 0 $::ProgramInfo(wmagrep,SubstitutionCost); 
    pack $w.main.app                      -side bottom -expand 1 -fill both \
	-padx 3 -pady 5
    pack $w.main.caseInsensitiveckb -side top    -expand 1 -fill y \
	-padx 3 -pady 3 -anchor w
    pack $w.main.bestResultckb      -side top    -expand 1 -fill y \
	-padx 3 -pady 3 -anchor w

    frame $w.cntls
    button $w.cntls.save -text [_ "Save"] -command SaveWMAgrepInfo
    set msg [_ "Press this button to dismiss the popup."]
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 4
    pack $w.cntls.save -side right -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 10

    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Press this button to make the changes you have made take effect."]
    balloonhelp_for $w.cntls.save $msg
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    if { ([FeaturesUnSetP wmagrep $::InterfaceLocale] == 0) && 
	 ($::Features(CaseInsensitiveCLFlagBackrefP,wmagrep,$::InterfaceLocale) == 0)} {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGNoBackRef)
    } else {
	set msg $::Messages(CommandLineCaseInsensitiveFlagMSGStd)
    }
    balloonhelp_for $w.main.caseInsensitiveckb $msg
    set msg [_ "How many error units should each deletion cost?"]
    balloonhelp_for $w.main.app.dcost $msg
    set msg [_ "How many error units should each insertion cost?"]
    balloonhelp_for $w.main.app.icost $msg
    set msg [_ "How many error units should each substitution cost?"]
    balloonhelp_for $w.main.app.scost $msg
    set msg [_ "In the absence of exact matches, produce the best results?"]
    balloonhelp_for $w.main.bestResultckb $msg
    set msg [_ "What is the maximum total error cost permitted?"]
    balloonhelp_for $w.main.app.tcost $msg
}

proc SaveWMAgrepInfo {} { 
    set ::ProgramInfo(wmagrep,TotalCost) [.pcpWMAgrep.main.app.tcost get]
    set ::ProgramInfo(wmagrep,InsertionCost) [.pcpWMAgrep.main.app.icost get]
    set ::ProgramInfo(wmagrep,DeletionCost) [.pcpWMAgrep.main.app.dcost get]
    set ::ProgramInfo(wmagrep,SubstitutionCost) [.pcpWMAgrep.main.app.scost get]
    if {$::wmagrepCasIns} {
	set ::ProgramInfo(wmagrep,CaseInsensitiveP) 1
    } else {
	set ::ProgramInfo(wmagrep,CaseInsensitiveP) 0
    }
    if {$::wmagrepBesRes} {
	set ::ProgramInfo(wmagrep,BestResults) 1
    } else {
	set ::ProgramInfo(wmagrep,BestResults) 0
    }
}

option add  *pcpZsh.*Background $::ColorSpecs(ProgramSpecificControls,Background) 100;
option add  *pcpZsh.*Foreground $::ColorSpecs(ProgramSpecificControls,Foreground) 100;
option add  *pcpZsh.*activeBackground $::ColorSpecs(ProgramSpecificControls,ActiveBackground) 100;
option add  *pcpZsh.*activeForeground $::ColorSpecs(ProgramSpecificControls,ActiveForeground) 100;
option add  *pcpZsh.*selectColor $::ColorSpecs(ProgramSpecificControls,Select) 100;
option add  *pcpZsh.*Entry.Background $::ColorSpecs(ProgramSpecificControls,EntryBackground) 100;
option add  *pcpZsh.*Entry.disabledBackground $::ColorSpecs(ProgramSpecificControls,DisabledEntryBackground) 100;

proc PopupZshControls {} { 
    set w .pcpZsh
    if {[winfo exist .pcpZsh]} {
	if {![winfo ismapped .pcpZsh]} {
	    wm deiconify .pcpZsh;
	    raise .pcpZsh
	} else {
	    wm iconify .pcpZsh;
	}
	return ;
    }
    toplevel $w -borderwidth 4 -relief raised
    wm title $w Zsh
    after idle {
	raise .pcpZsh
	update idletasks
	set xmax [winfo screenwidth .pcpZsh]
	set ymax [winfo screenheight .pcpZsh]
	set x0 [expr int( rand() * double($xmax -[winfo reqwidth  .pcpZsh]))];
	set y0 [expr int( rand() * double($ymax -[winfo reqheight .pcpZsh]))];
	wm geometry .pcpZsh "+$x0+$y0";
    }
    set genmsg [_ "Set command-line options for Zsh."]
    set title [_ "Zsh Settings"]
    if {[FeaturesUnSetP zsh $::InterfaceLocale]} {
	append title \n[_ "(untested)"]
    }
    label $w.title -text $title  -font PopupTitleFont 
    frame $w.main
    checkbutton $w.main.zshKornQuantifiersPckb -text [_ "Korn Shell Extensions"] \
	-variable ProgramInfo(zsh,KornQuantifiersP) -onvalue 1 -offvalue 0
    checkbutton $w.main.zshExtendedGlobPckb -text [_ "Extended Glob"] \
	-variable ProgramInfo(zsh,ExtendedGlobP) -onvalue 1 -offvalue 0
    grid $w.main.zshKornQuantifiersPckb -row 0 -column 0 -sticky w -pady 2
    grid $w.main.zshExtendedGlobPckb -row 2 -column 0 -sticky w -pady 2

    frame $w.cntls
    button $w.cntls.dis -text [_ "Dismiss"] -command [list destroy $w]
    pack $w.cntls.dis -side left -expand 0 -fill none -padx 4
    pack $w.title -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.main  -side top -expand 1 -fill both -pady 4     -padx 10
    pack $w.cntls -side top -expand 1 -fill both -pady {8 4} -padx 10
    balloonhelp_for $w $genmsg
    balloonhelp_for $w.title $genmsg
    balloonhelp_for $w.main $genmsg
    balloonhelp_for $w.cntls $genmsg
    set msg [_ "Recognize Korn shell style quantifiers?"]
    balloonhelp_for $w.main.zshKornQuantifiersPckb $msg;
    set msg [_ "Press this button to dismiss the popup."]
    balloonhelp_for $w.cntls.dis $msg
    set msg [_ "Recognize extended glob notation?"]
    balloonhelp_for $w.main.zshExtendedGlobPckb $msg;
}

proc PopupCurrentProgramControls {{InteractiveP 1}} {
    set FunctionName Popup${::Program}Controls;
    if {[info commands $FunctionName] != ""} {
	eval $FunctionName
    } else {
	if {$InteractiveP} {
	    ShowMessage [_ "The current program, $::Program, has no settable parameters."]
	}
    }
}

proc UpdateProgramControlPanel {} {
    set PreviousPanel .${::PreviousProgram}cp
    if {[winfo exists $PreviousPanel]} {
	destroy $PreviousPanel;
	PopupCurrentProgramControls 0;
    }
}

#Here are the procedures that execute the individual programs.

proc ExecuteMatchAgrep {args} {
    global TestFile;
    global CommandFile;

    set re [lindex $args 0]

#This is a temporary kludge to prevent agrep from crashing redet during
#feature testing when it hits the test for integer ranges, or if for some
#other reason a user includes a "<" in an expression. The real solution
#is to pass the regular expression through a file so that exec doesn't see it
#or to fix Tcl. 

    if {[string first "<" $re] == 0} {
	dmsg "Encountered a \"<\" in regexp $re";
	return "";
    }

#    set cl [list agrep -N]
    set cl [list agrep]

    if {$::ProgramInfo(agrep,CaseInsensitiveP)} {
	lappend cl -i
    }
    if {$::ProgramInfo(agrep,BestResults)} {
	lappend cl -B
	lappend cl -y
    }
    if {$::ProgramInfo(agrep,TotalCost) > 0} {
	lappend cl -A$::ProgramInfo(agrep,TotalCost)
	lappend cl -D$::ProgramInfo(agrep,DeletionCost)
	lappend cl -I$::ProgramInfo(agrep,InsertionCost)
	lappend cl -S$::ProgramInfo(agrep,SubstitutionCost)
    }

    if {[llength $args] > 1} {
	set extras [split [lindex $args 1]]
	foreach x $extras {
	    lappend cl $x;
	}
    }
    lappend cl $re;
    lappend cl $TestFile;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchWMAgrep {args} {
    global TestFile;
    global CommandFile;

    set re [lindex $args 0]

#This is a temporary kludge to prevent agrep from crashing redet during
#feature testing when it hits the test for integer ranges, or if for some
#other reason a user includes a "<" in an expression. The real solution
#is to pass the regular expression through a file so that exec doesn't see it
#or to fix Tcl. 

    if {[string first "<" $re] == 0} {
	dmsg "Encountered a \"<\" in regexp $re";
	return "";
    }

#    set cl [list agrep -N]
    set cl [list wmagrep]

    if {$::ProgramInfo(wmagrep,CaseInsensitiveP)} {
	lappend cl -i
    }
    if {$::ProgramInfo(wmagrep,BestResults)} {
	lappend cl -B
	lappend cl -y
    }
    if {$::ProgramInfo(wmagrep,TotalCost) > 0} {
	lappend cl -A$::ProgramInfo(wmagrep,TotalCost)
	lappend cl -D$::ProgramInfo(wmagrep,DeletionCost)
	lappend cl -I$::ProgramInfo(wmagrep,InsertionCost)
	lappend cl -S$::ProgramInfo(wmagrep,SubstitutionCost)
    }

    if {[llength $args] > 1} {
	set extras [split [lindex $args 1]]
	foreach x $extras {
	    lappend cl $x;
	}
    }
    lappend cl $re;
    lappend cl $TestFile;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc CheckRegexpAvailabilityArena {} {
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    puts $CommandHandle "if (!pcre_supported())\{exit(2)\}\nexit(0);";
    close $CommandHandle; 
    set cl [list arena]
    lappend cl $CommandFile
    set cl [linsert $cl 0 "tk_exec"]
    if {[catch {eval $cl}] == 0} {
	return 1;
    } else {
	return 0;
    }
}

proc ExecuteMatchArena {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "restr=\"$re\";\nopts=0";
    if {$::ProgramInfo(arena,CaseInsensitiveP)} {append cmd "|PCRE_CASELESS"}
    if {$::ProgramInfo(arena,VerboseP)} {append cmd "|PCRE_EXTENDED"}
    append cmd ";
re = pcre_compile(restr,opts);
if(is_void(re)) exit(2);\n
while (!feof(stdin)) \{
  line=fgets(stdin);
  if(is_void(line)) break;
  if (pcre_match(re,line,0)) print(line);
\}
exit(0);\n"
    puts $CommandHandle $cmd;
    close $CommandHandle; 

    set cl [list arena]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchAwk {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\$0 ~ /$re/ {print \$0}"
    puts $CommandHandle $cmd;
    close $CommandHandle; 

    set cl [list awk]
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubAwk {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "\{print gensub(/%s/,\"%s\",1)\}" $re $sub];
    puts $CommandHandle $cmd;
    close $CommandHandle;

    set cl [list awk]
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchBash {re} {
    global ShellItemLimit;
    global TestFile;
    global TempGlobDir;
    global CommandFile;

    #Read test data back in, storing in array, one line at a time;
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to read test data back in from %s."] $TestFile];
	error "ExecuteMatchBash";
    }
    set LineCount 0
    while { [gets $TempDataHandle line] > 0} {
	incr LineCount;
	set TestLines($LineCount) $line
    }
    close $TempDataHandle;

    if {$LineCount >= $ShellItemLimit} {
	ShowMessage [format [_ "%1\$d items exceeds limit of %2\$d  for shells."] $LineCount $ShellItemLimit]
	#Delay so that user will get a chance to read above message.
	after 1000;
	error [format "ExecuteMatchBash: %s" [_ "item limit exceeded"]];
    } 

    #Clean out this directory if it already exists. 
    file delete -force $TempGlobDir;
    file mkdir $TempGlobDir;
    for {set i 1} {$i <= $LineCount} {incr i} {
	set NewFile [file join $TempGlobDir $TestLines($i)];
	if {[catch {open  $NewFile "w"} TempDataHandle] != 0} { 
	    WriteJournal [format [_ "Unable to open file %s."] $NewFile];
	    continue ;
	} else {
	    puts $TempDataHandle "x";
	    close $TempDataHandle;
	}
    }
    set cl [list bash]
    if {$::ProgramInfo(bash,ExtendedP)} {
	lappend cl "-O"
	lappend cl "extglob"
    }
    if {$::ProgramInfo(bash,CaseInsensitiveGlobP)} {
	lappend cl "-O"
	lappend cl "nocaseglob"
    }
    if {$::ProgramInfo(bash,CaseInsensitiveMatchP)} {
	lappend cl "-O"
	lappend cl "nocasematch"
    }
    lappend cl "-s"
    lappend cl "<"
    lappend cl $CommandFile

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    regsub -all ";" $re "\\;" qre
    set cmd "cd $TempGlobDir;ls $qre"
    puts $CommandHandle $cmd;
    close $CommandHandle;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchBoo {re} {
    global TestFile;
    global CommandFile;

    set cl [list boo]

    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }

set cmd "
import System.IO
try:
	cre = @/$re/
	using input = StreamReader($TestFile):
	      for line in input:
	      	  line = line.Trim()
		    	  if cre.Match(line).Success:
			  	        print line
except e:
       print \"Error\", e.ToString()
";

    puts $CommandHandle $cmd
    close $CommandHandle;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $re]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}

proc ExecuteMatchBusyBoxEgrep {re} {
    global TestFile;
    global CommandFile;

    set cl [list busybox grep -E]

    if {$::ProgramInfo(BusyBoxEgrep,CaseInsensitiveP)} {
	lappend cl -i
    }
    if {$::ProgramInfo(BusyBoxEgrep,Complement)} {
	lappend cl -v
    }
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    puts $CommandHandle $re
    close $CommandHandle;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $re]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}

proc CQuote {s} {
    return [string map {"\\" "\\\\" "\#" "\\\\#" "\n" "\\n" \" \\\"} $s]
}

proc ExecuteMatchC {re} {
    global TestFile;
    global CommandFile;
    global CSourceFile;

    set qre [CQuote $re]

    #Write the C program out to a file
    if {[catch {open $CSourceFile "w"} CSourceHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CSourceFile];
	error "";
    }
    set cmd "\#include <stdlib.h>
\#include <stdio.h>
\#include <string.h>
\#include <regex.h>
";

set cmdPart2 "\#define IBUFSIZE  10240
\#define REBUFSIZE 10240
static char ibuf\[IBUFSIZE+1\];
static char re\[REBUFSIZE+1\];
int main(int ac, char **av) {
  FILE *refp;
  regex_t rx;
  int li;
  if (regcomp(&rx,\"$qre\",REG_NEWLINE|REG_NOSUB|REG_EXTENDED) != 0) exit(3);
  while (fgets(ibuf,IBUFSIZE,stdin) != NULL)  {
      li = strlen(ibuf) -1; 
      if(ibuf\[li\] == \'\\n\') ibuf\[li\] = \'\\0\';
      if(regexec(&rx,ibuf,0,NULL,0) == 0) puts(ibuf);
  }
  exit(0);
}";

    append cmd "\#ifndef _POSIX_C_SOURCE
\#define _POSIX_C_SOURCE
\#endif
";# Force POSIX regexps even if gnu libc

    append cmd $cmdPart2
    puts $CSourceHandle $cmd;
    close $CSourceHandle; 

    #Compile the C program
    if {[catch {exec cc -o $CommandFile $CSourceFile}] != 0} {
	ShowMessage [format [_ "Unable to compile C program with regexp %s (%s)."] $re $qre]
	error "";
    }

    #Execute the C program
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchCgrep {args} {
    global TestFile;
    global CommandFile;

    set re [lindex $args 0]
    set cl [list cgrep]

    if {$::ProgramInfo(cgrep,ExtendedP)} {
	lappend cl -E; 
    }
    if {$::ProgramInfo(cgrep,CaseInsensitiveP)} {
	lappend cl -i
    }
    if {$::ProgramInfo(cgrep,Complement)} {
	lappend cl -v
    }
    lappend cl -A
    lappend cl $::ProgramInfo(cgrep,TotalCost);
    lappend cl +C
    lappend cl $::ProgramInfo(cgrep,InsertionCost);
    lappend cl -C
    lappend cl $::ProgramInfo(cgrep,DeletionCost);
    lappend cl +-C
    lappend cl $::ProgramInfo(cgrep,SubstitutionCost);
    if {[llength $args] > 1} {
	set extras [split [lindex $args 1]]
	foreach x $extras {
	    lappend cl $x;
	}
    }
    lappend cl -f
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd $re;
    puts $CommandHandle $cmd; 
    close $CommandHandle;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}

proc ExecuteMatchEd {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "g/$re/";
    puts $CommandHandle $cmd; 
    close $CommandHandle;

    set cl [list ed]
    lappend cl "-s"
    lappend cl $TestFile
    lappend cl "<"
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubEd {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "1,\$s/$re/$sub/g\n1,\$p";
    puts $CommandHandle $cmd;
    close $CommandHandle;

    set cl [list ed]
    lappend cl "-s"
    lappend cl $TestFile
    lappend cl "<"
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchEgrep {re} {
    global TestFile;
    global CommandFile;

    set cl [list egrep]

    if {$::ProgramInfo(egrep,CaseInsensitiveP)} {
	lappend cl -i
    }
    if {$::ProgramInfo(egrep,EmitMatchOnly)} {
	lappend cl -o
    }
    if {$::ProgramInfo(egrep,Complement)} {
	lappend cl -v
    }
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    puts $CommandHandle $re
    close $CommandHandle;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $re]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}

proc ExecuteMatchGlark {re} {
    global TestFile;
    global CommandFile;

    set cl [list glark]
    lappend cl -h;			# Suppress listing of names of matching files
    lappend cl -q;			# Suppress warnings
    lappend cl -U;			# Suppress highlighting
    lappend cl -N;			# Suppress linenumbers
    if {$::ProgramInfo(glark,CaseInsensitiveP)} {
	lappend cl -i
    }
    if {$::ProgramInfo(glark,EmitMatchOnly)} {
	lappend cl -y;			# Output only the matching region, not the entire line
    }
    if {$::ProgramInfo(glark,Complement)} {
	lappend cl -v;			# Output only the lines that do not match.
    }
    if {$::ProgramInfo(glark,MatchEntireLine)} {
	lappend cl -x;			# Output only the lines that match the entire line.
    }

    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    puts $CommandHandle $re
    close $CommandHandle;
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $re]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}

proc ExecuteMatchGrep {re} {
    global TestFile;
    global CommandFile;

    set cl [list grep]

    set Which $::ProgramInfo(grep,Notation);
    switch -exact -- $Which {
	Basic  {lappend cl "-G"}
	Extended {lappend cl "-E"}
	Perl {lappend cl "-P"}
    }
    if {$::ProgramInfo(grep,CaseInsensitiveP)} {
	lappend cl -i
    }
    if {$::ProgramInfo(grep,EmitMatchOnly)} {
	lappend cl -o
    }
    if {$::ProgramInfo(grep,Complement)} {
	lappend cl -v
    }
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    puts $CommandHandle $re
    close $CommandHandle;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $re]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}


proc ExecuteMatchEmacs {re} {
    global TestFile;
    global CommandFile;
    global EmacsOutputFile;
    global EmacsWrapper;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "(defun append-to-buffer-with-nl (buffer start end)\n\"Append to specified buffer the text between start and end.\"\n\t(let ((oldbuf (current-buffer)))\n\t(save-current-buffer\n\t\t(set-buffer (get-buffer-create buffer))\n\t\t(insert-buffer-substring oldbuf start end)\n\t\t(insert \"\\n\"))))\n(defun print-regexp-matches (pattern)\n\t\"Print the lines matching a regexp\"\n(set-variable 'case-fold-search nil)\n\t(goto-char (point-min))\n\t(while (re-search-forward pattern nil t 1)\n\t\t(append-to-buffer-with-nl \"output\" (line-beginning-position) (line-end-position)))\n(set-buffer (get-buffer-create \"output\"))\n(write-file \"%s\"))\n(print-regexp-matches \"%s\")\n" $EmacsOutputFile $re];
    puts $CommandHandle $cmd;
    close $CommandHandle;

    set cl [list bash]
    lappend cl $EmacsWrapper
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubEmacs {re sub} {
    global TestFile;
    global CommandFile;
    global EmacsOutputFile;
    global EmacsWrapper;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    if {$::ProgramInfo(emacs,FoldCaseMatchP)} {
	set MatchCaseFlag "t";
    } else {
	set MatchCaseFlag "nil";
    }
    if {$::ProgramInfo(emacs,FoldCaseReplaceP)} {
	set ReplaceCaseFlag "t";
    } else {
	set ReplaceCaseFlag "nil";
    }
    set cmd [format \
		 "(set-variable 'case-fold-search %s)\n(goto-char (point-min))\n(while (re-search-forward \"%s\" nil t)\n\t(replace-match \"%s\" %s nil))\n(write-file \"%s\")\n" \
		 $MatchCaseFlag $re $sub $ReplaceCaseFlag $EmacsOutputFile];
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list bash]; #This is correct. We need a shell.
    lappend cl $EmacsWrapper
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchEuphoria {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "include wildcard.e\nobject line\nwhile 1 do\n\tline = gets(0)\n\tif atom(line) then\n\t\texit\n\tend if\n\tline = line\[1..length(line)-1\]\n\tif wildcard_match(\"$re\",line) then\n\t\tputs(1,line)\n\t\tputs(1,'\\n')\n\tend if\nend while\n";
    puts $CommandHandle $cmd
    close $CommandHandle;

    set cl [list exu]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchExpr {re} {
    global TestFile;

    #Read test data back in, storing in list, one line at a time;
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to read test data back in from %s."] $TestFile];
	error "ExecuteMatchExpr";
    }
    set TestLines [list]
    while { [gets $TempDataHandle line] > 0} {
	lappend TestLines $line
    }
    close $TempDataHandle;

    set Result [list]
    if {[string match $::ExecutionFlag Normal] == 0} {return "N/A"}
    foreach dl $TestLines {
	set cl [list tk_exec]
	lappend cl expr
	lappend cl "$dl"
	lappend cl :
	lappend cl "$re"
	catch {eval $cl} res
	if {$res > 0} {
	    lappend Result $dl
	}
    }
    return [join $Result "\n"];
}

proc ExecuteMatchFgrep {re} {
    global TestFile;
    global CommandFile;

    set cl fgrep
    if {$::ProgramInfo(fgrep,CaseInsensitiveP)} {
	lappend cl "-i"
    }
    if {$::ProgramInfo(fgrep,EmitMatchOnly)} {
	lappend cl "-o"
    }
    if {$::ProgramInfo(fgrep,Complement)} {
	lappend cl "-v"
    }
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    puts $CommandHandle $re
    close $CommandHandle;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $re]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}

proc ExecuteMatchFish {re} {
    global ShellItemLimit;
    global TempGlobDir;
    global TestFile;
    global CommandFile;

    #Read test data back in, storing in array, one line at a time;
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to read test data back in from %s."] $TestFile];
	error "ExecuteMatchFish";
    }
    set LineCount 0;
    while { [gets $TempDataHandle line] > 0} {
	incr LineCount
	set TestLines($LineCount) $line
    }
    close $TempDataHandle;

    if {$LineCount > $ShellItemLimit} {
	ShowMessage [format [_ "%1\$d items exceeds limit of %2\$d  for shells."] $LineCount $ShellItemLimit];
	puts [format "%d items exceeds limit of %d  for shells." $LineCount $ShellItemLimit]
	#Delay so that user will get a chance to read above message. 
	after 5000;
	error [format "ExecuteMatchFish: %s" [_ "item limit exceeded"]];
    } 

    #Clean out this directory if it already exists. Then create files.
    file delete -force $TempGlobDir;
    file mkdir $TempGlobDir;
    for {set i 1} {$i <= $LineCount} {incr i} {
	set NewFile [file join $TempGlobDir $TestLines($i)];
	if {[catch {open  $NewFile "w"} TempDataHandle] != 0} { 
	    WriteJournal [format [_ "Unable to open file %s."] $NewFile];
	    continue ;
	} else {
	    puts $TempDataHandle "x";
	    close $TempDataHandle;
	}
    }

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "cd $TempGlobDir\nls -1 $re"
    puts $CommandHandle $cmd
    close $CommandHandle;

    set cl [list fish < $CommandFile]
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    return  [eval $cl]
}

proc ExecuteMatchFrink {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "for line = lines\[\"file:$TestFile\",\"UTF-8\"\]\n\tif (line =~ %r/$re/)\n\t\tprintln\[line\]\n"
    puts $CommandHandle $cmd
    close $CommandHandle;

    set cl [list java]
    lappend cl -cp
    lappend cl frink.jar
    lappend cl frink.parser.Frink
 #   lappend cl --nounits
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubFrink {re se} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "for line = lines\[\"file:$TestFile\",\"UTF-8\"\]\n{\n\tline =~ %s/$re/$se/g\n\tprintln\[line\]\n}\n"
    puts $CommandHandle $cmd
    close $CommandHandle;

    set cl [list java]
    lappend cl -cp
    lappend cl frink.jar
    lappend cl frink.parser.Frink
#    lappend cl --nounits
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}


proc ExecuteMatchGawk {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\$0 ~ /$re/ {print \$0}";
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list gawk]
    set Which $::ProgramInfo(gawk,Notation);
    switch -exact -- $Which {
	Traditional  {lappend cl "--traditional"}
	Posix {lappend cl "--posix"}
    }
    if {$::ProgramInfo(gawk,CaseInsensitiveP)} {
	lappend cl -v
	lappend cl IGNORECASE=1
    }
    if {$::ProgramInfo(gawk,IntervalExpressions)} {
	lappend cl --re-interval
    }
    lappend cl "-f"
    lappend cl "$CommandFile"
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return  [eval $cl];

}

proc ExecuteSubGawk {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "\{print gensub(/%s/,\"%s\",1)\}" $re $sub];
    puts $CommandHandle $cmd;
    close $CommandHandle; 

    set cl [list gawk]
    set Which $::ProgramInfo(gawk,Notation);
    switch -exact -- $Which {
	Traditional  {lappend cl "--traditional"}
	Posix {lappend cl "--posix"}
    }
    if {$::ProgramInfo(gawk,IntervalExpressions)} {
	lappend cl "--re-interval"
    }
    if {$::ProgramInfo(gawk,CaseInsensitiveP)} {
	lappend cl -v
	lappend cl IGNORECASE=1
    }
    lappend cl "-f"
    lappend cl "$CommandFile"
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return  [eval $cl];
}

proc ExecuteMatchGroovy {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "lines = System.in.readLines()
for (line in lines) {
    if ( line ==~ /$re/ ) println line
}"
    puts $CommandHandle $cmd
    close $CommandHandle;

    set cl [list groovy]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchGuile {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "(use-modules (ice-9 rdelim))\n(define line \#f)\n(define re\n\t  (catch 'regular-expression-syntax\n\t\t(lambda () (make-regexp \"$re\"))\n\t\t(lambda (key . args)\n\t\t\t(begin\n\t\t\t\t(write-line \"regular expression syntax error\" (current-error-port))\n\t\t\t\t(quit 2)))))\n(while (begin (set! line (read-line)) (not (eof-object? line)))\n\t(if (regexp-exec re line)\n\t\t(write-line line)))\n";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list guile];
    lappend cl -s
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return  [eval $cl];
}

proc ExecuteSubGuile {re se} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "(use-modules (ice-9 rdelim) (ice-9 regex))\n(define line \#f)\n(while (begin (set! line (read-line)) (not (eof-object? line)))\n\t(write-line\n\t (catch 'regular-expression-syntax\n\t\t(lambda () (regexp-substitute/global \#f \"$re\" line $se))\n\t\t\t(lambda (key . args)\n\t\t\t\t (begin\n\t\t\t\t\t(write-line \"regular expression syntax error\" (current-error-port))\n\t\t\t\t\t\t(quit 2))))))";
    puts $CommandHandle $cmd; 
    close $CommandHandle;
    set cl [list guile];
    lappend cl -s
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return  [eval $cl];
}

proc ExecuteMatchIci {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set flags 0
    if {$::ProgramInfo(ici,CaseInsensitiveP)} {
	set flags [expr $flags | 0x01]
    }
    if {$::ProgramInfo(ici,VerboseP)} {
	set flags [expr $flags | 0x08]
    }
    set cmd "rx = regexp(\"$re\",$flags);
while (line = getline(stdin)) \{
     if (line \~ rx) \{
       printf(\"%s\\n\",line);
     \}
\}
";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list ici]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchIcon {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "link regexp\nprocedure main()\n\tlocal line, rep\n\tif (rep:=RePat(\"$re\")) then {\n\t\twhile (line := read()) do\n\t\t\tif ReFind(rep,line) then write(line)\n\t\treturn 0\n\t}\n\treturn 1\nend\n";
    puts $CommandHandle $cmd;
    close $CommandHandle; 

    set cl [list icon]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchJava {re} {
    global TestFile;
    global TempDir;
    global FeatureTestLogHandle;
    global TestingFeaturesP;
    global CommandFile;

    set FLAGS 0;
    if {$::ProgramInfo(java,CanonEQ)} {
	append FLAGS {|Pattern.CANON_EQ}
    }
    if {$::ProgramInfo(java,CaseInsensitiveP)} {
	append FLAGS {|Pattern.CASE_INSENSITIVE}
    } elseif {$::ProgramInfo(java,UnicodeCase)} {
	append FLAGS {|Pattern.CASE_INSENSITIVE|Pattern.UNICODE_CASE}
    }

    set cmd \
	"import java.io.*;\nimport java.util.regex.*;\npublic class $::JavaMatchClassName {\n\tpublic static void main(String\[\] args) {\n\t\tString thisLine;\n\t\tString regexp = (args\[0\]).substring(1);\n\t\ttry {\n\t\t\tPattern p = Pattern.compile(regexp,$FLAGS);\n\t\t\tMatcher m;\n\t\t\ttry {\n\t\t\t\tBufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n\t\t\t\twhile ( (thisLine = in.readLine()) != null) {\n\t\t\t\t\tm = p.matcher(thisLine);\n\t\t\t\t\tif(m.matches()) System.out.println(thisLine);\n\t\t\t\t}\n\t\t\t}\n\t\t\tcatch (IOException e) {\n\t\t\t\tSystem.err.println(\"Error: \" + e);\n\t\t\t\tSystem.exit(2);\n\t\t\t}\n\t\t\tSystem.exit(0);\n\t\t}\n\t\tcatch (PatternSyntaxException e) {\n\t\t\tSystem.err.println(\"Error: \" + e);\n\t\t\tSystem.exit(1);\n\t\t}\n\t}\n}\n";
    if { ([file exists $::JavaMatchClassFile] == 0) || ($::UpdateJavaByteCodeP)} {
	if {[catch {open $::JavaMatchFile "w"} JavaHandle ] != 0} {
	    ShowMessage [format [_ "Unable to open file %s."] $::JavaMatchFile];
	    error [format [_ "Unable to open %s"] $::JavaMatchFile];
	}
	puts $JavaHandle $cmd;
	close $JavaHandle;
	# Byte compile the java source
	if { [catch {tk_exec javac $::JavaMatchFile}] != 0} {
	    if {$TestingFeaturesP} {
		if {$FeatureTestLogHandle != ""} {
		    puts $FeatureTestLogHandle [format "\t%s" [_ "Java compilation failed."]];
		}
	    } else {
		ShowMessage [_ "Java compilation failed."];
	    }
	    error [_ "Java compilation failed."];
	}
	set ::UpdateJavaByteCodeP 0;
    }
    set cl [list java]
    lappend cl "-classpath"
    lappend cl $TempDir
    lappend cl $::JavaMatchClassName
    set pre "\\"
    append pre $re
    lappend cl "$pre"
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubJava {re sub} {
    global TestFile;
    global TempDir;
    global FeatureTestLogHandle;
    global TestingFeaturesP;
    global CommandFile;

    set FLAGS 0;
    if {$::ProgramInfo(java,CanonEQ)} {
	append FLAGS {|Pattern.CANON_EQ}
    }
    if {$::ProgramInfo(java,CaseInsensitiveP)} {
	append FLAGS {|Pattern.CASE_INSENSITIVE}
    } elseif {$::ProgramInfo(java,UnicodeCase)} {
	append FLAGS {|Pattern.CASE_INSENSITIVE|Pattern.UNICODE_CASE}
    }

    set cmd \
	"import java.io.*;\nimport java.util.regex.*;\npublic class $::JavaSubClassName {\n\tpublic static void main(String\[\] args) {\n\t\tString thisLine;\n\t\tString regexp = (args\[0\]).substring(1);\n\t\tString sub = (args\[1\]).substring(1);\n\t\ttry {\n\t\t\tPattern p = Pattern.compile(regexp,$FLAGS);\n\t\t\tMatcher m;\n\t\t\ttry {\n\t\t\t\tBufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n\t\t\t\twhile ( (thisLine = in.readLine()) != null) {\n\t\t\t\t\tm = p.matcher(thisLine);\n\t\t\t\t\tSystem.out.println(m.replaceAll(sub));\n\t\t\t\t}\n\t\t\t}\n\t\t\tcatch (IOException e) {\n\t\t\t\tSystem.err.println(\"Error: \" + e);\n\t\t\t\tSystem.exit(2);\n\t\t\t}\n\t\t\tSystem.exit(0);\n\t\t}\n\t\tcatch (PatternSyntaxException e) {\n\t\t\tSystem.err.println(\"Error: \" + e);\n\t\t\tSystem.exit(1);\n\t\t}\n\t}\n}\n";

    if { ([file exists $::JavaSubClassFile] == 0) || ($::UpdateJavaByteCodeP)} {
	if {[catch {open $::JavaSubFile "w"} JavaHandle ] != 0} {
	    error [format [_ "Unable to open %s"] $::JavaSubFile];
	}
	puts $JavaHandle $cmd;
	close $JavaHandle;
	# Byte compile the java source
	if { [catch {tk_exec javac $::JavaSubFile}] != 0} {
	    if {$TestingFeaturesP} {
		if {$FeatureTestLogHandle != ""} {
		    puts $FeatureTestLogHandle [format "\t%s" [_ "Java compilation failed."]];
		}
	    } else {
		ShowMessage [_ "Java compilation failed."];
	    }
	    error [_ "Java compilation failed."];
	}
	set ::UpdateJavaByteCodeP 0;
    }
    set cl [list java]
    lappend cl "-classpath"
    lappend cl $TempDir
    lappend cl $::JavaSubClassName
    set pre "\\"
    append pre $re
    lappend cl "$pre"
    set psub "\\"
    append psub $sub
    lappend cl "$psub"
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchJavascript {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "var re = new RegExp (\"$re\");\nwhile (!System.stdin.eof()){\n\tline=System.stdin.readln();\n\tif(re.test (line)){\n\t\tSystem.stdout.write(line);\n\t\tSystem.stdout.write(\"\\n\");\n\t}\n}\nSystem.exit(0);";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list js]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubJavascript {re sub} {
    global TestFile;
    global CommandFile;

    if { [catch {open $CommandFile "w"} CommandHandle] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "while (!System.stdin.eof()){\n\tvar line=System.stdin.readln();\n\tSystem.stdout.write(line.replace(\/$re\/,\"$sub\"));\n\t\tSystem.stdout.write(\"\\n\");\n\t}\nSystem.exit(0);";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list js]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchJgrep {re} {
    global TestFile;
    global CommandFile;

#This is a kludge to prevent jgrep from crashing redet during
#feature testing when it hits the test for integer ranges, or if for some
#other reason a user includes a "<" in an expression. Until Tcl is
#fixed there isn't a lot else to be done since jgrep has no option
#for reading the expression from a file.

    if {[string first "<" $re] == 0} {
	dmsg "Encountered a \"<\" in regexp $re";
	return "";
    }

    set cl [list jgrep]

    if {$::ProgramInfo(jgrep,CaseInsensitiveP)} {
	lappend cl -i
    }
    lappend cl $re
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    #Jgrep insists on generating a line with the filename before the
    #results so we strip the first line.
    set rval [eval $cl];
    return [string range $rval [expr [string first "\n" $rval] + 1] end]
}

proc ExecuteMatchJudoscript {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "while (line=readLine()) != eof {\n\tif (line.matches(\'$re\')) println line;\n}\n";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list java]
    lappend cl -jar
    lappend cl judo.jar
    lappend cl "-q"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubJudoscript {re sub} {
    global TestFile;
    global CommandFile;

    if { [catch {open $CommandFile "w"} CommandHandle] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "while (line=readLine()) != eof {\n\tprintln line.replaceAll(\'$re\',\'$sub\');\n}\n";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list java]
    lappend cl -jar
    lappend cl judo.jar
    lappend cl "-q"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchKsh {re} {
    global ShellItemLimit;
    global TestFile;
    global TempGlobDir;
    global CommandFile;

    #Read test data back in, storing in array, one line at a time;
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to read test data back in from %s."] $TestFile];
	error "ExecuteMatchKsh";
    }
    set LineCount 0
    while { [gets $TempDataHandle line] > 0} {
	incr LineCount;
	set TestLines($LineCount) $line
    }
    close $TempDataHandle;

    if {$LineCount >= $ShellItemLimit} {
	ShowMessage [format [_ "%1\$d items exceeds limit of %2\$d  for shells."] $LineCount $ShellItemLimit]
	#Delay so that user will get a chance to read above message.
	after 1000;
	error [format "ExecuteMatchKsh: %s" [_ "item limit exceeded"]];
    } 

    #Clean out this directory if it already exists. 
    file delete -force $TempGlobDir;
    file mkdir $TempGlobDir;
    for {set i 1} {$i <= $LineCount} {incr i} {
	set NewFile [file join $TempGlobDir $TestLines($i)];
	if {[catch {open  $NewFile "w"} TempDataHandle] != 0} { 
	    WriteJournal [format [_ "Unable to open file %s."] $NewFile];
	    continue ;
	} else {
	    puts $TempDataHandle "x";
	    close $TempDataHandle;
	}
    }
    set cl [list ksh]
    lappend cl "-c"
    regsub -all ";" $re "\\;" qre
    lappend cl "cd $TempGlobDir;ls $qre"
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchLua {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "while true do\n\tlocal dline = io.read(\"*line\")\n\tif dline == nil then break end\n\ti = string.find(dline,\"$re\")\n\tif i ~= nil then print(dline) end\nend\n";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list lua]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubLua {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "while true do\n\tlocal dline = io.read(\"*line\")\n\tif dline == nil then break end\n\tresult, cnt = string.gsub(dline,\"$re\",\"$sub\");\n\tprint(result)\n\tend\n";
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list lua]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

#This is not ready yet. Just getting infrastructure in place.
proc ExecuteMatchM4 {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\$0 ~ /$re/ {print \$0}"
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list m4]
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

#This is not ready yet. Just getting infrastructure in place.
proc ExecuteSubM4 {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "\{gsub(/%s/,\"%s\");print\}" $re $sub];
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list m4]
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

#This is not ready yet. Just getting infrastructure in place.
proc ExecuteMatchGPP {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\$0 ~ /$re/ {print \$0}"
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list gpp]
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

#This is not ready yet. Just getting infrastructure in place.
proc ExecuteSubGPP {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "\{gsub(/%s/,\"%s\");print\}" $re $sub];
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list gpp]
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchMawk {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\$0 ~ /$re/ {print \$0}"
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list mawk]
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubMawk {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "\{gsub(/%s/,\"%s\");print\}" $re $sub];
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list mawk]
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchMinised {re} {
    global TestFile;
    global CommandFile;
    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "/$re/p"
    puts $CommandHandle $cmd;
    close $CommandHandle;

    #The -n flag is necessary since autoprinting results in double output.
    set cl [list minised -n]
    lappend cl "-f"
    lappend cl "$CommandFile"
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubMinised {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cl [list minised]
    if {$::OutputOnlyChangedLinesP} {
	set cmd "s/$re/$sub/gp"
	puts $CommandHandle $cmd;
	lappend cl "-n"
    } else {
	set cmd "s/$re/$sub/g"
	puts $CommandHandle $cmd;
    }
    close $CommandHandle;
    lappend cl "-f"
    lappend cl "$CommandFile"
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchMysql {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to read test data back in from %s."] $TestFile];
	error "ExecuteMatchMysql";
    }
    #Read test data back in, one line at a time, and write out select commands
    set LineCount 0
    set Data [split [string trimright [read $TempDataHandle] "\n"] "\n"];
    close $TempDataHandle;
    if {$::ProgramInfo(mysql,RegexpP)} {
	set MTYPE REGEXP
    } else {
	set MTYPE LIKE
    }
    foreach line $Data {
	puts $CommandHandle "SELECT \'$line\' $MTYPE \'$re\'\;"
    }
    close $CommandHandle;
    set cl [list mysql]
    lappend cl "-B"
    lappend cl "<"
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    #mysql produces for each entry two lines. The first line consists of the
    #data, then the word REGEXP, then the regular expression. The second line
    #is 0 or 1 according as the regexp matched.
    set index 0;
    set Result [list]
    set RawResult [eval $cl]
    foreach {r bool} [split $RawResult "\n"] {
	if {$bool} {
	    append Result [format "%s\n" [lindex $Data $index]]
	}
	incr index
    }
    return $Result;
}

proc ExecuteMatchNawk {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\$0 ~ /$re/ {print \$0}"
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list nawk]
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubNawk {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "\{gsub(/%s/,\"%s\");print\}" $re $sub];
    puts $CommandHandle 
    close $CommandHandle; 
    set cl [list nawk]
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchNrgrep {re} {
    global TestFile;
    global CommandFile;

#This is a kludge to prevent nrgrep from crashing redet during
#feature testing when it hits the test for integer ranges, or if for some
#other reason a user includes a "<" in an expression.

    if {[string first "<" $re] == 0} {
	dmsg "Encountered a \"<\" in regexp $re";
	return "";
    }

    set cl [list nrgrep]

    if {$::ProgramInfo(nrgrep,CaseInsensitiveP)} {
	lappend cl -i
    }
    if {$::ProgramInfo(nrgrep,ComplementP)} {
	lappend cl -v
    }
    if {$::ProgramInfo(nrgrep,TotalCost) > 0} {
	set cs $::ProgramInfo(nrgrep,TotalCost)
	set OptSet 0;
	if {$::ProgramInfo(nrgrep,InsertionsP)} {
	    append cs i
	    set OptSet 1;
	}
	if {$::ProgramInfo(nrgrep,DeletionsP)} {
	    append cs d
	    set OptSet 1;
	}
	if {$::ProgramInfo(nrgrep,SubstitutionsP)} {
	    append cs s
	    set OptSet 1;
	}
	if {$::ProgramInfo(nrgrep,TranspositionsP)} {
	    append cs t
	    set OptSet 1;
	}
	if {$OptSet} {
	    lappend cl "-k"
	    lappend cl $cs
	}
    }
    lappend cl $re
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}

proc ExecuteMatchNumgrep {re} {
    global TestFile;
    global CommandFile;

    set cl [list numgrep]
    if {$::ProgramInfo(numgrep,OutputNumberByNumberP)} {
	lappend cl "-l"
    }
    lappend cl /$re/
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}

proc ExecuteMatchPatmatch {re} {
    global TestFile;

#This is a kludge to prevent nrgrep from crashing redet during
#feature testing when it hits the test for integer ranges, or if for some
#other reason a user includes a "<" in an expression. I can set up a workaround
#for this later by running patmatch through a shell script.

    if {[string first "<" $re] == 0} {
	devmsg "Encountered a \"<\" in regexp $re";
	return "";
    }

    set cl [list perl]
    lappend cl [list patmatch.pl]
    lappend cl -$::ProgramInfo(patmatch,ResidueType)
    lappend cl $re
    lappend cl $TestFile
    lappend cl $::ProgramInfo(patmatch,MismatchNumber)
    lappend cl $::ProgramInfo(patmatch,MismatchTypes)
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    #Patmatch produces two lines for each result. The first contains the indices
    #of the match, the second the match itself. Each match is followed by a space
    #even if it is the only one on the line.
    set RawResultList [split [eval $cl] "\n"]
    set Result [list]
    foreach {indices match} $RawResultList {
	lappend Result [string trim $match]
    }
    return [join $Result "\n"]
}

proc ExecuteMatchPcregrep {re} {
    global TestFile;
    global CommandFile;

    set cl [list pcregrep]
    lappend cl "-u";		# Necessary for Unicode

    if {$::ProgramInfo(pcregrep,CaseInsensitiveP)} {
	lappend cl -i
    }
    if {$::ProgramInfo(pcregrep,EmitMatchOnly)} {
	lappend cl -o
    }
    if {$::ProgramInfo(pcregrep,Complement)} {
	lappend cl -v
    }
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    puts $CommandHandle $re
    close $CommandHandle;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $re]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}

proc ExecuteMatchPerl {re} {
    global TestFile;
    global CommandFile;

    if {$::ProgramInfo(perl,UnicodeLocaleDependentP)} {
	set flags "-C";
    } else {
	set flags "-CSD";
    }
    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "use utf8;\nuse charnames \":full\";\nwhile (\$line = <STDIN>){\n\t\$copy=\$line;\n\tchomp(\$copy);\n\tif(\$copy  =~ /$re/) {\n\t\tprint \$line\n\t}\n}";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list perl]
    lappend cl $flags
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubPerl {re sub} {
    global TestFile;
    global CommandFile;

    if {$::ProgramInfo(perl,UnicodeLocaleDependentP)} {
	set flags "-C";
    } else {
	set flags "-CSD";
    }
    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "use utf8;\nuse charnames \":full\";\nwhile (\$line = <STDIN>){\n\t\$copy=\$line;\n\tchomp(\$copy);\n\t\$_=\$copy;\n\ts/$re/$sub/;\n\tprint \$_ ;\nprint \"\\n\"\n}\n";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list perl]
    lappend cl $flags
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchPhp {re} {
    global TestFile;
    global CommandFile;
    global PHPPCRE;
    global PHPMB;

    set Prelude "";
    if {$PHPPCRE} {
	set PHPfunc "preg_match";
    } else {
	if {$PHPMB} {
	    set PHPfunc "mb_ereg";
	    set Prelude "mb_regex_encoding('UTF-8');";
	} else {
	    set PHPfunc "ereg";
	}
    }
    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "<?php %s\n\$fd = fopen(\"%s\",\"r\");\nwhile(!feof(\$fd)){\n\t\$line = trim(fgets(\$fd,256));\n\tif (%s('%s', \$line)){\n\t\tprintf('%%s\n',\$line);\n\t}\n}\nfclose(\$fd);?>" $Prelude $TestFile $PHPfunc $re];
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list php]
    lappend cl "-f"
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubPhp {re sub} {
    global TestFile;
    global CommandFile;
    global PHPPCRE;
    global PHPMB;

    if {$PHPPCRE} {
	set PHPfunc "preg_replace";
    } else {
	if {$PHPMB} {
	    set PHPfunc "mb_ereg_replace";
	    set Prelude "mb_regex_encoding('UTF-8');";
	} else {
	    set PHPfunc "ereg_replace";
	    set Prelude "";
	}
    }

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "<?php %s\n\$fd = fopen(\"%s\",\"r\");\nwhile(!feof(\$fd)){\n\t\$line = trim(fgets(\$fd,256));\n\t\tprintf('%%s\n',%s('%s','%s',\$line));\n}\nfclose(\$fd);?>" $Prelude $TestFile $PHPfunc $re $sub];
    puts $CommandHandle 
    close $CommandHandle;
    set cl [list php]
    lappend cl "-f"
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchPike {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\#charset UTF-8\nint main()\n{\n\tstring iline;\n\tstring line;\n\tRegexp.PCRE.Plain myre;\n\tmyre = Regexp.PCRE.Plain(\"$re\");\n\twhile ( (iline = Stdio.stdin.gets()) != 0 ){\n\t\tline = utf8_to_string(iline);\n\t\tif (myre->match(line)) write(\"%s\\n\",string_to_utf8(line));\n\t}\n\treturn 0;\n}\n";
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list pike]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubPike {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\#charset UTF-8\nint main()\n{\n\tstring iline;\n\tstring line;\n\tRegexp.PCRE.Plain myre;\n\tmyre = Regexp.PCRE.Plain(\"$re\");\n\twhile ( (iline = Stdio.stdin.gets()) != 0 ){\n\t\tline = utf8_to_string(iline);\n\t\twrite(\"%s\\n\",string_to_utf8(myre->replace(line,\"$sub\")));\n\t}\n\treturn 0;\n}\n";
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list pike]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchPython {re} {
    global CommandFile;
    global TestFile;

    if {$::ProgramInfo(python,RawStringP)} {
	set Prefix "ur";
    } else {
	set Prefix "u";
    }
    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "# -*- coding: UTF-8 -*-\nimport sys\nimport codecs\nfrom re import *\n(utf8_encode, utf8_decode, utf8_reader, utf8_writer) = codecs.lookup('utf-8')\noutfile = utf8_writer(sys.stdout)\ninfile=utf8_reader(open('%s','r'))\nr = compile(%s'%s')\nwhile (1):\n\ttry:\n\t\tline = infile.readline()\n\t\tif line == \"\":\n\t\t\tbreak\n\t\ttline=line.rstrip(\"\\n\")\n\t\tmo=r.match(tline)\n\t\tif mo:\n\t\t\toutfile.write(line)\n\texcept IOError:\n\t\tsys.exit(0)\n\texcept ValueError:\n\t\tsys.stderr.write(\"Invalid UTF-8 encountered.\")\n\t\tsys.exit(1)\n" $TestFile $Prefix $re]
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list python]
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubPython {re sub} {
    global CommandFile;
    global TestFile;

    if {$::ProgramInfo(python,RawStringP)} {
	set Prefix "ur";
    } else {
	set Prefix "u";
    }
    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "# -*- coding: UTF-8 -*-\nimport sys\nimport codecs\nfrom re import *\n(utf8_encode, utf8_decode, utf8_reader, utf8_writer) = codecs.lookup('utf-8')\noutfile = utf8_writer(sys.stdout)\ninfile=utf8_reader(open('%s','r'))\nr = compile(%s'%s')\nwhile (1):\n\ttry:\n\t\tline = infile.readline().rstrip(\"\\n\")\n\t\tif line == \"\":\n\t\t\tbreak\n\t\toutfile.write(r.sub(%s'%s',line))\n\t\toutfile.write('\\n')\n\texcept IOError:\n\t\tsys.exit(0)\n\texcept ValueError:\n\t\tsys.stderr.write(\"Invalid UTF-8 encountered.\")\n\t\tsys.exit(1)\n" $TestFile $Prefix $re $Prefix $sub]
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list python]
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

# This procedure is a bit unusual in that we redirect stderr into a temp file
# from within Rc and then check whether this file is empty. The reason for this
# is that if Rc is given a command like: "ls (?e)foo" (as in the test for the ?e flag)
# it parses this as equivalent to: "ls ?e foo". Since there is no file named "?e"
# it generates a message to that effect on stderr. It then procedes to list "foo"
# on stdout. Inspection of stdout will therefore make it look like the test succeeded.
# One would think that we would detect the error because writing on stderr would cause
# the catch (in ExecuteRegexp) to return a non-zero status, but Rc seems to suppress
# undiverted output to stderr when executed non-interactively. I don't find anything
# to this effect in the manual, but my tests seem to show that this is what it is
# doing. I have therefore used the kludge described above as a way to find out whether
# Rc detected an error.
proc ExecuteMatchRc {re} {
    global ShellItemLimit;
    global TestFile;
    global TempGlobDir;
    global CommandFile;

    #Read test data back in, storing in array, one line at a time;
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to read test data back in from %s."] $TestFile];
	error "ExecuteMatchRc";
    }
    set LineCount 0
    while { [gets $TempDataHandle line] > 0} {
	incr LineCount;
	set TestLines($LineCount) $line
    }
    close $TempDataHandle;

    if {$LineCount >= $ShellItemLimit} {
	ShowMessage [format [_ "%1\$d items exceeds limit of %2\$d  for shells."] $LineCount $ShellItemLimit]
	#Delay so that user will get a chance to read above message.
	after 1000;
	error [format "ExecuteMatchRc: %s" [_ "item limit exceeded"]];
    } 

    #Clean out this directory if it already exists. 
    file delete -force $TempGlobDir;
    file mkdir $TempGlobDir;
    for {set i 1} {$i <= $LineCount} {incr i} {
	set NewFile [file join $TempGlobDir $TestLines($i)];
	if {[catch {open  $NewFile "w"} TempDataHandle] != 0} { 
	    WriteJournal [format [_ "Unable to open file %s."] $NewFile];
	    continue ;
	} else {
	    puts $TempDataHandle "x";
	    close $TempDataHandle;
	}
    }
    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set TempErrorLog [file join $::TempDir "rcerror.log"]
    file delete -force $TempErrorLog
    set cmd "cd $TempGlobDir;ls $re >\[2\] $TempErrorLog"
    puts $CommandHandle $cmd;
    close $CommandHandle;

    set cl [list rc]
    lappend cl "-s"
    lappend cl "<"
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    set rval [eval $cl]
    if {[file exists $TempErrorLog]} {
	if {[file size $TempErrorLog]} {
	    error ""
	}
    }
    return $rval
}

proc ExecuteMatchRebol {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "REBOL \[\n\tTitle: \"Script created by redet.\"\n\]\ndigit: charset \[\#\"0\" - \#\"9\"\]\nlower: charset \[\#\"a\" - \#\"z\"\]\nupper: charset \[\#\"A\" - \#\"Z\"\]\nalpha: union lower upper\nalnum: union alpha digit\nhexlet: charset \"AaBbCcDdEeFf\"\nxdigit: union digit hexlet\nwhile \[line: input\] \[\n\tif parse/all line \[$re\] \[\n\t\tprint line\n\t]\n\]\nquit\n";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list rebol]
    lappend cl -q
    lappend cl -w
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchRep {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "(while (setq line (read-line))
      (setq lastpos (- (length line) 1))
      (if (equal (elt line lastpos) 10)
      	(setq line (substring line 0 lastpos)))
      (if (string-match \"$re\" line)
	  (write standard-output (concat line \"\n\"))))"
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list rep]
    lappend cl "--no-rc"; #Suppress execution of user's init file.
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    lappend cl {2>}
    if {[string equal $::System Unix]} {
	lappend cl "/dev/null"
    } else {
	lappend cl "bitbucket"
    }
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchRuby {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "while line = STDIN.gets\n\tif  /$re/ =~ line then\n\t\tprint line\n\tend\nend\n";
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list ruby]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubRuby {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd [format "while line = STDIN.gets.chomp\n\tprint (line.gsub(/%s/,%%q%s%s%s),\"\\n\")\nend\n" $re $::LeftRubyStringDelimiter $sub $::RightRubyStringDelimiter];
    puts $CommandHandle $cmd;
    close $CommandHandle; 
    set cl [list ruby]
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchSed {re} {
    global TestFile;
    global CommandFile;
    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "/$re/p"
    puts $CommandHandle $cmd;
    close $CommandHandle;

    #The -n flag is necessary since autoprinting results in double output.
    set cl [list sed -n]
    if {$::ProgramInfo(sed,ExtendedRegexp)} {
	lappend cl "-r"
    }
    lappend cl "-f"
    lappend cl "$CommandFile"
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubSed {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cl [list sed]
    if {$::OutputOnlyChangedLinesP} {
	set cmd "s/$re/$sub/gp"
	puts $CommandHandle $cmd;
	lappend cl "-n"
    } else {
	set cmd "s/$re/$sub/g"
	puts $CommandHandle $cmd;
    }
    close $CommandHandle;
    if {$::ProgramInfo(sed,ExtendedRegexp)} {
	lappend cl "-r"
    }
    lappend cl "-f"
    lappend cl "$CommandFile"
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchSgrep {re} {
    global TestFile;
    global CommandFile;

    set cl [list sgrep]
    lappend cl -n;			# Suppress reading of ~/.sgreprc or /usr/lib/sgreprc

    if {$::ProgramInfo(sgrep,CaseInsensitiveP)} {
	lappend cl -i
    }
    lappend cl "-f"
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    lappend cl {2>}
    if {[string equal $::System Unix]} {
	lappend cl "/dev/null"
    } else {
	lappend cl "bitbucket"
    }

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    regsub -all -- \" $re \\\" qre
#    set cmd [format "\'%s\'" $qre]
    set cmd $qre
    puts $CommandHandle $cmd
    close $CommandHandle;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl];
}

proc ExecuteMatchSleep {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\$fh = getConsole();\nwhile (!-eof \$fh) {\n\t\$line = readln(\$fh);\n\tif (\$line ismatch \'$re\') {println (\$line)}\n}\nreturn 0;\n";
    puts $CommandHandle $cmd;
    close $CommandHandle;
    set cl [list java]
    lappend cl "-jar"
    lappend cl sleep.jar
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubSleep {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\$fh = getConsole();\nwhile (!-eof \$fh) {\n\t\$line = readln(\$fh);\n\tprintln(replace(\$line,\'$re\',\'$sub\'));\n}\n";
    puts $CommandHandle $cmd;
    close $CommandHandle;

    set cl [list java]
    lappend cl "-jar"
    lappend cl sleep.jar
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    set res [eval $cl]
    if {[string equal [string range $res end-2 end] "EOF"]} {
	set res [string range $res 0 end-3];
    }
    return $res 
}

proc ExecuteMatchSleepWildcard {re} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "\$fh = getConsole();\nwhile (!-eof \$fh) {\n\t\$line = readln(\$fh);\n\tif (\'$re\' iswm \$line) {println (\$line)}\n}\nreturn 0;\n";
    puts $CommandHandle $cmd;
    close $CommandHandle;

    set cl [list java]
    lappend cl "-jar"
    lappend cl sleep.jar
    lappend cl $CommandFile
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchSsed {re} {
    global TestFile;
    global CommandFile;
    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cmd "/$re/p"
    puts $CommandHandle $cmd;
    close $CommandHandle;

    #The -n flag is necessary since autoprinting results in double output.
    set cl [list ssed -n]
    if {$::ProgramInfo(ssed,POSIX)} {
	lappend cl "--posix"
    }
    switch -exact -- $::ProgramInfo(ssed,RegexpType) {
	extended {
	    lappend cl "-r"
	}
	perl {
	    lappend cl "-R"
	}
    }
    lappend cl "-f"
    lappend cl "$CommandFile"
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubSsed {re sub} {
    global TestFile;
    global CommandFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    set cl [list ssed]
    if {$::OutputOnlyChangedLinesP} {
	set cmd "s/$re/$sub/gp"
	puts $CommandHandle $cmd;
	lappend cl "-n"
    } else {
	set cmd "s/$re/$sub/g"
	puts $CommandHandle $cmd;
    }
    close $CommandHandle;
    if {$::ProgramInfo(ssed,ExtendedRegexp)} {
	lappend cl "-r"
    } elseif {$::ProgramInfo(ssed,POSIX)} {
	lappend cl "--posix"
    } elseif {$::ProgramInfo(ssed,PERL)} {
	lappend cl "-R"
    }
    lappend cl "-f"
    lappend cl "$CommandFile"
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchTcl {re} {
    global TestFile;

    set Result "";
    set MatchCnt 0;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list "Executed internally by tcl."] }

    #Read test data back in, storing in list, one line at a time;
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to open %s."] $TempDataFile];
	error [_ "ExecuteMatchTcl: cannot open data file"];
    }
    set LineCount 0
    while { [gets $TempDataHandle line] > 0} {
	set line [string trimright $line "\n"];
	incr LineCount;
	lappend TestLines $line;
    }
    close $TempDataHandle;

    #Now run regexp against each line;
    lappend cmdbase regexp
    if {$::ProgramInfo(tcl,CaseInsensitiveP)} {lappend cmdbase "-nocase"}
    if {$::ProgramInfo(tcl,ExpandedP)} {lappend cmdbase "-expanded"}
    lappend cmdbase "--"
    lappend cmdbase $re
    for {set i  0} {$i < $LineCount} {incr i} {
	set str [lindex $TestLines $i]
	set cmd $cmdbase
	lappend cmd $str
	lappend cmd match
	if {[eval $cmd] == 1}  {
	    if {$::ProgramInfo(tcl,EmitMatchOnlyP)} {
		append Result $match;
	    } else {
		append Result $str;
	    }
	    append Result "\n";
	    incr MatchCnt;
	}
    }
 
    #If there are no matches, we throw an exception here so as to match
    #the result of executing a child process as we do for the other programs.
    #The exception will be caught by catch() in ExecuteMatchRegexp().
    if {[string equal $Result ""]} {
	error "";
    }
    return [string trimright $Result "\n"];
}

proc ExecuteSubTcl {re sub} {
    global TestFile;

    set Result "";
    set MatchCnt 0;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list "Executed internally by tcl."] }

    #Read test data back in, storing in list, one line at a time;
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to open %s."] $TempDataFile];
	error [_ "ExecuteSubTcl: cannot open data file"];
    }
    set LineCount 0
    while { [gets $TempDataHandle line] > 0} {
	set line [string trimright $line "\n"];
	incr LineCount;
	lappend TestLines $line;
    }
    close $TempDataHandle;

    #Now run regexp against each line;
    lappend cmdbase regsub
    if {$::ProgramInfo(tcl,CaseInsensitiveP)} {lappend cmdbase "-nocase"}
    if {$::ProgramInfo(tcl,ExpandedP)} {lappend cmdbase "-expanded"}
    lappend cmdbase "-all"
    lappend cmdbase "--"
    lappend cmdbase $re
    for {set i  0} {$i < $LineCount} {incr i} {
	set str [lindex $TestLines $i]
	set cmd $cmdbase
	lappend cmd $str
	lappend cmd $sub
	lappend cmd subres
	eval $cmd
	append Result $subres
	append Result "\n";
	if {[string equal $subres $str] !=0} {incr MatchCnt}
    }

    #If there are no matches, we throw an exception here so as to match
    #the result of executing a child process as we do for the other programs.
    #The exception will be caught by catch() in ExecuteMatchRegexp().
    if {[string equal $Result ""]} {
	error "";
    }
    return [string trimright $Result "\n"];
}

proc ExecuteMatchTclGlob {re} {
    global TestFile;

    set Result "";
    set MatchCnt 0;

    if {[string match $::ExecutionFlag Normal] == 0} {return [list "Executed internally by tcl."] }

    #Read test data back in, storing in list, one line at a time;
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to open %s."] $TempDataFile];
	error "";
    }
    set LineCount 0
    while { [gets $TempDataHandle line] > 0} {
	set line [string trimright $line "\n"];
	incr LineCount;
	lappend TestLines $line;
    }
    close $TempDataHandle;

    #Now run regexp against each line;
    for {set i  0} {$i < $LineCount} {incr i} {
	if {[string match $re [lindex $TestLines $i]] == 1}  {
	    append Result [lindex $TestLines $i];
	    append Result "\n";
	    incr MatchCnt;
	}
    }

    #If there are no matches, we throw an exception here so as to match
    #the result of executing a child process as we do for the other programs.
    #The exception will be caught by catch() in ExecuteRegexp().
    if {[string equal $Result ""]} {
	error "";
    }
    return [string trimright $Result "\n"];
}

proc ExecuteMatchTcsh {re} {
    global ShellItemLimit;
    global TempGlobDir;
    global TestFile;
    global CommandFile;

    #Read test data back in, storing in array, one line at a time;
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to read test data back in from %s."] $TestFile];
	error "ExecuteMatchTcsh";
    }
    set LineCount 0;
    while { [gets $TempDataHandle line] > 0} {
	incr LineCount
	set TestLines($LineCount) $line
    }
    close $TempDataHandle;

    if {$LineCount > $ShellItemLimit} {
	ShowMessage [format [_ "%1\$d items exceeds limit of %2\$d  for shells."] $LineCount $ShellItemLimit];
	puts [format "%d items exceeds limit of %d  for shells." $LineCount $ShellItemLimit]
	#Delay so that user will get a chance to read above message. 
	after 5000;
	error [format "ExecuteMatchTcsh: %s" [_ "item limit exceeded"]];
    } 

    #Clean out this directory if it already exists. 
    file delete -force $TempGlobDir;
    file mkdir $TempGlobDir;
    for {set i 1} {$i <= $LineCount} {incr i} {
	set NewFile [file join $TempGlobDir $TestLines($i)];
	if {[catch {open  $NewFile "w"} TempDataHandle] != 0} { 
	    WriteJournal [format [_ "Unable to open file %s."] $NewFile];
	    continue ;
	} else {
	    puts $TempDataHandle "x";
	    close $TempDataHandle;
	}
    }
    set cl [list tcsh]
    lappend cl "-c"
    regsub -all ";" $re "\\;" qre
    lappend cl "cd $TempGlobDir;ls $qre"
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteSubTr {re sub} {
    global TestFile;
    global CommandFile;

#This is a kludge to prevent tr from crashing redet during
#feature testing when it hits the test for integer ranges, or if for some
#other reason a user includes a "<" in an expression. Tr has no way
#to read expressions from a file so we can't shield the "<"
#from Tcl that way. On Unix systems we can execute Tr via a sub shell
#but that may not work on other systems. Need to think about this,
#or hope that Tcl gets fixed soon.

    if {[string first "<" $re] == 0} {
	dmsg "Encountered a \"<\" in regexp $re";
	return "";
    }

    if {[string first "<" $sub] == 0} {
	dmsg "Encountered a \"<\" in subexp $sub";
	return "";
    }

    set cl [list tr]
    if {$::ProgramInfo(tr,Complement)} {
	lappend cl "-c"
    }
    if {$::ProgramInfo(tr,Squeeze)} {
	lappend cl "-s"
    }
    if {$::ProgramInfo(tr,Truncate)} {
	lappend cl "-t"
    }
    lappend cl $re;
    lappend cl $sub;
    lappend cl "<"
    lappend cl $TestFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}

proc ExecuteMatchVim {re} {
    global TestFile;
    global CommandFile;
    global TempOutputFile;

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    file delete $TempOutputFile;
    set cmd "";
    if {$::ProgramInfo(vim,CaseInsensitiveP)} {
	append cmd "set ignorecase\n"
    }
    if {$::ProgramInfo(vim,SmartCaseP)} {
	append cmd "set smartcase\n"
    }
    if {$::ProgramInfo(vim,ListModeP)} {
	append cmd "set list\n"
    }
    append cmd "set encoding=utf-8\ng/$re/.w! >> $TempOutputFile\nq!\n";
    fconfigure $CommandHandle -encoding utf-8
    puts $CommandHandle $cmd; 
    close $CommandHandle;
    set cl [list vim]
    lappend cl "-e";			# Start up in ex mode
    lappend cl "-i";			# Prevent reading ~/.viminfo
    lappend cl "NONE"
    lappend cl "-T";
    lappend cl "dumb"
    lappend cl "-U"
    lappend cl "-NONE"
    lappend cl "-s"
    lappend cl $TestFile
    lappend cl "<"
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    set RawResult "";
    set Result ""
    eval $cl
    if {[catch {open $TempOutputFile "r"} fh] != 0} {
	if {$::DebugP} {
	    ShowMessage [format [_ "Unable to open file %s."] $TempOutputFile];
	}
    } else {
	fconfigure $fh -encoding utf-8
	set RawResult [split [read $fh] "\n"]
    }
    foreach line $RawResult {
	if {$line == ""} {continue}
	lappend Result $line
    }
    return [join $Result "\n"]
}

proc ExecuteSubVim {re sub} {
    global TestFile;
    global CommandFile;
    global TempOutputFile

    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    file delete $TempOutputFile
    set cmd "";
    if {$::ProgramInfo(vim,CaseInsensitiveP)} {
	append cmd "set ignorecase\n"
    }
    if {$::ProgramInfo(vim,SmartCaseP)} {
	append cmd "set smartcase\n"
    }
    if {$::ProgramInfo(vim,ListModeP)} {
	append cmd "set list\n"
    }
    append cmd "set encoding=utf-8\n%s/$re/$sub/"
    if {$::ProgramInfo(vim,SubstitutionGlobalP)} {
	append cmd "g"
    }
    append cmd "\nw $TempOutputFile\nq!\n";
    fconfigure $CommandHandle -encoding utf-8
    puts $CommandHandle $cmd; 
    close $CommandHandle;
    set cl [list vim]
    lappend cl "-e";			# Start up in ex mode
    lappend cl "-i";			# Prevent reading ~/.viminfo
    lappend cl "NONE"
    lappend cl "-T";
    lappend cl "dumb"
    lappend cl "-U"
    lappend cl "-NONE"
    lappend cl "-s"
    lappend cl $TestFile
    lappend cl "<"
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    set RawResult "";
    set Result ""
    eval $cl
    if {[catch {open $TempOutputFile "r"} fh] != 0} {
	if {$::DebugP} {
	    ShowMessage [format [_ "Unable to open file %s."] $TempOutputFile];
	}
    } else {
	fconfigure $fh -encoding utf-8
	set RawResult [split [read $fh] "\n"]
    }
    foreach line $RawResult {
	if {$line == ""} {continue}
	lappend Result $line
    }
    return [join $Result "\n"]
}

proc ExecuteMatchXmlstarlet {re} {
    global TestFile;

    set cl [list xml select]
    lappend cl "$re"
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl]]}
    set cl [linsert $cl 0 "tk_exec"]
    set RawResult "";
    set Result ""
    return [eval $cl]
}

proc ExecuteMatchZsh {re} {
    global ShellItemLimit;
    global TempGlobDir;
    global TestFile;
    global CommandFile;

    #Read test data back in, storing in array, one line at a time;
    if {[catch {open $TestFile "r"} TempDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to read test data back in from %s."] $TestFile];
	error "ExecuteMatchZsh";
    }
    set LineCount 0;
    while { [gets $TempDataHandle line] > 0} {
	incr LineCount
	set TestLines($LineCount) $line
    }
    close $TempDataHandle;

    if {$LineCount > $ShellItemLimit} {
	ShowMessage [format [_ "%1\$d items exceeds limit of %2\$d  for shells."] $LineCount $ShellItemLimit];
#	puts [format "%d items exceeds limit of %d  for shells." $LineCount $ShellItemLimit]
	#Delay so that user will get a chance to read above message. 
	after 5000;
	error [format "ExecuteMatchZsh: %s" [_ "item limit exceeded"]];
    } 

    #Clean out this directory if it already exists. 
    file delete -force $TempGlobDir;
    file mkdir $TempGlobDir;
    for {set i 1} {$i <= $LineCount} {incr i} {
	set NewFile [file join $TempGlobDir $TestLines($i)];
	if {[catch {open  $NewFile "w"} TempDataHandle] != 0} { 
	    WriteJournal [format [_ "Unable to open file %s."] $NewFile];
	    continue ;
	} else {
	    puts $TempDataHandle "x";
	    close $TempDataHandle;
	}
    }
    if {[catch {open $CommandFile "w"} CommandHandle ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] $CommandFile];
	error "";
    }
    if {$::ProgramInfo(zsh,ExtendedGlobP)} {
	append cmd "setopt extendedglob;"
    }
    if {$::ProgramInfo(zsh,KornQuantifiersP)} {
	append cmd "setopt kshglob;"
    }
    regsub -all ";" $re "\\;" qre
    append cmd "cd $TempGlobDir;ls $qre"
    puts $CommandHandle $cmd
    close $CommandHandle;

    set cl [list zsh]
    lappend cl $CommandFile
    if {[string match $::ExecutionFlag Normal] == 0} {return [list [join $cl] $cmd]}
    set cl [linsert $cl 0 "tk_exec"]
    return [eval $cl]
}



#End of the procedures that execute the individual programs.

# Write out the shell script that actually executes emacs.
# This is necessary because emacs writes to a file and we need to get the result
# from stdin.
proc CreateEmacsWrapper {} {
    global EmacsWrapper
    global TestFile;
    global CommandFile;
    global EmacsOutputFile;

    if {[catch {open $EmacsWrapper "w"} EmacsDataHandle ] != 0} {
	ShowMessage [format [_ "Unable to write Emacs wrapper file %s."] $EmacsWrapper];
    }
    puts $EmacsDataHandle [format "emacs -batch -insert %s -l %s -kill >& /dev/null\nemstat=\$?\ncat %s\nexit \$emstat" $TestFile $CommandFile $EmacsOutputFile];
    close $EmacsDataHandle;
}


#Copy a regular expression from the clipboard
#and insert it into the regular expression window

proc LoadRegularExpressionFromClipboard {} {
    set sel "";
    if {[catch {set sel [selection get -selection CLIPBOARD -type UTF8_STRING]}]} {
	ShowMessage [_ "The clipboard is empty."];
	return;
    } else {
	$::REG insert insert $sel;
	ShowMessage [_ "Clipboard contents copied to regular expression window."];
    }
}

#Same as above, but from primary selection.

proc LoadRegularExpressionFromPrimarySelection {} {
    set sel "";
    if {[catch {set sel [selection get -selection PRIMARY -type UTF8_STRING]}]} {
	ShowMessage [_ "The primary selection is empty."];
	return;
    } else {
	$::REG insert insert $sel;
	ShowMessage [_ "Primary selection copied to regular expression window."];
    }
}

#Read a regular expression from a file
#and insert it into the regular expression window

proc LoadRegularExpressionFromFile {} {
    set ReFile [tk_getOpenFile];
    if {$ReFile != ""} {
	if {[catch {open $ReFile "r"} ReHandle ] != 0} {
	    ShowMessage [format [_ "Unable to open regular expression file %s."] [MinimizeFileName $ReFile]];
	    return ;
	}
	if { [gets $ReHandle line] > 0} {
	    $::REG insert insert $line;
	}
	close $ReHandle;
    }
}

proc ClearRegexp {} {
    $::REG  delete 0 end;
    $::SUB delete 0 end;
}

proc ClearInput {} {
    $::IND configure -state normal
    $::IND delete 1.0 end;
    if {!$::INDEditableP} {
	$::IND configure -state disabled
    }
}

proc EditTestInputData {} {
    global InputDataFromWindowP

    $::IND configure -state normal
    set InputDataFromWindowP 1;
    set ::INDEditableP 1;
    focus -force $::IND;
}

proc MoveResultsToTestData {} {
    #Get the result data
    set Results [$::OUT get 1.0 end]
    if {[string trim $Results] == ""} {
	ShowMessage [_ "The result window is empty."]
	return
    }
    #Clear the test data
    $::IND configure -state normal
    $::IND delete 1.0 end;
    #Copy the result data into the test data window
    $::IND insert end $Results
    if {!$::INDEditableP} {
	$::IND configure -state disabled
    }
    #Clear the result window
    $::OUT configure -state normal
    $::OUT delete 1.0 end;
    if {!$::OUTEditableP} {
	$::OUT configure -state disabled
    }
    ShowMessage [_ "Results transferred to test data."]
}

#Copy test data from the clipboard.
proc LoadTestDataFromClipboard {} {
    global InputDataFromWindowP;
    set sel "";

    if {[catch {set sel [selection get -selection CLIPBOARD -type UTF8_STRING]}]} {
	ShowMessage [_ "The clipboard is empty."];
	return;
    }
    $::IND configure -state normal
    $::IND insert insert $sel;
    set InputDataFromWindowP 1;
    if {!$::INDEditableP} {
	$::IND configure -state disabled
    }
    ShowMessage [_ "Loaded test data from clipboard."];
}

proc LoadTestInputData {args} {		# Optional filename argument
    global InData; 
    global InputDataFromWindowP;
    global PipeP;

    if {$PipeP} {
	set new [read stdin];
	set InDataFile [_ "pipe to stdin"];
    } else {
	if {[llength $args] > 0} {
	    set InDataFile [lindex $args 0];
	} else {
	    set InDataFile [tk_getOpenFile];
	}
	if {$InDataFile != ""} {
	    if {[catch {open $InDataFile "r"} InDataHandle ] != 0} {
		ShowMessage [format [_ "Unable to open test input data file %s."] [MinimizeFileName $InDataFile]];
		return;
	    }
	    fconfigure $InDataHandle -encoding $::Pars(TestDataEncoding);
	    set new [read $InDataHandle];
	    close $InDataHandle;
	} else {
	    ShowMessage [_ "No file name specified for test data."];
	    return;
	}
    }
    if {$new == ""} {
	ShowMessage [format [_ "Unable to read test input data from file %s."] \
			 [MinimizeFileName $InDataFile]];
	return;
    }
    $::IND configure -state normal
    $::IND insert insert $new;
    set InputDataFromWindowP 1;
    if {!$::INDEditableP} {
	$::IND configure -state disabled
    }
    ShowMessage [format [_ "Loaded test data from %s."] [MinimizeFileName $InDataFile]]
}

proc SaveTestInputData {} {
    global InData;
    global InputDataFromWindowP

    if {$InputDataFromWindowP} {
	set InData [$::IND get 1.0 end];
    }
    if {$InData == ""} {
	ShowMessage [_ "There is no test data to save."];
	return;
    }
    set InputSaveFile [tk_getSaveFile -initialfile [_ "SavedTestData"]];
    if {$InputSaveFile != ""} {
	if {[catch {open $InputSaveFile "w+"} InputSaveHandle ] != 0} {
	    ShowMessage [format [_ "Unable to open file %s to save test data."] [MinimizeFileName $InputSaveFile]];
	    return ;
        }

	if {[string equal $::Pars(TestDataEncoding) utf-8]} {
	    #There's no point incurring the overhead of pwe if we don't need to
	    fconfigure $InputSaveHandle -encoding utf-8
	    puts $InputSaveHandle $InData
	} else {
	    if {[catch {PutWithEncoding $InputSaveHandle $::Pars(TestDataEncoding) $InData} msg] != 0} {
	    } else {
		PutNL $InputSaveHandle
		set msg [format [_ "Test data saved in %s."] [MinimizeFileName $InputSaveFile]];
	    }
	}
	close $InputSaveHandle;
	ShowMessage $msg
    }
}

proc ClearOutput {} {
    $::OUT configure -state normal
    $::OUT delete 1.0 end;
    if {!$::OUTEditableP} {
	LockOutput;
    }
}

proc EditOutput {} {
    global OutputFromWindowP;
    $::OUT configure -state normal
    set OutputFromWindowP 1;
    set ::OUTEditableP 1;
    focus -force $::OUT;
}

proc LockOutput {} {
    global OutputFromWindowP;
    $::OUT configure -state disabled;
    set OutputFromWindowP 0;
    set ::OUTEditableP 0;
}

proc ClearOutputComparisonData {} {
    $::COM configure -state normal
    $::COM delete 1.0 end;
    if {!$::COMEditableP} {
	$::COM configure -state disabled
    }
}

proc EditOutputComparisonData {} {
    global ComparisonDataFromWindowP

    $::COM configure -state normal
    set ComparisonDataFromWindowP 1;
    set ::COMEditableP 1;
    focus -force $::COM;
}

proc LoadOutputComparisonData {} {
    global ComparisonDataFromWindowP;

    set ComparisonDataFile [tk_getOpenFile];
    if {$ComparisonDataFile != ""} {
	if {[catch {open $ComparisonDataFile "r"} ComparisonDataHandle ] != 0} {
	    ShowMessage [format [_ "Unable to open comparison data file %s."] \
			     [MinimizeFileName $ComparisonDataFile]];
	    return;
        }
	fconfigure $ComparisonDataHandle -encoding $::Pars(ComparisonDataEncoding)
        set new [read $ComparisonDataHandle];
        if {$new == ""} {
	    ShowMessage [format [_ "Unable to read comparison data from file %s."] \
			     [MinimizeFileName $ComparisonDataFile]];
	    return;
        }
	$::COM configure -state normal
	$::COM insert insert $new;
        close $ComparisonDataHandle;
	set ComparisonputDataFromWindowP 1;
	if {!$::COMEditableP} {
	    $::COM configure -state disabled
	}
	ShowMessage [_ "Loaded comparison data."]
    }
}

proc LoadOutputComparisonDataFromClipboard {} {
    global ComparisonDataFromWindowP;
    set sel "";

    if {[catch {set sel [selection get -selection CLIPBOARD -type UTF8_STRING]}]} {
	ShowMessage [_ "The clipboard is empty."];
	return;
    }
    $::COM configure -state normal
    $::COM insert insert $sel;
    set ComparisonputDataFromWindowP 1;
    if {!$::COMEditableP} {
	$::COM configure -state disabled
    }
    ShowMessage [_ "Loaded comparison data from clipboard."]
}

proc SaveResultsComparisonData {} {
    global ComparisonData;
    global ComparisonDataFromWindowP

    if {$ComparisonDataFromWindowP} {
	set ComparisonData [$::COM get 1.0 end];
	set ComparisonData [string trim $ComparisonData]; #Avoid single whitespace
    }
    if {$ComparisonData == ""} {
	ShowMessage [_ "There is no comparison data to save."];
	return;
    }
    set ComparisonSaveFile [tk_getSaveFile -initialfile [_ "SavedComparisonData"]];
    if {$ComparisonSaveFile != ""} {
	if {[catch {open $ComparisonSaveFile "w+"} ComparisonSaveHandle ] != 0} {
	    ShowMessage [format [_ "Unable to open file %s to save comparison data."] \
			     [MinimizeFileName $ComparisonSaveFile]];
	    return;
        }

	if {[string equal $::ComparisonDataEncoding utf-8]} {
	    #There's no point incurring the overhead of pwe if we don't need to
	    fconfigure $ComparisonSaveHandle -encoding utf-8
	    puts $ComparisonSaveHandle $ComparisonData;
	} else {
	    if {[catch {PutWithEncoding $ComparisonSaveHandle $::Pars(ComparisonDataEncoding) $ComparisonData} msg] != 0} {
	    } else {
		PutNL $ComparisonSaveHandle
		set msg [format [_ "Comparison data saved in %s."] [MinimizeFileName $ComparisonSaveFile]];
	    }
	}
	close $ComparisonSaveHandle;
	ShowMessage $msg
    }
}


#Return: -1 on error
#         0 if output and intended are the same
#         1 if output and intended are different

proc RunDiff {AutoP} {
    global DiffResultFile;
    global TempCompFile;
    global TempOutputFile;
    global TempSortFile;
    global ComparisonDataFromWindowP;
    global ComparisonData;
    global RegexpResult;
    global errorCode;
    global GNUDiffP;

    #Get the comparison data from the window if in edit mode
    if {$ComparisonDataFromWindowP} {
	set ComparisonData [$::COM get 1.0 end];
	set ComparisonData [string trim $ComparisonData]; #Avoid single whitespace
    }
    if {$ComparisonData == ""} {
	if {$AutoP == 0} {
	    ShowMessage [_ "No comparison data is available."];
	}
	return -1;
    }

    #Write output data to temporary file.
    #For now just do it all the time, but we can save on i/o and
    #only do it when it isn't already there.
    #Note that we need to sort no matter what so that the diff won't
    #fail due to different ordering.
    if {[catch {open $TempSortFile "w"} TempSortHandle ] != 0} {
	ShowMessage [format [_ "Unable to open temporary sort file %s."] $TempSortFile];
	return -1;
    }
    puts $TempSortHandle $RegexpResult;
    close $TempSortHandle;
    if {[catch {exec sort $TempSortFile > $TempOutputFile} ] != 0} {
	ShowMessage [_ "RunDiff: sort failed"];
	return -1;
    } 

    #Write comparison data to temporary test file
    if {[catch {open $TempSortFile "w"} TempSortHandle ] != 0} {
	ShowMessage [format [_ "Unable to open temporary sort file %s."] $TempSortFile];
	return -1;
    }
    puts $TempSortHandle $ComparisonData;
    close $TempSortHandle;
    if {[catch {exec sort $TempSortFile > $TempCompFile} ] != 0} {
	ShowMessage [_ "RunDiff: sort failed"];
	return -1;
    } 

    #We have to put the output of diff into a file because tcl considers any
    #non-zero exit status to be an error and aborts rather than return the contents
    #of stdout. Therefore, even if there is no real error but diff is merely
    #reporting that there was a difference, because diff returns 1, no output
    #is returned by exec.
    if {$GNUDiffP} {
	if { [catch { exec diff -B --side-by-side --suppress-common-lines $TempOutputFile $TempCompFile > $DiffResultFile} rval]  == 0} {
	    return 0;
	}
    } else {
	if { [catch { exec diff $TempOutputFile $TempCompFile > $DiffResultFile} rval]  == 0} {
	    return 0;
	}
    }

    set ChildError [lindex [split $errorCode] 3];
    if {$ChildError > 1} {
	ShowMessage [_ "Error executing comparison."]
	return -1;
    }
    return 1;
}

proc ShowDiffResult {{AutoP 0}} {
    global DiffPopup;
    global DiffResultFile;

    if {!$::UseDiffP} {
	ShowMessage [_ "Diff is not available."]
	return ;
    }

    set rstat [RunDiff $AutoP];

    if {$rstat == -1} {return $rstat};
    if {$rstat == 0} {
	ShowMessage [_ "Result of executing regexp and comparison data are identical."];
	return $rstat;
    }

    ShowMessage [_ "Result of executing regexp and comparison data are different."];
    #Get text from file and display in pop-up.
    if {[catch {open  $DiffResultFile "r"} DiffResultHandle] != 0} { 
	ShowMessage [format [_ "Unable to open comparison result file %s."] $DiffResultFile];
	error "";
    } else {
	set DiffResults [read $DiffResultHandle];
    }
    if {$DiffResults == ""} {
	ShowMessage [format [_ "Unable to read comparison results from file %s"] $DiffResultFile ];
	return $rstat;
    }
    destroy $DiffPopup;
    set DiffPopup [CreateTextDisplay [_ "Differences between Regexp Output and Comparison Data"] 80 12]
    BindKeys $DiffPopup;
    AppendToTextDisplay $DiffPopup $DiffResults;
    return $rstat;
}


proc AssignEncoding {x e} {
    set ::Pars($x) $e
    destroy .encm
}

set EncodingInfo(ascii) "The usual Roman encoding used in the United States\nand other English-speaking countries."
set EncodingInfo(big5) "A 2-byte encoding used in Taiwan and Hong Kong for\ntraditional Chinese characters."
set EncodingInfo(cp437) "This is the original encoding of the IBM PC."
set EncodingInfo(cp737) "An IBM PC encoding for the Greek alphabet."
set EncodingInfo(cp775) "MS DOS 8-bit encoding for Estonian, Latvian, and Lithuanian"
set EncodingInfo(cp850) "MS DOS Multilingual Latin I"
set EncodingInfo(cp852) "MS DOS Central European (Czech, Polish, Rumanian, Slovak)"
set EncodingInfo(cp855) "A rarely used MS DOS encoding of Cyrillic"
set EncodingInfo(cp857) "MS DOS Turkish"
set EncodingInfo(cp860) "MS DOS Portuguese"
set EncodingInfo(cp861) "MS DOS Icelandic/Nordic"
set EncodingInfo(cp862) "MS DOS Hebrew"
set EncodingInfo(cp863) "MS DOS Canadian French"
set EncodingInfo(cp864) "MS DOS Arabic"
set EncodingInfo(cp865) "MS DOS Nordic"
set EncodingInfo(cp866) "MS DOS Cyrillic"
set EncodingInfo(cp869) "MS DOS Modern Greek"
set EncodingInfo(cp874) "MS Windows Thai"
set EncodingInfo(cp932) "An MS Windows extension of Shift JIS for Japanese"
set EncodingInfo(cp936) "An MS Windows version of the GBK encoding of Chinese"
set EncodingInfo(cp949) "An MS Windows encoding for Korean Hangul similar to EUC-KR."
set EncodingInfo(cp950) "The Microsoft version of the Big5 encoding of traditional Chinese"
set EncodingInfo(cp1250) "MS Windows Latin 2"
set EncodingInfo(cp1251) "MS Windows Cyrillic"
set EncodingInfo(cp1252) "MS Windows Latin 1"
set EncodingInfo(cp1253) "MS Windows Greek"
set EncodingInfo(cp1254) "MS Windows Turkish"
set EncodingInfo(cp1255) "MS Windows Hebrew"
set EncodingInfo(cp1256) "MS Windows Arabic"
set EncodingInfo(cp1257) "MS Windows Estonian, Latvian, Lithuanian"
set EncodingInfo(cp1258) "MS Windows Vietnamese"
set EncodingInfo(dingbats) "Dingbats"
set EncodingInfo(ebcdic) "IBM's 8-bit encoding for American English"
set EncodingInfo(euc-cn) "The version of the Extended Unix Code multibyte encoding\nused for simplified Chinese."
set EncodingInfo(euc-jp) "The version of the Extended Unix Code multibyte encoding\nused for Japanese "
set EncodingInfo(euc-kr) "The version of the Extended Unix Code multibyte encoding\nused for Korean"
set EncodingInfo(gb1988) "A two-byte Chinese encoding."
set EncodingInfo(gb2312) "This is the principal character set used by the\nPeople's Republic of China\nencoded as EUC-CN."
set EncodingInfo(gb2312-raw) "This is the principal character set used by the\nPeople's Republic of China.\nThis is the version without further encoding as EUC-CN."
set EncodingInfo(gb12345) "An expansion of GB2312 for Chinese."
set EncodingInfo(identity) "The identity mapping. Maps everything onto itself."
set EncodingInfo(iso2022) "A multibyte encoding for Chinese."
set EncodingInfo(iso2022-jp)  "A multibyte encoding for Japanese."
set EncodingInfo(iso2022-kr)  "A multibyte encoding for Korean."
set EncodingInfo(iso8859-1) "This is the ASCII extension known as Latin-1,\nused for most Western European languages."
set EncodingInfo(iso8859-2) "This is an ASCII extension used for Eastern European languages."
set EncodingInfo(iso8859-3) "This is an ASCII extension used for Esperanto and Maltese."
set EncodingInfo(iso8859-4) "This is an ASCII extension used for Northern European languages."
set EncodingInfo(iso8859-5) "This is an ASCII extension used for Cyrillic."
set EncodingInfo(iso8859-6) "This is an ASCII extension used for Arabic."
set EncodingInfo(iso8859-7) "This is an ASCII extension used for Greek."
set EncodingInfo(iso8859-8) "This is an ASCII extension used for Hebrew."
set EncodingInfo(iso8859-9) "This is an ASCII extension used for Turkish."
set EncodingInfo(iso8859-10) "This is an ASCII extension used for Nordic languages."
set EncodingInfo(iso8859-11) "This is an ASCII extension used for Thai."
set EncodingInfo(iso8859-13) "This is an ASCII extension used for languages of the Baltic Rim."
set EncodingInfo(iso8859-14) "This is the ASCII extension used primarily for Celtic languages."
set EncodingInfo(iso8859-15) "This is the ASCII extension for Western European languages\nthat modernizes Latin-1."
set EncodingInfo(iso8859-16) "This is the ASCII extension used primarily South-Eastern European langauges."
set EncodingInfo(jis0201) "An eight-bit Japanese encoding containing roughly speaking ASCII plus kana"
set EncodingInfo(jis0208) "A two-byte Japanese encoding containing 6355 kanji plus\nkana, roman letters, Greek, adn Cyrillic"
set EncodingInfo(jis0212) "This is a supplementary set of characters for Japanese"
set EncodingInfo(koi8-r) "Russian Cyrillic"
set EncodingInfo(koi8-u) "Ukrainian Cyrillic"
set EncodingInfo(ksc5601) "A double-byte encoding for the Korean writing system"
set EncodingInfo(macCentEuro) "Macintosh Central European"
set EncodingInfo(macCroatian) "Macintosh Croatian"
set EncodingInfo(macCyrillic) "Macintosh Cyrillic"
set EncodingInfo(macDingbats) "Macintosh Dingbats"
set EncodingInfo(macGreek) "Macintosh Greek"
set EncodingInfo(macIceland) "Macintosh Icelandic"
set EncodingInfo(macJapan) "Macintosh Japanese"
set EncodingInfo(macRoman) "Macintosh Roman"
set EncodingInfo(macRomania) "Macintosh Romanian"
set EncodingInfo(macThai) "Macintosh Thai"
set EncodingInfo(macTurkish) "Macintosh Turkish"
set EncodingInfo(macUkraine) "Macintosh Ukrainian"
set EncodingInfo(pascii) "The Perso-Arabic Standard for Computer Information Interchange.\nThis is the Indian government 8-bit encoding for\nthe languages written in Arabic letters:\nArabic, Kashmiri, Persian, Sindhi, and Urdu.\nIt is the Arabic script counterpart to ISCII."
set EncodingInfo(shiftjis) "A two-byte encoding for the Japanese writing system standardized as JIS  0208."
set EncodingInfo(symbol) "Adobe Symbol font encoding"
set EncodingInfo(tis-620) "This is the Thai national standard 8-bit encoding."
set EncodingInfo(ucs-2be) "This is a two-byte encoding of the Basic Monolingual Plane of Unicode, with the two bytes in big-endian order."
set EncodingInfo(unicode) "This is a synonym for UCS-2, the two-byte encoding of the\nBasic Monolingual Plane of Unicode"
set EncodingInfo(utf-8) "The UTF-8 variable length encoding for Unicode."

#Subtract list b from a
proc SubtractList {a b} {
    array set tmp {}
    foreach x $a {
	set tmp($x) ""
    }
    foreach y $b {
	if {[info exists tmp($y)]} {
	    unset tmp($y)
	}
    }
    return [array names tmp]
}

proc PopupSelectEncoding {x} {
    set xp 3
    set yp 3
    if {[winfo exists .encm]} {
	raise .encm
	return
    }
    set w [toplevel .encm]
    wm title $w [_ "Select encoding"]
    set wf [frame $w.f -border 2 -relief flat -bg salmon]
    pack $wf
    .encm configure -bg salmon
    set EncodingList [lsort -dictionary \
		  [SubtractList [encoding names] [list "identity" "X11ControlChars"]]]
    set EncodingCnt [llength $EncodingList]
    set PerRow [expr int(0.7 * ceil(sqrt($EncodingCnt)))]
    set Rows [expr ceil(double($EncodingCnt)/double($PerRow))]
    set Total [expr $PerRow * $Rows]

    for {set k 0} {$k < $Total} {incr k} {
	set row [expr $k/$PerRow]
	set col [expr $k%$PerRow]
	set c $wf.r${row}c${col}
	if {$k < $EncodingCnt} {
	    set Encoding [lindex $EncodingList $k]
	    button $c -text $Encoding \
		-padx $xp -pady $yp -command "AssignEncoding $x $Encoding" \
		-activeforeground $::ColorSpecs(Menu,ActiveForeground) \
		-activebackground $::ColorSpecs(Menu,ActiveBackground)
	    if {[string equal $Encoding $::Pars($x)]} {
		$c configure -bg coral -relief raised
	    }
	    if {[info exists ::EncodingInfo($Encoding)]} {
		balloonhelp_for $c $::EncodingInfo($Encoding)
	    }
	} else {
	    label $c
	}
	set LastRow $row;
	set LastCol $col;
    }
    #Lay the buttons and labels out in a grid.
    for {set row 0} {$row <= $LastRow} {incr row} {
	set line [list];
	for {set col 0} {$col <= $LastCol} {incr col} {
	    set cell [format ".encm.f.r%dc%d" $row $col]
	    lappend line $cell
	}
	eval grid $line -sticky news;
    }
    raise .encm
}


proc CreateTextDisplay {title width height} {
    set bg $::ColorSpecs(TextDisplay,Background)
    set fg $::ColorSpecs(TextDisplay,Foreground)
    set top [new_dialog_create Textdisplay]
    wm title $top $title
    set info [dialog_info $top]
    scrollbar $info.sbar -command "$info.text yview" 
    pack $info.sbar  -side right -expand 0 -fill y
    text $info.text -height $height -width $width -font MainFont -wrap word \
	-yscrollcommand "$info.sbar set" -background $bg -foreground $fg \
	-exportselection 1;
    pack $info.text -side left -expand yes -fill both
    $info.text configure -state disabled
    bind $info.sbar <<B3>> "ScrollbarMoveBigIncrement $info.sbar 0.2 %x %y"
    return $top
}

proc AppendToTextDisplay {top mesg} {
    set info [dialog_info $top]
    $info.text configure -state normal
    $info.text insert end $mesg
    $info.text configure -state disabled
}

set linkNum 0;
proc AppendLinkToTextDisplay {top mesg LinkCode} {
    global linkNum
    set info [dialog_info $top]
    $info.text configure -state normal
    set tag "link[incr linkNum]"
    bind $info.text <ButtonPress> break
    $info.text insert end $mesg [list body $tag]
    $info.text tag configure $tag -foreground red -underline 1
    $info.text tag bind $tag <Enter> \
        "$info.text tag configure $tag -foreground blue"
    $info.text tag bind $tag <Leave> \
        "$info.text tag configure $tag -foreground red"
    $info.text tag bind $tag <ButtonPress> \
        "$LinkCode"
    $info.text configure -state disabled
}

#This is Cameron Laird's procedure
proc launchBrowser url {
    global tcl_platform

    # It *is* generally a mistake to switch on $tcl_platform(os), particularly
    # in comparison to $tcl_platform(platform).  For now, let's just regard it
    # as a stylistic variation subject to debate.
    switch $tcl_platform(os) {
        Darwin {
	    set command [list open $url]
        }
        HP-UX -
        Linux  -
        SunOS {
	    foreach executable {mozilla netscape iexplorer opera lynx
		w3m links galeon konqueror mosaic firefox amaya
		browsex elinks} {
		set executable [auto_execok $executable]
		if [string length $executable] {
		    # Do you want to mess with -remote?  How about other browsers?
		    set command [list $executable $url &]
		    break
		}
	    }
        }
        {Windows 95} -
        {Windows NT} {
	    set command "[auto_execok start] {} [list $url]"
        }
    }
    if [info exists command] {
        if [catch {exec {expand}$command} err] {
	    tk_messageBox -icon error -message "error '$err' with '$command'"
        }
    } else {
        tk_messageBox -icon error -message \
	    "Please tell CL that ($tcl_platform(os), $tcl_platform(platform)) is not yet ready for browsing."
    }
}

proc ShowWebPage {url} {
    global BrowserPIDS;

    if {[string equal $::System MacOSX]} {
	lappend BrowserPIDS [exec osascript -e "\"open location $url\""]
	return 
    }

    set BrowserFound 0;
    foreach Browser $::BrowserList {
	if { [string length [auto_execok $Browser]]} {
	    set BrowserFound 1;
	    break ;
	} else {
	    ShowMessage [format \
	     [_ "The browser %s is not available on this machine or not in your path."]\
		 $Browser];
	}
    }
    if {$BrowserFound} {
	lappend BrowserPIDS [exec $Browser $url &]
    } else {
	ShowMessage [_ "No browser on the browser list was located."]
    }
}

proc WebManual {} {
    global ManualPath;
    global ManualURL;

    if {[file exists $ManualPath] == 0} {
	ShowMessage [format [_ "Manual not found at location %s"] $ManualPath];
	return ;
    }
    ShowWebPage $ManualURL;
}

proc OSName {} {
    set OS $::tcl_platform(os);
    if {$OS == "Linux"} {set OS "GNU/Linux"};
    return [format "%s %s" $OS  $::tcl_platform(osVersion)]
}

proc BugReports {} {
    global Version;

    if {[PopupDown BugReports] ==1} {return}
    set BugReportPopup [CreateTextDisplay [_ "Bug Reports"] 62 21];
    set ::PopupList(BugReports) $BugReportPopup;
    BindKeys $BugReportPopup;
    AppendToTextDisplay $BugReportPopup [_ "Report bugs to: billposer@alum.mit.edu.\n"];
    AppendToTextDisplay $BugReportPopup [_ "Please include the following information:\n\n"];
    AppendToTextDisplay $BugReportPopup [_ "  What version of the program are you using?\n"];
    AppendToTextDisplay $BugReportPopup [format [_ "    (This is version %s \[%s\].)\n\n"] $Version [ProgramTimeDateStamp]];
    AppendToTextDisplay $BugReportPopup [_ "  What operating system are you running?.\n"];
    AppendToTextDisplay $BugReportPopup [format [_ "    (This is %s.)\n\n"] [OSName]];
    AppendToTextDisplay $BugReportPopup [_ "  What window system are you using?.\n"];
    AppendToTextDisplay $BugReportPopup [format [_ "    (This is %s.)\n\n"] $::WindowSystem]
    AppendToTextDisplay $BugReportPopup [_ "  What version of tcl/tk are you using?.\n"];
    AppendToTextDisplay $BugReportPopup [format [_ "    (This is version %s.)\n\n"] [info patchlevel]];
    AppendToTextDisplay $BugReportPopup [_ "If the problem is restricted to a particular program, what program is it and what version is it?\n"];
    AppendToTextDisplay $BugReportPopup [format [_ "  (The current program is %s \[%s\].\n"] [NameProgram] $::ProgramInfo($::program,version)]
    AppendToTextDisplay $BugReportPopup [_ "  The \'This Program\' entry on the Help menu will provide\n  version information for the currently selected program.)\n\n"]
    AppendToTextDisplay $BugReportPopup [_ "Bug reports may be sent in any language that I can read without too much trouble or am trying to learn or improve. These include:\n\n"];
    AppendLinkToTextDisplay $BugReportPopup [_ "\tCatal\u00e1"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=cat};
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\tDakelh/\u1455\u15F8\u14A1"] {ShowWebPage http://ydli.org}
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\tDeutsch"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=deu};
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\tEnglish"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=eng};
    AppendToTextDisplay $BugReportPopup "\n"; 
    AppendLinkToTextDisplay $BugReportPopup "\tEspa\u00F1ol" {ShowWebPage http://www.ethnologue.com/show_language.asp?code=spa}
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\tEsperanto"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=epo};
    AppendToTextDisplay $BugReportPopup "\n"; 
    AppendLinkToTextDisplay $BugReportPopup "\tFran\u00e7ais" {ShowWebPage http://www.ethnologue.com/show_language.asp?code=fra};
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\t\uD55C\uAD6D\uB9D0"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=kor};
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\tItaliano"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=ita};
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\t\u65E5\u672C\u8A9E"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=jpn};
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\tLatina Lingua"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=lat};
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\tNederlands"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=nld};
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\t\u0A2A\u0A70\u0A1C\u0A3E\u0A2C\u0A40"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=pan};
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\tPortugu\u00EAs"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=por};
    AppendToTextDisplay $BugReportPopup "\n";
    AppendLinkToTextDisplay $BugReportPopup [_ "\tT\u00FCrk\u00E7e"] {ShowWebPage http://www.ethnologue.com/show_language.asp?code=tur};
    AppendToTextDisplay $BugReportPopup "\n\n";
    AppendToTextDisplay $BugReportPopup [_ "Please note that in many cases although I can understand the language my ability to respond in it may be limited.\n"];
    AppendToTextDisplay $BugReportPopup "\n";

    AppendToTextDisplay $BugReportPopup "\n";
}

proc CommandLineOptions {} {
    if {[PopupDown CommandLineOptions] ==1} {return}
    set po [CreateTextDisplay [_ "Command Line Options"] 60 13];
    set ::PopupList(CommandLineOptions) $po;
    BindKeys $po;
    AppendToTextDisplay $po [_ "Usage: redet \[options\] (<input text file>)\n\n"];
    AppendToTextDisplay $po [_ "  -c <filename>   load class definitions from <filename>\n"];
    AppendToTextDisplay $po [_ "  -d              set the debug flag\n"];
    AppendToTextDisplay $po [_ "  -F <filename>   read a feature list from <filename> >\n"];
    AppendToTextDisplay $po [_ "  -f              read input text from standard input\n"];
    AppendToTextDisplay $po [_ "  -H              do not read the history file\n"];
    AppendToTextDisplay $po [_ "  -h              provide help\n"];
    AppendToTextDisplay $po [_ "  -I <filename>   read <filename> as the init file\n"];
    AppendToTextDisplay $po [_ "  -i              do not read the init file\n"];
    AppendToTextDisplay $po [_ "  -l <locale>     set the locale to <locale>\n"];
    AppendToTextDisplay $po [_ "  -n              disable feature testing\n"];
    AppendToTextDisplay $po [_ "  -o              use deprecated old style init files\n"];
    AppendToTextDisplay $po [_ "  -P              list the programs supported"];
    AppendToTextDisplay $po [_ "  -p <program>    set the program to <program>\n"];
    AppendToTextDisplay $po [_ "  -s              start up in substitution mode\n"];
    AppendToTextDisplay $po [_ "  -t              enable feature test debugging\n"];
    AppendToTextDisplay $po [_ "  -v              identify version"];
}


proc About {} {
    global Version;
    if {[PopupDown About] ==1} {return}
    set AboutPopup [CreateTextDisplay [_ "About This Program"] 72 12]
    set ::PopupList(About) $AboutPopup;
    BindKeys $AboutPopup;
    AppendToTextDisplay $AboutPopup [format [_ "This is Redet version %s \[%s\]."] $Version [ProgramTimeDateStamp]];
    AppendToTextDisplay $AboutPopup [_ " It is a tool for developing, testing, and executing regular expressions."];
    AppendToTextDisplay $AboutPopup [_ " You can obtain the latest version of Redet from: "];
    AppendLinkToTextDisplay $AboutPopup "http://www.billposer.org/Software/redet.html." {ShowWebPage http://www.billposer.org/Software/redet.html};
    AppendToTextDisplay $AboutPopup "\n\n";
    AppendToTextDisplay $AboutPopup "Copyright (C) 2003-2008 William J. Poser (billposer@alum.mit.edu).";
    AppendToTextDisplay $AboutPopup [_ "This program is free software; you can redistribute it and/or modify it under the terms of version 3 of the GNU General Public License as published by the Free Software Foundation."];
    AppendToTextDisplay $AboutPopup "\n\n";
    AppendToTextDisplay $AboutPopup [_ "This program 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.\n"];
    AppendToTextDisplay $AboutPopup [_ "See the GNU General Public License for more details."];
    AppendToTextDisplay $AboutPopup "\n\n";
    AppendToTextDisplay $AboutPopup [_ "You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA."];
}

proc Description {} {
    if {[PopupDown Description] ==1} {return}
    set DescriptionPopup [CreateTextDisplay "Description" 60 12]
    set ::PopupList(Description) $DescriptionPopup;
    AppendToTextDisplay $DescriptionPopup "This program allows you to construct regular\
 expressions and test them against input data by executing any of a variety of search\
 programs, editors, and programming languages that support regular expressions.\
 A variety of regular expression  notations are therefore supported.\
 One window is devoted to the test data. The test data may\
 be loaded from a file, entered by typing in the window, or constructed by editing data loaded\
 from a file. The user may also enter data representing the intended output of execution of the\
 regular expression. This data too may be loaded from a file, entered in the associated window\
 (which appears if needed), or constructed by editing data loaded from a file. If such comparison\
 data is supplied, the program will automatically compare the actual output with the intended\
 output and report on any differences. Comparisons may also be triggered by means of a menu\
 button. This allows the user to correct errors in the comparison data, or test a hypothesis\
 about what is wrong, by editing the data in the window and rerunning the comparison.\
 When a suitable regular expression has been constructed it may be saved to a file.\
 For each program, a palette of regular expression constructions available in that\
 program is provided, from which entries may be copied into the regular expression\
 window by means of a mouse click. Additional palette entries may be supplied by the\
 user in his or her initialization file.
\

The full reference manual is available on-line at:
    http://www.billposer.org/Software/RedetManual.html"
}


#Uncomment these to make them the default once it is possible to restore explicit focus
#set FocusFollowsMouseP 1;
#tk_focusFollowsMouse;

proc ShowUnicodeGCP {} {
    global PopupLines;
    global SortUnicodeRangesByCodepointP;
    if {[PopupDown ShowUnicodeGCP] ==1} {return}
    set po [CreateTextDisplay [_ "Unicode General Character Properties"] 50 $PopupLines];
    set ::PopupList(ShowUnicodeGCP) $po;
    BindKeys $po;
    AppendToTextDisplay $po [_ "Single letters represent major classes. "]
    AppendToTextDisplay $po [_ "Two letter sequences represent subclasses. "]
    AppendToTextDisplay $po [_ "Note that some regular expression engines may not implement all classes.\n"]
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "L\t%s\n" [_ "letter"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "\tLu\t%s\n" [_ "uppercase letter, e.g. A (U+0041)"]];
    AppendToTextDisplay $po [format "\tLl\t%s\n" [_ "lowercase letter, e.g. a (U+0061"]];
    AppendToTextDisplay $po [format "\tLt\t%s\n" [_ "titlecase letter, e.g. \u01C8 (U+01C8)"]];
    AppendToTextDisplay $po [format "\tL&\t%s\n" [_ "union of upper, lower and title-case letters"]];
    AppendToTextDisplay $po [format "\tLm\t%s\n" [_ "modifier letter, e.g. \u02B0 (U+02B0)"]];
    AppendToTextDisplay $po [format "\tLo\t%s\n" [_ "other letter, e.g. \u05D0 (U+05D0) "]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "N\t%s\n" [_ "number"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "\tNd\t%s\n" [_ "decimal digit, e.g. 3 (U+0033)"]];
    AppendToTextDisplay $po [format "\tNl\t%s\n" [_ "letter number, e.g. \u3023 (U+3023)"]];
    AppendToTextDisplay $po [format "\tNo\t%s\n" [_ "other number, e.g. \u00B3 (U+00B3)"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "P\t%s\n" [_ "punctuation"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "\tPc\t%s\n" [_ "punctuation - connector, e.g. \u203F (U+203F)"]];
    AppendToTextDisplay $po [format "\tPd\t%s\n" [_ "punctuation - dash"]];
    AppendToTextDisplay $po [format "\tPs\t%s\n" [_ "punctuation - open"]];
    AppendToTextDisplay $po [format "\tPe\t%s\n" [_ "punctuation - close"]];
    AppendToTextDisplay $po [format "\tPi\t%s\n" [_ "punctuation - initial quote"]];
    AppendToTextDisplay $po [format "\tPf\t%s\n" [_ "punctuation - final quote"]];
    AppendToTextDisplay $po [format "\tPo\t%s\n" [_ "punctuation - other"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "S\t%s\n" [_ "symbol"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "\tSm\t%s\n" [_ "math symbol, .e.g \u2245 (U+2245)"]];
    AppendToTextDisplay $po [format "\tSc\t%s\n" [_ "currency symbol, e.g. \u20A0 (U+20A0)"]];
    AppendToTextDisplay $po [format "\tSk\t%s\n" [_ "modifier symbol, e.g. \u005E (U+005E)"]];
    AppendToTextDisplay $po [format "\tSo\t%s\n" [_ "other symbol, e.g. \u00AE (U+00AE)"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "Z\t%s\n" [_ "separator"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "\tZs\t%s\n" [_ "space separator"]];
    AppendToTextDisplay $po [format "\tZl\t%s\n" [_ "line separator"]];
    AppendToTextDisplay $po [format "\tZp\t%s\n" [_ "paragraph separator"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "M\t%s\n" [_ "mark"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "\tMn\t%s\n" [_ "non-spacing mark"]];
    AppendToTextDisplay $po [format "\tMc\t%s\n" [_ "spacing combining mark"]];
    AppendToTextDisplay $po [format "\tMe\t%s\n" [_ "enclosing mark"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "C\t%s\n" [_ "other"]];
    AppendToTextDisplay $po "\n";
    AppendToTextDisplay $po [format "\tCc\t%s\n" [_ "other - control"]];
    AppendToTextDisplay $po [format "\tCf\t%s\n" [_ "other - format"]];
    AppendToTextDisplay $po [format "\tCo\t%s\n" [_ "other - private use"]];
    AppendToTextDisplay $po [format "\tCn\t%s\n" [_ "other - not assigned"]];

}

proc ShowUnicodeRanges {} {
    global SortUnicodeRangesByCodepointP;
    global PopupLines;
    if {[PopupDown ShowUnicodeRanges] ==1} {return}
    set po  [CreateTextDisplay [_ "Unicode Ranges"] 78 $PopupLines];
    set ::PopupList(ShowUnicodeRanges) $po;
    BindKeys $po;
    if {$SortUnicodeRangesByCodepointP} {
	AppendToTextDisplay $po [format "%-52s  \[0x000000-0x00007F\]\n" [_ "Basic Latin"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000080-0x0000FF\]\n" [_ "C1 Controls and Latin-1 Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000100-0x00017F\]\n" [_ "Latin Extended-A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000180-0x00024F\]\n" [_ "Latin Extended-B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000250-0x0002AF\]\n" [_ "IPA Extensions"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0002B0-0x0002FF\]\n" [_ "Spacing Modifier Letters"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000300-0x00036F\]\n" [_ "Combining Diacritical Marks"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000370-0x0003FF\]\n" [_ "Greek/Coptic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000400-0x0004FF\]\n" [_ "Cyrillic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000500-0x00052F\]\n" [_ "Cyrillic Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000530-0x00058F\]\n" [_ "Armenian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000590-0x0005FF\]\n" [_ "Hebrew"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000600-0x0006FF\]\n" [_ "Arabic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000700-0x00074F\]\n" [_ "Syriac"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000750-0x00077F\]\n" [_ "Arabic Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000780-0x0007BF\]\n" [_ "Thaana"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0007C0-0x0007FF\]\n" [_ "Nko"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0008C0-0x0008FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000900-0x00097F\]\n" [_ "Devanagari"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000980-0x0009FF\]\n" [_ "Bengali/Assamese"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000A00-0x000A7F\]\n" [_ "Gurmukhi"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000A80-0x000AFF\]\n" [_ "Gujarati"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000B00-0x000B7F\]\n" [_ "Oriya"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000B80-0x000BFF\]\n" [_ "Tamil"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000C00-0x000C7F\]\n" [_ "Telugu"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000C80-0x000CFF\]\n" [_ "Kannada"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000D00-0x000D7F\]\n" [_ "Malayalam"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000D80-0x000DFF\]\n" [_ "Sinhala"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000E00-0x000E7F\]\n" [_ "Thai"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000E80-0x000EFF\]\n" [_ "Lao"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000F00-0x000FFF\]\n" [_ "Tibetan"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001000-0x00109F\]\n" [_ "Myanmar"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0010A0-0x0010FF\]\n" [_ "Georgian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001100-0x0011FF\]\n" [_ "Hangul Jamo"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001200-0x00137F\]\n" [_ "Ethiopic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001380-0x00139F\]\n" [_ "Ethiopic Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0013A0-0x0013FF\]\n" [_ "Cherokee"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001400-0x00167F\]\n" [_ "Unified Canadian Aboriginal Syllabics"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001680-0x00169F\]\n" [_ "Ogham"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0016A0-0x0016FF\]\n" [_ "Runic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001700-0x00171F\]\n" [_ "Tagalog"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001720-0x00173F\]\n" [_ "Hanunoo"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001740-0x00175F\]\n" [_ "Buhid"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001760-0x00177F\]\n" [_ "Tagbanwa"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001780-0x0017FF\]\n" [_ "Khmer"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001800-0x0018AF\]\n" [_ "Mongolian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0018B0-0x0018FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001900-0x00194F\]\n" [_ "Limbu"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001950-0x00197F\]\n" [_ "Tai Le"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001980-0x0019DF\]\n" [_ "New Tai Lue"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0019E0-0x0019FF\]\n" [_ "Khmer Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001A00-0x001A1F\]\n" [_ "Buginese"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001A20-0x001AFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001B00-0x001B7F\]\n" [_ "Balinese"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001B80-0x001BBF\]\n" [_ "Sundanese"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001BC0-0x001BFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001C00-0x001C4F\]\n" [_ "Lepcha"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001C50-0x001C7F\]\n" [_ "Ol Chiki"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001C80-0x001CFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001D00-0x001D7F\]\n" [_ "Phonetic Extensions"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001D80-0x001DBF\]\n" [_ "Phonetic Extensions Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001DC0-0x001DFF\]\n" [_ "Combining Diacritical Marks Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001E00-0x001EFF\]\n" [_ "Latin Extended Additional"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001F00-0x001FFF\]\n" [_ "Greek Extended"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002000-0x00206F\]\n" [_ "General Punctuation"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002070-0x00209F\]\n" [_ "Superscripts and Subscripts"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0020A0-0x0020CF\]\n" [_ "Currency Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0020D0-0x0020FF\]\n" [_ "Combining Diacritical Marks for Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002100-0x00214F\]\n" [_ "Letterlike Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002150-0x00218F\]\n" [_ "Number Forms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002190-0x0021FF\]\n" [_ "Arrows"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002200-0x0022FF\]\n" [_ "Mathematical Operators"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002300-0x0023FF\]\n" [_ "Miscellaneous Technical"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002400-0x00243F\]\n" [_ "Control Pictures"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002440-0x00245F\]\n" [_ "Optical Character Recognition"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002460-0x0024FF\]\n" [_ "Enclosed Alphanumerics"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002500-0x00257F\]\n" [_ "Box Drawing"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002580-0x00259F\]\n" [_ "Block Elements"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0025A0-0x0025FF\]\n" [_ "Geometric Shapes"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002600-0x0026FF\]\n" [_ "Miscellaneous Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002700-0x0027BF\]\n" [_ "Dingbats"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0027C0-0x0027EF\]\n" [_ "Miscellaneous Mathematical Symbols-A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0027F0-0x0027FF\]\n" [_ "Supplemental Arrows-A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002800-0x0028FF\]\n" [_ "Braille Patterns"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002900-0x00297F\]\n" [_ "Supplemental Arrows-B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002980-0x0029FF\]\n" [_ "Miscellaneous Mathematical Symbols-B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002A00-0x002AFF\]\n" [_ "Supplemental Mathematical Operators"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002B00-0x002BFF\]\n" [_ "Miscellaneous Symbols and Arrows"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002C00-0x002C5F\]\n" [_ "Glagolitic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002C60-0x002C7F\]\n" [_ "Latin Extended-C"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002C80-0x002CFF\]\n" [_ "Coptic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002D00-0x002D2F\]\n" [_ "Georgian Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002D30-0x002D7F\]\n" [_ "Tifinagh"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002D80-0x002DDF\]\n" [_ "Ethiopic Extended"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002E00-0x002E7F\]\n" [_ "Supplemental Punctuation"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002E80-0x002EFF\]\n" [_ "CJK Radicals Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002F00-0x002FDF\]\n" [_ "Kangxi Radicals"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002FE0-0x002FEF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002FF0-0x002FFF\]\n" [_ "Ideographic Description Characters"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003000-0x00303F\]\n" [_ "CJK Symbols and Punctuation"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003040-0x00309F\]\n" [_ "Hiragana"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0030A0-0x0030FF\]\n" [_ "Katakana"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003100-0x00312F\]\n" [_ "Bopomofo"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003130-0x00318F\]\n" [_ "Hangul Compatibility Jamo"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003190-0x00319F\]\n" [_ "Kanbun (Kunten)"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0031A0-0x0031BF\]\n" [_ "Bopomofo Extended"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0031C0-0x0031EF\]\n" [_ "CJK Strokes"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0031F0-0x0031FF\]\n" [_ "Katakana Phonetic Extensions"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003200-0x0032FF\]\n" [_ "Enclosed CJK Letters and Months"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003300-0x0033FF\]\n" [_ "CJK Compatibility"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003400-0x004DBF\]\n" [_ "CJK Unified Ideographs Extension A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x004DC0-0x004DFF\]\n" [_ "Yijing Hexagram Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x004E00-0x009FAF\]\n" [_ "CJK Unified Ideographs"]];
	AppendToTextDisplay $po [format "%-52s  \[0x009FB0-0x009FFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A000-0x00A48F\]\n" [_ "Yi Syllables"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A490-0x00A4CF\]\n" [_ "Yi Radicals"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A4D0-0x00A4FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A500-0x00A63F\]\n" [_ "Vai"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A640-0x00A6FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A700-0x00A71F\]\n" [_ "Modifier Tone Letters"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A720-0x00A7FF\]\n" [_ "Latin Extended-D"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A800-0x00A82F\]\n" [_ "Syloti Nagri"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A830-0x00A83F\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A840-0x00A87F\]\n" [_ "Phags-pa"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A880-0x00A8DF\]\n" [_ "Saurashtra"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A8E0-0x00A8FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A900-0x00A92F\]\n" [_ "Kayah Li"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A930-0x00A95F\]\n" [_ "Rejang"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A960-0x00A9FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00AA00-0x00AA5F\]\n" [_ "Cham"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A960-0x00ABFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00AC00-0x00D7AF\]\n" [_ "Hangul Syllables"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00D7B0-0x00D7FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00D800-0x00DB7F\]\n" [_ "High Surrogate Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00DB80-0x00DBFF\]\n" [_ "High Private Use Surrogate Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00DC00-0x00DFFF\]\n" [_ "Low Surrogate Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E000-0x00E07F\]\n" [_ "Private Use Area - Conlang Tengwar"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E080-0x00E0FF\]\n" [_ "Private Use Area - Conlang brie.Cirth"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E2E0-0x00E2FF\]\n" [_ "Private Use Area - Conlang Xaini"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E300-0x00E33F\]\n" [_ "Private Use Area - Conlang Mizarian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E340-0x00E35F\]\n" [_ "Private Use Area - Conlang Ziri:nka"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E360-0x00E37F\]\n" [_ "Private Use Area - Conlang Sarkai"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E380-0x00E3AF\]\n" [_ "Private Use Area - Conlang Thelwik"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E3B0-0x00E3FF\]\n" [_ "Private Use Area - Conlang Olaetyan"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E400-0x00E42F\]\n" [_ "Private Use Area - Conlang Niskloz"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E430-0x00E44F\]\n" [_ "Private Use Area - Conlang Kazat ?akkorou"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E450-0x00E46F\]\n" [_ "Private Use Area - Conlang Kazvarad"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E470-0x00E48F\]\n" [_ "Private Use Area - Conlang Zarkhand"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E490-0x00E4BF\]\n" [_ "Private Use Area - Conlang Rozhxh"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E4C0-0x00E4EF\]\n" [_ "Private Use Area - Conlang Serivelna"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E4F0-0x00E4FF\]\n" [_ "Private Use Area - Conlang Kelwathi"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E500-0x00E51F\]\n" [_ "Private Use Area - Conlang Saklor"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E520-0x00E54F\]\n" [_ "Private Use Area - Conlang Rynnan"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E550-0x00E57F\]\n" [_ "Private Use Area - Conlang Alzetjan"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E580-0x00E59F\]\n" [_ "Private Use Area - Conlang Telarasso"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E5A0-0x00E5BF\]\n" [_ "Private Use Area - Conlang Ssuraki"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E5C0-0x00E5DF\]\n" [_ "Private Use Area - Conlang Gargoyle"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E5E0-0x00E5FF\]\n" [_ "Private Use Area - Conlang Ophidian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E600-0x00E62F\]\n" [_ "Private Use Area - Conlang Ferengi"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E630-0x00E64F\]\n" [_ "Private Use Area - Conlang Seussian Latin Extensions"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E650-0x00E68F\]\n" [_ "Private Use Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E690-0x00E6CF\]\n" [_ "Private Use Area - Conlang Ewellic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E6D0-0x00E6FF\]\n" [_ "Private Use Area - Conlang Phaistos Disc"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E740-0x00E76F\]\n" [_ "Private Use Area - Conlang Unifon"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E770-0x00E77F\]\n" [_ "Private Use Area - Conlang Solresol"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E780-0x00E7FF\]\n" [_ "Private Use Area - Conlang Visible Speech"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E800-0x00E82F\]\n" [_ "Private Use Area - Conlang Monofon"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E830-0x00EDFF\]\n" [_ "Private Use Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00EE00-0x00EEAF\]\n" [_ "Private Use Area - Hungarian Runes"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00EEB0-0x00F89F\]\n" [_ "Private Use Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00F8A0-0x00F8CF\]\n" [_ "Private Use Area - Conlang Aiha"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00F8D0-0x00F8FF\]\n" [_ "Private Use Area - Conlang Klingon"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E000-0x00F8FF\]\n" [_ "Private Use Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00F900-0x00FAFF\]\n" [_ "CJK Compatibility Ideographs"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FB00-0x00FB4F\]\n" [_ "Alphabetic Presentation Forms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FB50-0x00FDFF\]\n" [_ "Arabic Presentation Forms-A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE00-0x00FE0F\]\n" [_ "Variation Selectors"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE10-0x00FE1F\]\n" [_ "Vertical Forms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE20-0x00FE2F\]\n" [_ "Combining Half Marks"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE30-0x00FE4F\]\n" [_ "CJK Compatibility Forms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE50-0x00FE6F\]\n" [_ "Small Form Variants"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE70-0x00FEFF\]\n" [_ "Arabic Presentation Forms-B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FF00-0x00FFEF\]\n" [_ "Halfwidth and Fullwidth Forms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FFF0-0x00FFFF\]\n" [_ "Specials"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010000-0x01007F\]\n" [_ "Linear B Syllabary"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010080-0x0100FF\]\n" [_ "Linear B Ideograms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010100-0x01013F\]\n" [_ "Aegean Numbers"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010140-0x01018F\]\n" [_ "Ancient Greek Numbers"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010190-0x01027F\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010280-0x01029C\]\n" [_ "Lycian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01029D-0x01029F\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0102A0-0x0102D0\]\n" [_ "Carian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0102D1-0x0102FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010300-0x01032F\]\n" [_ "Old Italic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010330-0x01034F\]\n" [_ "Gothic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010380-0x01039F\]\n" [_ "Ugaritic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0103A0-0x0103DF\]\n" [_ "Old Persian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010400-0x01044F\]\n" [_ "Deseret"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010450-0x01047F\]\n" [_ "Shavian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010480-0x0104AF\]\n" [_ "Osmanya"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0104B0-0x0107FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010800-0x01083F\]\n" [_ "Cypriot Syllabary"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010840-0x0108FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010900-0x01091F\]\n" [_ "Phoenician"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010920-0x01093F\]\n" [_ "Lydian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010940-0x0109FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010A00-0x010A5F\]\n" [_ "Kharoshthi"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010A60-0x011FFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x012000-0x0123FF\]\n" [_ "Cuneiform"]];
	AppendToTextDisplay $po [format "%-52s  \[0x012400-0x01247F\]\n" [_ "Cuneiform Numbers and Punctuation"]];
	AppendToTextDisplay $po [format "%-52s  \[0x012480-0x01CFFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D000-0x01D0FF\]\n" [_ "Byzantine Musical Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D100-0x01D1FF\]\n" [_ "Musical Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D200-0x01D24F\]\n" [_ "Ancient Greek Musical Notation"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D250-0x01D2FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D300-0x01D35F\]\n" [_ "Tai Xuan Jing Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D360-0x01D37F\]\n" [_ "Counting Rod Numerals"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D380-0x01D3FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D400-0x01D7FF\]\n" [_ "Mathematical Alphanumeric Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D800-0x01FFFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x020000-0x02A6DF\]\n" [_ "CJK Unified Ideographs Extension B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x02A6E0-0x02F7FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x02F800-0x02FA1F\]\n" [_ "CJK Compatibility Ideographs Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x02FAB0-0x0DFFFF\]\n" [_ "Unused"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0E0000-0x0E007F\]\n" [_ "Tags"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0E0080-0x0E00FF\]\n" [_ "Unused"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0E0100-0x0E01EF\]\n" [_ "Variation Selectors Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0E01F0-0x0EFFFF\]\n" [_ "Unused"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0F0000-0x0F0E69\]\n" [_ "Supplementary Private Use Area-A Conlang Kinya Syllables"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0F0E70-0x0F16AF\]\n" [_ "Supplementary Private Use Area-A Conlang Pikto"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0F16B0-0x0FFFFF\]\n" [_ "Supplementary Private Use Area-A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0FFFFE-0x0FFFFF\]\n" [_ "Unused"]];
	AppendToTextDisplay $po [format "%-52s  \[0x100000-0x10FFFD\]\n" [_ "Supplementary Private Use Area-B"]];
    } else {
	AppendToTextDisplay $po [format "%-52s  \[0x010100-0x01013F\]\n" [_ "Aegean Numbers"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FB00-0x00FB4F\]\n" [_ "Alphabetic Presentation Forms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D200-0x01D24F\]\n" [_ "Ancient Greek Musical Notation"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010140-0x01018F\]\n" [_ "Ancient Greek Numbers"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FB50-0x00FDFF\]\n" [_ "Arabic Presentation Forms-A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE70-0x00FEFF\]\n" [_ "Arabic Presentation Forms-B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000750-0x00077F\]\n" [_ "Arabic Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000600-0x0006FF\]\n" [_ "Arabic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000530-0x00058F\]\n" [_ "Armenian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002190-0x0021FF\]\n" [_ "Arrows"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001B00-0x001B7F\]\n" [_ "Balinese"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000000-0x00007F\]\n" [_ "Basic Latin"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000980-0x0009FF\]\n" [_ "Bengali/Assamese"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002580-0x00259F\]\n" [_ "Block Elements"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0031A0-0x0031BF\]\n" [_ "Bopomofo Extended"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003100-0x00312F\]\n" [_ "Bopomofo"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002500-0x00257F\]\n" [_ "Box Drawing"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002800-0x0028FF\]\n" [_ "Braille Patterns"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001A00-0x001A1F\]\n" [_ "Buginese"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001740-0x00175F\]\n" [_ "Buhid"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D000-0x01D0FF\]\n" [_ "Byzantine Musical Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000080-0x0000FF\]\n" [_ "C1 Controls and Latin-1 Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002E80-0x002EFF\]\n" [_ "CJK Radicals Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00F900-0x00FAFF\]\n" [_ "CJK Compatibility Ideographs"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0031C0-0x0031EF\]\n" [_ "CJK Strokes"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003300-0x0033FF\]\n" [_ "CJK Compatibility"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE30-0x00FE4F\]\n" [_ "CJK Compatibility Forms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x004E00-0x009FAF\]\n" [_ "CJK Unified Ideographs"]];
	AppendToTextDisplay $po [format "%-52s  \[0x02F800-0x02FA1F\]\n" [_ "CJK Compatibility Ideographs Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003400-0x004DBF\]\n" [_ "CJK Unified Ideographs Extension A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x020000-0x02A6DF\]\n" [_ "CJK Unified Ideographs Extension B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003000-0x00303F\]\n" [_ "CJK Symbols and Punctuation"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0102A0-0x0102D0\]\n" [_ "Carian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00AA00-0x00AA5F\]\n" [_ "Cham"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0013A0-0x0013FF\]\n" [_ "Cherokee"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0020D0-0x0020FF\]\n" [_ "Combining Diacritical Marks for Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001DC0-0x001DFF\]\n" [_ "Combining Diacritical Marks Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000300-0x00036F\]\n" [_ "Combining Diacritical Marks"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE20-0x00FE2F\]\n" [_ "Combining Half Marks"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002400-0x00243F\]\n" [_ "Control Pictures"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002C80-0x002CFF\]\n" [_ "Coptic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D360-0x01D37F\]\n" [_ "Counting Rod Numerals"]];
	AppendToTextDisplay $po [format "%-52s  \[0x012400-0x01247F\]\n" [_ "Cuneiform Numbers and Punctuation"]];
	AppendToTextDisplay $po [format "%-52s  \[0x012000-0x0123FF\]\n" [_ "Cuneiform"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0020A0-0x0020CF\]\n" [_ "Currency Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010800-0x01083F\]\n" [_ "Cypriot Syllabary"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000500-0x00052F\]\n" [_ "Cyrillic Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000400-0x0004FF\]\n" [_ "Cyrillic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010400-0x01044F\]\n" [_ "Deseret"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000900-0x00097F\]\n" [_ "Devanagari"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002700-0x0027BF\]\n" [_ "Dingbats"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002460-0x0024FF\]\n" [_ "Enclosed Alphanumerics"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003200-0x0032FF\]\n" [_ "Enclosed CJK Letters and Months"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002D80-0x002DDF\]\n" [_ "Ethiopic Extended"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001380-0x00139F\]\n" [_ "Ethiopic Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001200-0x00137F\]\n" [_ "Ethiopic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002000-0x00206F\]\n" [_ "General Punctuation"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0025A0-0x0025FF\]\n" [_ "Geometric Shapes"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002D00-0x002D2F\]\n" [_ "Georgian Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0010A0-0x0010FF\]\n" [_ "Georgian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002C00-0x002C5F\]\n" [_ "Glagolitic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010330-0x01034F\]\n" [_ "Gothic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001F00-0x001FFF\]\n" [_ "Greek Extended"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000370-0x0003FF\]\n" [_ "Greek/Coptic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000A80-0x000AFF\]\n" [_ "Gujarati"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000A00-0x000A7F\]\n" [_ "Gurmukhi"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FF00-0x00FFEF\]\n" [_ "Halfwidth and Fullwidth Forms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003130-0x00318F\]\n" [_ "Hangul Compatibility Jamo"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00AC00-0x00D7AF\]\n" [_ "Hangul Syllables"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001100-0x0011FF\]\n" [_ "Hangul Jamo"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001720-0x00173F\]\n" [_ "Hanunoo"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000590-0x0005FF\]\n" [_ "Hebrew"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00DB80-0x00DBFF\]\n" [_ "High Private Use Surrogate Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00D800-0x00DB7F\]\n" [_ "High Surrogate Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003040-0x00309F\]\n" [_ "Hiragana"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000250-0x0002AF\]\n" [_ "IPA Extensions"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002FF0-0x002FFF\]\n" [_ "Ideographic Description Characters"]];
	AppendToTextDisplay $po [format "%-52s  \[0x003190-0x00319F\]\n" [_ "Kanbun (Kunten)"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002F00-0x002FDF\]\n" [_ "Kangxi Radicals"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000C80-0x000CFF\]\n" [_ "Kannada"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0031F0-0x0031FF\]\n" [_ "Katakana Phonetic Extensions"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0030A0-0x0030FF\]\n" [_ "Katakana"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A900-0x00A92F\]\n" [_ "Kayah Li"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010A00-0x010A5F\]\n" [_ "Kharoshthi"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0019E0-0x0019FF\]\n" [_ "Khmer Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001780-0x0017FF\]\n" [_ "Khmer"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000E80-0x000EFF\]\n" [_ "Lao"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001E00-0x001EFF\]\n" [_ "Latin Extended Additional"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002C60-0x002C7F\]\n" [_ "Latin Extended-C"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000180-0x00024F\]\n" [_ "Latin Extended-B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000100-0x00017F\]\n" [_ "Latin Extended-A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A720-0x00A7FF\]\n" [_ "Latin Extended-D"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001C00-0x001C4F\]\n" [_ "Lepcha"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002100-0x00214F\]\n" [_ "Letterlike Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001900-0x00194F\]\n" [_ "Limbu"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010000-0x01007F\]\n" [_ "Linear B Syllabary"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010080-0x0100FF\]\n" [_ "Linear B Ideograms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00DC00-0x00DFFF\]\n" [_ "Low Surrogate Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010280-0x01029C\]\n" [_ "Lycian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010920-0x01093F\]\n" [_ "Lydian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000D00-0x000D7F\]\n" [_ "Malayalam"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D400-0x01D7FF\]\n" [_ "Mathematical Alphanumeric Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002200-0x0022FF\]\n" [_ "Mathematical Operators"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002300-0x0023FF\]\n" [_ "Miscellaneous Technical"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0027C0-0x0027EF\]\n" [_ "Miscellaneous Mathematical Symbols-A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002980-0x0029FF\]\n" [_ "Miscellaneous Mathematical Symbols-B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002B00-0x002BFF\]\n" [_ "Miscellaneous Symbols and Arrows"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002600-0x0026FF\]\n" [_ "Miscellaneous Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A700-0x00A71F\]\n" [_ "Modifier Tone Letters"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001800-0x0018AF\]\n" [_ "Mongolian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D100-0x01D1FF\]\n" [_ "Musical Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001000-0x00109F\]\n" [_ "Myanmar"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001980-0x0019DF\]\n" [_ "New Tai Lue"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0007C0-0x0007FF\]\n" [_ "Nko"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002150-0x00218F\]\n" [_ "Number Forms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001680-0x00169F\]\n" [_ "Ogham"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001C50-0x001C7F\]\n" [_ "Ol Chiki"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0103A0-0x0103DF\]\n" [_ "Old Persian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010300-0x01032F\]\n" [_ "Old Italic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002440-0x00245F\]\n" [_ "Optical Character Recognition"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000B00-0x000B7F\]\n" [_ "Oriya"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010480-0x0104AF\]\n" [_ "Osmanya"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A840-0x00A87F\]\n" [_ "Phags-pa"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010900-0x01091F\]\n" [_ "Phoenician"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001D00-0x001D7F\]\n" [_ "Phonetic Extensions"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001D80-0x001DBF\]\n" [_ "Phonetic Extensions Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E580-0x00E59F\]\n" [_ "Private Use Area - Conlang Telarasso"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E800-0x00E82F\]\n" [_ "Private Use Area - Conlang Monofon"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E400-0x00E42F\]\n" [_ "Private Use Area - Conlang Niskloz"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E830-0x00EDFF\]\n" [_ "Private Use Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E470-0x00E48F\]\n" [_ "Private Use Area - Conlang Zarkhand"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00EE00-0x00EEAF\]\n" [_ "Private Use Area - Hungarian Runes"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E4C0-0x00E4EF\]\n" [_ "Private Use Area - Conlang Serivelna"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00EEB0-0x00F89F\]\n" [_ "Private Use Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E500-0x00E51F\]\n" [_ "Private Use Area - Conlang Saklor"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00F8A0-0x00F8CF\]\n" [_ "Private Use Area - Conlang Aiha"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E550-0x00E57F\]\n" [_ "Private Use Area - Conlang Alzetjan"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00F8D0-0x00F8FF\]\n" [_ "Private Use Area - Conlang Klingon"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E5C0-0x00E5DF\]\n" [_ "Private Use Area - Conlang Gargoyle"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E000-0x00F8FF\]\n" [_ "Private Use Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E600-0x00E62F\]\n" [_ "Private Use Area - Conlang Ferengi"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E630-0x00E64F\]\n" [_ "Private Use Area - Conlang Seussian Latin Extensions"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E650-0x00E68F\]\n" [_ "Private Use Area"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E690-0x00E6CF\]\n" [_ "Private Use Area - Conlang Ewellic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E430-0x00E44F\]\n" [_ "Private Use Area - Conlang Kazat ?akkorou"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E740-0x00E76F\]\n" [_ "Private Use Area - Conlang Unifon"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E770-0x00E77F\]\n" [_ "Private Use Area - Conlang Solresol"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E380-0x00E3AF\]\n" [_ "Private Use Area - Conlang Thelwik"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E780-0x00E7FF\]\n" [_ "Private Use Area - Conlang Visible Speech"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E490-0x00E4BF\]\n" [_ "Private Use Area - Conlang Rozhxh"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E4F0-0x00E4FF\]\n" [_ "Private Use Area - Conlang Kelwathi"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E360-0x00E37F\]\n" [_ "Private Use Area - Conlang Sarkai"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E520-0x00E54F\]\n" [_ "Private Use Area - Conlang Rynnan"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E5E0-0x00E5FF\]\n" [_ "Private Use Area - Conlang Ophidian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E000-0x00E07F\]\n" [_ "Private Use Area - Conlang Tengwar"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E6D0-0x00E6FF\]\n" [_ "Private Use Area - Conlang Phaistos Disc"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E080-0x00E0FF\]\n" [_ "Private Use Area - Conlang brie.Cirth"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E3B0-0x00E3FF\]\n" [_ "Private Use Area - Conlang Olaetyan"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E450-0x00E46F\]\n" [_ "Private Use Area - Conlang Kazvarad"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E5A0-0x00E5BF\]\n" [_ "Private Use Area - Conlang Ssuraki"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E2E0-0x00E2FF\]\n" [_ "Private Use Area - Conlang Xaini"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E300-0x00E33F\]\n" [_ "Private Use Area - Conlang Mizarian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00E340-0x00E35F\]\n" [_ "Private Use Area - Conlang Ziri:nka"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A930-0x00A95F\]\n" [_ "Rejang"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0016A0-0x0016FF\]\n" [_ "Runic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A880-0x00A8DF\]\n" [_ "Saurashtra"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010450-0x01047F\]\n" [_ "Shavian"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000D80-0x000DFF\]\n" [_ "Sinhala"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE50-0x00FE6F\]\n" [_ "Small Form Variants"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0002B0-0x0002FF\]\n" [_ "Spacing Modifier Letters"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FFF0-0x00FFFF\]\n" [_ "Specials"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001B80-0x001BBF\]\n" [_ "Sundanese"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002070-0x00209F\]\n" [_ "Superscripts and Subscripts"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002A00-0x002AFF\]\n" [_ "Supplemental Mathematical Operators"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0027F0-0x0027FF\]\n" [_ "Supplemental Arrows-A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002900-0x00297F\]\n" [_ "Supplemental Arrows-B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002E00-0x002E7F\]\n" [_ "Supplemental Punctuation"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0F16B0-0x0FFFFF\]\n" [_ "Supplementary Private Use Area-A"]];
	AppendToTextDisplay $po [format "%-52s  \[0x100000-0x10FFFD\]\n" [_ "Supplementary Private Use Area-B"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0F0E70-0x0F16AF\]\n" [_ "Supplementary Private Use Area-A Conlang Pikto"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0F0000-0x0F0E69\]\n" [_ "Supplementary Private Use Area-A Conlang Kinya Syllables"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A800-0x00A82F\]\n" [_ "Syloti Nagri"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000700-0x00074F\]\n" [_ "Syriac"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001700-0x00171F\]\n" [_ "Tagalog"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001760-0x00177F\]\n" [_ "Tagbanwa"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0E0000-0x0E007F\]\n" [_ "Tags"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D300-0x01D35F\]\n" [_ "Tai Xuan Jing Symbols"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001950-0x00197F\]\n" [_ "Tai Le"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000B80-0x000BFF\]\n" [_ "Tamil"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000C00-0x000C7F\]\n" [_ "Telugu"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000780-0x0007BF\]\n" [_ "Thaana"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000E00-0x000E7F\]\n" [_ "Thai"]];
	AppendToTextDisplay $po [format "%-52s  \[0x000F00-0x000FFF\]\n" [_ "Tibetan"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002D30-0x002D7F\]\n" [_ "Tifinagh"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010380-0x01039F\]\n" [_ "Ugaritic"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A4D0-0x00A4FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D250-0x01D2FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x002FE0-0x002FEF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A960-0x00A9FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001C80-0x001CFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x009FB0-0x009FFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010840-0x0108FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001A20-0x001AFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0018B0-0x0018FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A960-0x00ABFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0008C0-0x0008FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D380-0x01D3FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A8E0-0x00A8FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010190-0x01027F\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A640-0x00A6FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01D800-0x01FFFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A830-0x00A83F\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00D7B0-0x00D7FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010A60-0x011FFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x02A6E0-0x02F7FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x010940-0x0109FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x012480-0x01CFFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0104B0-0x0107FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x01029D-0x01029F\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0102D1-0x0102FF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001BC0-0x001BFF\]\n" [_ "Undefined"]];
	AppendToTextDisplay $po [format "%-52s  \[0x001400-0x00167F\]\n" [_ "Unified Canadian Aboriginal Syllabics"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0E01F0-0x0EFFFF\]\n" [_ "Unused"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0FFFFE-0x0FFFFF\]\n" [_ "Unused"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0E0080-0x0E00FF\]\n" [_ "Unused"]];
	AppendToTextDisplay $po [format "%-52s  \[0x02FAB0-0x0DFFFF\]\n" [_ "Unused"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A500-0x00A63F\]\n" [_ "Vai"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE00-0x00FE0F\]\n" [_ "Variation Selectors"]];
	AppendToTextDisplay $po [format "%-52s  \[0x0E0100-0x0E01EF\]\n" [_ "Variation Selectors Supplement"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00FE10-0x00FE1F\]\n" [_ "Vertical Forms"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A000-0x00A48F\]\n" [_ "Yi Syllables"]];
	AppendToTextDisplay $po [format "%-52s  \[0x00A490-0x00A4CF\]\n" [_ "Yi Radicals"]];
	AppendToTextDisplay $po [format "%-52s  \[0x004DC0-0x004DFF\]\n" [_ "Yijing Hexagram Symbols"]];
    }
}

proc UpdateUnicodeRangeSort {} {
    if {[winfo exists $::PopupList(ShowUnicodeRanges)]} {
	destroy $::PopupList(ShowUnicodeRanges);
	ShowUnicodeRanges;
    }
}

proc ToggleUnicodeGCP {} {
    if {[winfo exists $::PopupList(ShowUnicodeGCP)] == 0} {
	ShowUnicodeGCP;
    } else {
	destroy $::PopupList(ShowUnicodeGCP);
    }
}

proc ToggleUnicodeRangesByCodepoint {} {
    if {$::SortUnicodeRangesByCodepointP} {
	set ::SortUnicodeRangesByCodepointP 0
    } else {
	set ::SortUnicodeRangesByCodepointP 1
    }
    UpdateUnicodeRangeSort;
}

proc ToggleComparisonWindow {} {
    global ComparisonWindowDisplayedP;
    global MenuIndex;
    global m;

    if {$ComparisonWindowDisplayedP} {
	set ComparisonWindowDisplayedP 0;
	$m.file.comp entryconfigure $MenuIndex(ToggleComparisonWindow) -label [_ "Display Comparison Window"];
    } else {
	set ComparisonWindowDisplayedP 1;
	$m.file.comp entryconfigure $MenuIndex(ToggleComparisonWindow) -label [_ "Hide Comparison Window"];
    }
    LayoutWindows;
}


proc ListWindows {} {
    global Wlist;

    foreach key [lsort [array names Wlist]] {
	puts $Wlist($key);
    }
}

proc new_dialog_create {class {win "auto"}} {
    if {$win == "auto"} {
        set count 0
        set win ".ndialog[incr count]"
        while {[winfo exists $win]} {
            set win ".ndialog[incr count]"
        }
    }
    toplevel $win -class $class;
    frame $win.info
    pack $win.info -expand yes -fill both -padx 4 -pady 4
    wm title $win $class
    wm group $win .

    after idle [format {
        update idletasks
        wm minsize %s [winfo reqwidth %s] [winfo reqheight %s]
    } $win $win $win]

    return $win
}

# The following code is taken from the Efftcl library by Mark Harrison and
# Michael McLennan, copyrighted by Mark Harrison and Lucent Technologies, available
# from http://www.awprofessional.com/content/images/0201634740/sourcecode/efftcl.zip.
# As the authors explicitly give permission to "steal the code for your own applications"
# the relevant portions are included here so as not to require the user to install
# to install the library. If you install the library, remove the following and
# uncomment the line "#package require Efftcl" by deleting the crosshatch.

#  Effective Tcl/Tk Programming
#    Mark Harrison, DSC Communications Corp.
#    Michael McLennan, Bell Labs Innovations for Lucent Technologies
#    Addison-Wesley Professional Computing Series
# ======================================================================
#  Copyright (c) 1996-1997  Lucent Technologies Inc. and Mark Harrison
# ======================================================================

proc dialog_create {class {win "auto"}} {
    if {$win == "auto"} {
        set count 0
        set win ".dialog[incr count]"
        while {[winfo exists $win]} {
            set win ".dialog[incr count]"
        }
    }
    toplevel $win -class $class -background \#2200DD;

    frame $win.info
    pack $win.info -expand yes -fill both -padx 4 -pady 4
    frame $win.sep -height 2 -borderwidth 1 -relief sunken
    pack $win.sep -fill x -pady 4
    frame $win.controls
    pack $win.controls -fill x -padx 4 -pady 1

    wm title $win $class
    wm group $win .

    after idle [format {
        update idletasks
        wm minsize %s [winfo reqwidth %s] [winfo reqheight %s]
    } $win $win $win]

    return $win
}

proc dialog_info {win} {
    return "$win.info"
}

proc dialog_controls {win} {
    return "$win.controls"
}

proc dialog_wait {win varName} {
    dialog_safeguard $win

    set x [expr [winfo rootx .]+50]
    set y [expr [winfo rooty .]+50]
    wm geometry $win "+$x+$y"

    wm deiconify $win
    grab set $win

    vwait $varName

    grab release $win
    wm withdraw $win
}

bind modalDialog <ButtonPress> {
    wm deiconify %W
    raise %W
}
proc dialog_safeguard {win} {
    if {[lsearch [bindtags $win] modalDialog] < 0} {
        bindtags $win [linsert [bindtags $win] 0 modalDialog]
    }
}

proc ShowGPL {} {
    if {[PopupDown ShowGPL] ==1} {return}
    set po [CreateTextDisplay [_ "License"] 70 24]
    set ::PopupList(ShowGPL) $po;
    BindKeys $po;
    AppendToTextDisplay $po [format "%s%s" [format "%s\n\t%s\n" [_ "For this license in your language see:"] [_ "http://www.gnu.org/copyleft/gpl.html"]]  "\
\

		    GNU GENERAL PUBLIC LICENSE\

                       Version 3, 29 June 2007\


 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
\

                            Preamble
\

  The GNU General Public License is a free, copyleft license for
software and other kinds of works.
\

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.
\

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
\

  To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
\

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.
\

  Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
\

  For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
\

  Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
\

  Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
\

  The precise terms and conditions for copying, distribution and
modification follow.
\

                       TERMS AND CONDITIONS
\

  0. Definitions.
\

  \"This License\" refers to version 3 of the GNU General Public License.
\

  \"Copyright\" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
\

  \"The Program\" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as \"you\".  \"Licensees\" and
\"recipients\" may be individuals or organizations.
\

  To \"modify\" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a \"modified version\" of the
earlier work or a work \"based on\" the earlier work.
\

  A \"covered work\" means either the unmodified Program or a work based
on the Program.
\

  To \"propagate\" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
\

  To \"convey\" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
\

  An interactive user interface displays \"Appropriate Legal Notices\"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
\

  1. Source Code.
\

  The \"source code\" for a work means the preferred form of the work
for making modifications to it.  \"Object code\" means any non-source
form of a work.
\

  A \"Standard Interface\" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
\

  The \"System Libraries\" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
\"Major Component\", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
\

  The \"Corresponding Source\" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
\

  The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
\

  The Corresponding Source for a work in source code form is that
same work.
\

  2. Basic Permissions.
\

  All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
\

  You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
\

  Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.
\

  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
\

  No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
\

  When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
\

  4. Conveying Verbatim Copies.
\

  You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
\

  You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
\

  5. Conveying Modified Source Versions.
\

  You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
\

    a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.
\

    b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    \"keep intact all notices\".
\

    c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.
\

    d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.
\

  A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
\"aggregate\" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
\

  6. Conveying Non-Source Forms.
\

  You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
\

    a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.
\

    b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.
\

    c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.
\

    d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.
\

    e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.
\

  A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
\

  A \"User Product\" is either (1) a \"consumer product\", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, \"normally used\" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
\

  \"Installation Information\" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
\

  If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
\

  The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
\

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
\

  7. Additional Terms.
\

  \"Additional permissions\" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
\

  When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
\

  Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
\

    a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or
\

    b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or
\

    c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or
\

    d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or
\

    e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or
\

    f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.
\

  All other non-permissive additional terms are considered \"further
restrictions\" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
\

  If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
\

  Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
\

  8. Termination.
\

  You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
\

  However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
\

  Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
\

  Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
\

  9. Acceptance Not Required for Having Copies.
\

  You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
\

  10. Automatic Licensing of Downstream Recipients.

  Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.
\

  An \"entity transaction\" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
\

  You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
\

  11. Patents.
\

  A \"contributor\" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's \"contributor version\".
\

  A contributor's \"essential patent claims\" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, \"control\" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
\

  Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
\

  In the following three paragraphs, a \"patent license\" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To \"grant\" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
\

  If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  \"Knowingly relying\" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
\

  If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
\

  A patent license is \"discriminatory\" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
\

  Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
\

  12. No Surrender of Others' Freedom.
\

  If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
\

  13. Use with the GNU Affero General Public License.
\

  Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
\

  14. Revised Versions of this License.
\

  The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
\

  Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License \"or any later version\" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
\

  If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
\

  Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
\

  15. Disclaimer of Warranty.
\

  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
\

  16. Limitation of Liability.
\

  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
\

  17. Interpretation of Sections 15 and 16.
\

  If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
"]
}

#Write out a list of init file commands that will reconstruct
#the current configuration 
proc SaveState {{SaveFile Ask}} {
    if {[string equal $SaveFile Ask]} { 
	set SaveFile [tk_getSaveFile -initialfile [_ "SavedState"]];
	if {$SaveFile == ""} {
	    ShowMessage [_ "File selection cancelled."]
	    return ;
	}
    }
    if {[catch {open $SaveFile "w"} fh ] != 0} {
	ShowMessage [format [_ "Unable to open file %s."] [MinimizeFileName $SaveFile]];
	return ;
    }
    set cl [concat \
	[list [format "\#%s" [clock format [clock seconds]]]] \
	[list [format "\#%s" [_ Fonts]]] \
	[fontsel::SaveFontSettings] \
	[list [format "\#%s" [_ Colors]]] \
	[SaveColorSettings] \
	[list [format "\#%s" [_ "Palette Entries"]]] \
	[SavePaletteEntries] \
	[list [format "\#%s" [_ "Character Classes"]]] \
	[SaveUserClasses] \
	[list [format "\#%s" [_ Miscellaneous]]] \
	[SaveMiscellaneousSettings]];
    foreach x $cl {
	puts $fh $x;
    }
    close $fh;
    ShowMessage [format [_ "The configuration has been saved in file %s."] \
		     [MinimizeFileName $SaveFile]]
}

proc Usage {} {
    puts {Usage: redet [options] (<input text file>)};
    puts [_ "    -c <file>     read character class definitions from <file>"];
    puts [_ "    -d            set debug flag"];
    puts [_ "    -F <file>     read a feature list from <file>"];
    puts [_ "    -f            act as filter"];
    puts [_ "    -H            do not read history file"];
    puts [_ "    -h            help"];
    puts [_ "    -I <file>     read <file> as init file"];
    puts [_ "    -i            do not read init file"];
    puts [_ "    -l <locale>   internally set the locale to <locale>"];
    puts [_ "    -n            do not execute feature tests"];
    puts [_ "    -p <program>  use <program>"];
    puts [_ "    -P            list the programs supported"];
    puts [_ "    -s            start up in substitution mode"];
    puts [_ "    -t            show results of feature tests"];
    puts [_ "    -v            version"];
}

proc PopupTestPatiencePlacard {txt ForbidAbortP} {
    global ColorSpecs;

    toplevel .placard -borderwidth 4 -relief raised  -bg $ColorSpecs(Placard,Background)
    wm title .placard [_ "Feature Test Progress"];
    after idle {
	update idletasks
	set xmax [winfo screenwidth .placard]
	set ymax [winfo screenheight .placard]
	set x0 [expr int(2.4 * ($xmax -[winfo reqwidth .placard])/3.0)];
	set y0 [expr int(2.3 * ($ymax -[winfo reqheight .placard])/3.0)];
	wm geometry .placard "+$x0+$y0";
    }
    label .placard.title -text $txt -bg $ColorSpecs(Placard,Background) -fg $ColorSpecs(Placard,Foreground)
    button .placard.dismiss -text [_ "Abort"] -command AbortFeatureTests;
    Progress .placard.progbar;
    label .placard.time -text [format [_ "time elapsed: %1d minutes %2d seconds\nestimated total time: ? minutes  ? seconds\nestimated time remaining: ? minutes  ? seconds"] 0 0]\
	-bg $ColorSpecs(Placard,Background) -fg $ColorSpecs(Placard,Foreground)
    pack .placard.title -side top -fill x -padx 8 -pady 8;
    pack .placard.time -side top  -fill x -padx 8 -pady 8;
    pack .placard.progbar -side left -fill both -expand 1;
    if {!$ForbidAbortP} {
	pack .placard.dismiss -side right;
    }
    catch {.placard.title configure -font -*-Courier-bold-o-normal--*-140-*}
    catch {.placard.time configure -font -*-Courier-bold-o-normal--*-130-*}
}

proc AbortFeatureTests {} {
    if {$::FirstTestP} {
	ShowMessage [_ "The initial test run cannot be aborted."]
	return ;
    }
    set ::AbortFeatureTestP 1;
    set killpid $::tk_exec_pipe(pid)
    # We give the daughter a chance to exit nicely
    # before terminating with extreme prejudice.
    if {$::tcl_platform(platform) eq "unix"} {
	catch {[exec kill -s TERM $killpid]}
	after 100 {
	    catch {[exec kill -s KILL $killpid]}
	}
    }
}

proc AbortSearch {} {
    if {$::TestingFeaturesP} {
	AbortFeatureTests;
	return ;
    }
    if {$::tcl_platform(platform) eq "unix"} {
	if {[info exists ::tk_exec_pipe(pid)]} {
	    set killpid $::tk_exec_pipe(pid)
	    # We give the daughter a chance to exit nicely
	    # before terminating with extreme prejudice.
	    catch {[exec kill -s TERM $killpid]}
	    after 20 {
		catch {[exec kill -s KILL $killpid]}
	    }
	    if {$::DoSubstitutionsP} {
		ShowMessage [_ "Substitution aborted by user."]
	    } else {
		ShowMessage [_ "Search aborted by user."]
	    }
	} else {
	    ShowMessage [_ "There is nothing to abort."]
	}
    } else {
	ShowMessage [format [_ "%s does not support the abort command."] $::System]
    }
}

proc PopupAlert {name txt} {
    global ColorSpecs;

    destroy .alert_$name;
    toplevel .alert_$name -borderwidth 4 -relief raised -bg $ColorSpecs(Alert,Background)
    wm overrideredirect .alert_$name 1;
    label .alert_$name.title -text $txt -bg  $::ColorSpecs(Alert,Background) -fg $::ColorSpecs(Alert,Foreground);
    button .alert_$name.dismiss -text [_ "Dismiss"] -bg $::ColorSpecs(AlertDismiss,Background) -fg $::ColorSpecs(AlertDismiss,Foreground) -command "destroy .alert_$name";
    pack .alert_$name.title -side top -fill x -padx 8 -pady 8;
    pack .alert_$name.dismiss -side right;
    catch {.alert_$name.title configure -font -*-Courier-bold-o-normal--*-180-*}
}


option add  *art.*Background $::ColorSpecs(PopupWidgetDefault,Background) 100;
option add  *art.*Foreground $::ColorSpecs(PopupWidgetDefault,Foreground) 100;
option add  *art.*Text.Background $::ColorSpecs(PopupWidgetEntry,Background) 100;

proc PopupActualRegexp {} {
    global MainWidth;
    global MainFont;
    toplevel .art -borderwidth 4 -relief raised
    wm title .art [_ "Actual Regular Expression"]
    after idle {
	update idletasks
	set xmax [winfo screenwidth .art]
	set ymax [winfo screenheight .art]
	set x0 [expr 2 * ($xmax -[winfo reqwidth .art])/3];
	set y0 [expr 2 * ($ymax -[winfo reqheight .art])/3];
	wm geometry .art "+$x0+$y0";
    }
    label .art.title -text [_ "Regular Expression Actually Executed"];
    pack .art.title -side top -fill x -padx 8 -pady 8;
    text .art.txt -width $MainWidth -height 3 -font TextFont -exportselection 1;
    pack .art.txt -side top -fill x -padx 8 -pady 8;
    catch {.art.title configure -font -*-Courier-bold-o-normal--*-180-*}
    BindKeys .art;
    bind .art.txt <<B3>> {ShowCode %W %x %y}
}

proc ToggleActualRegexp {} {
    global PreviousActualRegexp;
    global DisplayActualRegexpIndex;
    global DescribeDisplayActualRegexpIndex;
    global m;

    if {[winfo exists .art]} {
	destroy .art;
	$m.tools.classes entryconfigure $DisplayActualRegexpIndex -label [_ "Display Regular Expression Actually Executed"];
    } else {
	PopupActualRegexp;
	DisplayActualRegexp $PreviousActualRegexp;
	$m.tools.classes entryconfigure $DisplayActualRegexpIndex -label [_ "Do Not Display Regular Expression Actually Executed"];
    }
}

proc DisplayActualRegexp {are} {
    if {[winfo exists .art.txt]} {
	.art.txt delete 1.0 end;
	.art.txt insert 1.0 $are;
    }
}

#Put a title in the frame.
proc SetTitle {version TimeStamp locale dosubsp} {
    if {$dosubsp} {
	set mode [_ "Substitution Mode"];
    } else {
	set mode [_ "Match Mode"];
    }
    if {$::DebugP||$::DevP} {
	wm title . [format "Redet %s \[%s\]      %s        %s" $version $TimeStamp $locale $mode];
    } else {
	wm title . [format "Redet %s       %s        %s" $version $locale $mode];
    }

}


#Set up balloon help
option add *Balloonhelp*background white widgetDefault
option add *Balloonhelp*foreground black widgetDefault
option add *Balloonhelpinfo.wrapLength 3i  widgetDefault
option add *Balloonhelp.info.justify left widgetDefault
toplevel .balloonhelp -class Balloonhelp -background black -borderwidth 1 -relief flat
#label .balloonhelp.arrow -anchor nw -bitmap @arrow.xbm
#pack .balloonhelp.arrow -side left -fill y
label .balloonhelp.info -font BalloonHelpFont;
pack .balloonhelp.info -side left -fill y
wm overrideredirect .balloonhelp 1
wm withdraw .balloonhelp
set bhInfo(active) 1

proc balloonhelp_control {state} {
     global bhInfo
     if {$state} {
          set bhInfo(active) 1
     } else {
	balloonhelp_cancel
	set bhInfo(active) 0
     }
}

proc balloonhelp_for {win mesg} {
    global bhInfo
    set bhInfo($win) $mesg
    set ::bhOverlapP($win) 1; 
    bind $win <Enter> {+balloonhelp_pending %W}
    bind $win <Leave> {+balloonhelp_cancel}
}

proc balloonhelpd_for {win mesg} {
    global bhInfo
    set ::bhOverlapP($win) 0;
    set bhInfo($win) $mesg
    bind $win <Enter> {+balloonhelp_show %W}
}

proc balloonhelp_pending {win} {
     global bhInfo
     balloonhelp_cancel
     set bhInfo(pending) [after 1000 [list balloonhelp_show $win]]
}

proc balloonhelp_cancel {} {
    global bhInfo
    if { [info exists bhInfo(pending)]} {
	after cancel $bhInfo(pending)
	unset bhInfo(pending)
    }
    wm withdraw .balloonhelp
}

proc balloonhelp_show {win} {
    global bhInfo;
    global bhOverlapP;
    if {[info exists bhOverlapP($win)]} {
	if {$bhOverlapP($win)} {
	    set Overlap 25;
	} else {
	    set Overlap -10;
	}
	if {[winfo exists $win]} {
	    if {$bhInfo(active)} {
		.balloonhelp.info configure -text $bhInfo($win) -font BalloonHelpFont
		#Set abcissa
		set MaxStringWidth 0;
		foreach line [split $bhInfo($win) "\n"] {
		    set StringWidth [font measure BalloonHelpFont -displayof .balloonhelp.info $line]
		    if {$StringWidth > $MaxStringWidth} {
			set MaxStringWidth $StringWidth;
		    }
		}
		set ScreenWidth [winfo screenwidth $win]
		set Width [winfo width $win];
		set LeftEdge  [winfo rootx $win];
		set RightEdge [expr $LeftEdge + $Width];
		if {$ScreenWidth - $RightEdge < $MaxStringWidth} { 
		    if {$LeftEdge > $MaxStringWidth} {
			set x [expr $LeftEdge - $MaxStringWidth + $Overlap];
		    } else {
			if {$ScreenWidth - $MaxStringWidth > 0} {
			    set x [expr $RightEdge - $MaxStringWidth];
			} else {
			    set x [expr $ScreenWidth - $MaxStringWidth];
			}
		    }
		} else {
		    set x [expr $RightEdge - $Overlap];
		}
		#Set ordinate
		set Height [winfo height $win];
		set TopEdge [winfo rooty $win];
		set y [expr $TopEdge + ($Height/2)];
		wm geometry .balloonhelp +$x+$y
		wm deiconify .balloonhelp
		raise .balloonhelp
	    }
	}
    }
	if {[info exist bhInfo(pending)]} {
	    unset bhInfo(pending)
	}
    }

    proc GotoStandardLayout {} {
	if {$::DoSubstitutionsP} {
	    if {!$::RegSubSideBySideP || !$::SideBySideLayoutP} {
		set ::SideBySideLayoutP 1;
		set ::RegSubSideBySideP 1;
		LayoutWindows;
	    }
	} else {
	    if {$::RegSubSideBySideP || $::SideBySideLayoutP} {
		set ::SideBySideLayoutP 0;
		set ::RegSubSideBySideP 0;
		LayoutWindows;
	    }
	}
    }

proc UpdateScrollbars {} {
    LayoutWindows;
    hist::ConstructHistory;
    ConstructPalette;
    ConstructUserClassPalette;
}

#Any command to be made available for binding as a keyboard shortcut
#must be listed here. 
#This needs to be called when we change locale so as to change the
#translations. 
proc SetCommandGlosses {} {
    global CommandGlosses

    set Pairs [list\
	   LoadRegularExpressionFromPrimarySelection "[_ "Load regular expression from primary selection."]"\
	   SaveActualRegexp "[_ "Save the regular expression resulting from expansion of user-defined character classes to a file."]"\
	   TestFeatures "[_ "Execute the feature test suite."]"\
	   LoadRegularExpressionFromClipboard   "[_ "Load regular expression from clipboard."]"\
	   LoadRegularExpressionFromFile    "[_ "Load regular expression from file"]"\
	   SaveRegularExpressionAsHistory   "[_ "Save the regular expression (& substitution expression) in history file format"]"\
	   SaveRegexpPlain  "[_ "Save the regular expression as plain text."]"\
	   SaveSubexpPlain  "[_ "Save the substitution expression as plain text"]"\
	   ClearInput     "[_ "Clear the test data."]"\
	   EditTestInputData  "[_ "Make the test input data window editable."]"\
	   LoadTestDataFromClipboard  "[_ "Load the test data window with the contents of the clipboard"]"\
           LoadTestInputData "[_ "Load the test data window from a file."]"\
           SaveTestInputData "[_ "Write the contents of the test data window to a file."]"\
	   ClearOutput	   "[_ "Clear the result window."]"\
	   EditOutput 	   "[_ "Make the result window editable."]"\
	   LockOutput	       "[_ "Make the result window uneditable."]"\
	   SaveResults	   "[_ "Write the contents of the results window to a file."]"\
	   ToggleComparisonWindow   "[_ "Toggle the comparison data window."]"\
	   ClearOutputComparisonData   "[_ "Clear the comparison data window."]"\
	   LoadOutputComparisonDataFromClipboard "[_ "Load the comparison data window with the contents of the clipboard."]"\
	   LoadOutputComparisonData "[_ "Load the comparison data window from a file."]"\
	   ShutDown   "[_ "Quit"]"\
	   ExecuteRegexp "[_ "Execute Regular Expression"]"\
	   hist::ToggleHistory  "[_ "Toggle the display of the history list."]"\
	   hist::ToggleHistoryProgramDisplay "[_ "Toggle the display of the program column in the history list."]"\
	   hist::SaveHistoryList "[_ "Write the history list to a file."]"\
           hist::PruneHistoryList  "[_ "Prune the history list."]"\
           hist::ClearHistoryList  "[_ "Clear the history list."]"\
	   ClearRegexp "[_ "Clear the regular expression window."]"\
	   TogglePalette "[_ "Toggle display of the palette"]"\
	   AbortSearch   "[_ "Abort the search or substitution in progress."]"\
	   resc::PopupCachedEntries "[_ "Pop up a control panel for manipulating stored results"]"\
	   search::SearchTestData    "[_ "Search the Test Data"]"\
	   search::SearchResults    "[_ "Search the Results"]"\
           PopupCurrentProgramControls    "[_ "Pop up the control panel for the current program."]"\
	   ReadCustomCharacterChartPopup  "[_ "Read a custom character chart definition from a file."]"\
	   ToggleIPAA    "[_ "Toggle the accented letter entry widget."]"\
	   ToggleIPAC 	   "[_ "Toggle the IPA consonant entry widget."]"\
	   ToggleIPAV 	   "[_ "Toggle the IPA vowel entry widget."]"\
	   ToggleIPAD 	   "[_ "Toggle the IPA diacritic entry widget."]"\
	   ToggleCharEntryByCode  "[_ "Toggle the popup for entering characters by their Unicode code."]"\
	   GotoStandardLayout  "[_ "Change to the standard layout for this mode."]"\
	   PopupUserClassEntry	 "[_ "Toggle the display of the character class definition tool"]"\
	   ToggleUserClassPalette  "[_ "Toggle the display of the user class palette"]" \
	   ToggleActualRegexp   "[_ "Toggle the display of the regular expression actually executed"]"\
	   ToggleBalloonHelp   "[_ "Toggle the display of balloon help"]"\
	   DescribeKeyBindings "[_ "Toggle the display of the current keyboard shortcuts."]"\
	   ShowGPL "[_ "Toggle display of this program's license."]"\
	   ToggleSubstitutionMode  "[_ "Toggle between match mode & substitution mode."]"\
	   ShowUnicodeRanges   "[_ "Toggle display of the Unicode range popup."]"\
	   ToggleUnicodeRangesByCodepoint "[_ "Toggle sorting of unicode ranges by codepoint or range name."]"\
	   ShowUnicodeGCP "[_ "Toggle display of the Unicode general character properties popup."]"\
	   SelectFont "[_ "Pop up the font control panel."]"\
	   SelectInterfaceLocale  "[_ "Pop up the locale selection control panel."]"\
	   About  "[_ "Toggle the popup with basic information about Redet."]"\
	   BugReports  "[_ "Toggle the bug reports popup."]"\
	   CommandDescriptions  "[_ "Bring up the reference manual section on commands in a browser"]"\
	   CommandLineOptions  "[_ "Toggle information on command line options."]"\
	   WebManual  "[_ "Bring up the reference manual in a browser."]"\
	   DescribePrograms  "[_ "Toggle information about the supported programs."]"\
	   PopupProgramInfo "[_ "Toggle information about the current pattern matching engine."]"\
	   Description  "[_ "Toggle a general description of Redet. "]"\
	   ShowCommandLine  "[_ "Show the command line."]"\
	   PostFileMenu "[_ "Post a tearoff copy of the File menu."]"\
	   PostRegularExpressionMenu  "[_ "Post a tearoff copy of the Regular Expression menu"]"\
	   PostTestDataMenu   "[_ "Post a tearoff copy of the Test Data menu"]"\
	   PostResultsMenu    "[_ "Post a tearoff copy of the Results  menu"]"\
	   PostComparisonDataMenu  "[_ "Post a tearoff copy of the Comparison Data  menu"]"\
	   PostProgramMenu "[_ "Post a tearoff copy of the Program menu."]"\
	   PostHistoryMenu "[_ "Post a tearoff copy of the History menu."]"\
	   PostToolsMenu "[_ "Post a tearoff copy of the Tools menu."]"\
	   PostConfigureMenu "[_ "Post a tearoff copy of the Configure menu."]"\
	   PostHelpMenu "[_ "Post a tearoff copy of the Help menu."]"\
	   PostCharacterEntryMenu "[_ "Post a tearoff copy of the Character Entry menu."]"\
	   PostUserClassMenu "[_ "Post a tearoff copy of the User Class menu."]"\
	   PostFeatureTestingMenu "[_ "Post a tearoff copy of the Feature Testing menu."]"\
	   PostLayoutMenu "[_ "Post a tearoff copy of the Layout menu."]"\
	   PostMiscellaneousMenu "[_ "Post a tearoff copy of the Miscellaneous Configuration menu."]"\
	   PostProgramSpecificMenu "[_ "Post a tearoff copy of the Program Specific Configuration menu."]"\
	   EditOutputComparisonData     "[_ "Make the comparison data window editable."]"\
	   MoveResultsToTestData      "[_ "Replace the test data with the results and clear the result window."]"]
    array set CommandGlosses $Pairs;
}

proc SelectInterfaceLocale {} {
    global ProposedInterfaceLocale;
    global InterfaceLocaleText;
    global InterfaceLocaleListHeight;

    catch {set InterfaceLocaleText [exec locale -a]};
    set InterfaceLocaleList [split $InterfaceLocaleText "\n"];

    #See if there are any locales.
    if {$InterfaceLocaleList == 0} {
	ShowMessage [_ "No locales are available."];
	return 0;
    }
    if {[winfo exists .loclist] == 0} {
	toplevel .loclist;
    }
    wm title .loclist [_ "Available InterfaceLocales"];
    wm withdraw .loclist;
    destroy .loclist.lbf.lb;
    label .loclist.lab -text [_ "Select InterfaceLocale"];
    frame .loclist.lbf
    listbox .loclist.lbf.lb -height $InterfaceLocaleListHeight -width 0 -font MainFont \
	-yscrollcommand {.loclist.lbf.sb set}  -font MainFont \
	-fg $::ColorSpecs(PaletteGloss,Foreground) \
	-bg $::ColorSpecs(PaletteGloss,Background);
    scrollbar .loclist.lbf.sb -command {.loclist.lbf.lb yview} \
	-troughcolor $::ColorSpecs(PaletteGloss,Background) \
	-bg $::ColorSpecs(PaletteGloss,Background);
    bind .loclist.lbf.sb <<B3>> "ScrollbarMoveBigIncrement .loclist.lbf.sb 0.20 %x %y"
    foreach line $InterfaceLocaleList {
	.loclist.lbf.lb insert end $line;
    }
    bind .loclist.lbf.lb <<B3>> {
	set ProposedInterfaceLocale [.loclist.lbf.lb get active];
#	balloonhelp_cancel;
	destroy .loclist;
    }
    pack .loclist.lab -side top -expand 1  -fill both;
    pack .loclist.lbf.lb -side left -expand 1 -fill both -padx 5
    if {$::UseScrollbarsP} {
	pack .loclist.lbf.sb -side right -expand 1 -fill y;
    }
    pack .loclist.lbf -expand 1 -fill both
    button .loclist.cancel -text [_ "Cancel"] -command {destroy .loclist}
    button .loclist.proceed -text [_ "Save New InterfaceLocale"] -command {set ::ProposedInterfaceLocale [.loclist.lbf.lb get active];destroy .loclist};
    pack .loclist.cancel   -side left -expand yes -fill x;
    pack .loclist.proceed  -side left -expand yes -fill x;
    BindKeys .loclist;
    balloonhelp_for .loclist.lbf.lb  [_ "Right click to select new locale."]
    wm deiconify .loclist;
    grab set .loclist;
    tkwait window .loclist
}

proc SetInterfaceLocale {loc} {
    set nl [::msgcat::mclocale $loc];
    if {$nl != 0} {
	# We don't use nl/InterfaceLocale because msgcat downcases but some programs are case-sensitive.
	# GNU grep etc. support Unicode if the locale is zh_TW.UTF-8 but not zh_tw.utf-8.
	set ::env(LC_ALL) $loc;
	set ::env(LANGUAGE) $loc;
	return $loc
    }
    return "";
}

proc ChangeInterfaceLocale {} {
    global Version;
    global InterfaceLocale;
    global ProposedInterfaceLocale;
    global Features;
    global Program;
    global program;
    global ProposedInterfaceLocale;
    global FeatureTestDebugP;

    SelectInterfaceLocale;
    if {[string equal $ProposedInterfaceLocale ""]} {
	return;
    }
    set InterfaceLocale [SetInterfaceLocale $ProposedInterfaceLocale];
    SetTitle $::Version [ProgramTimeDateStamp] $::InterfaceLocale $::DoSubstitutionsP;
    LoadMessageCatalog;
    if { [FeaturesUnSetP $program $InterfaceLocale] } {
	TestFeatures;
	LabelMenus;
	MarkProgramTested;
	RefreshProginfo;
    }
    if {$FeatureTestDebugP} {
	puts "InterfaceLocale is now $InterfaceLocale";
	puts "Size of Features array [array size Features]";
    }
    SetCommandGlosses;
    SetFontGlossHelpTranslations;
    SetPalette;
    ConstructPalette;
    if {$Features(unicodebmp,$program,$InterfaceLocale) == 1} {
	ShowMessage [format [_ "The new locale is %s. %s supports Unicode in this locale."] $InterfaceLocale $Program];	
    } else {
	ShowMessage [format [_ "The new locale is %s. %s does not support Unicode in this locale."] $InterfaceLocale $Program];
    }
    return ;
}


proc DefineShortcut {command keyspec} {
    #Validate command
    if {![info exists ::CommandGlosses($command)]} {
	ShowMessage [format [_ "%s is not a command for which a shortcut can be created"] $command]
	return ;
    }
    #Validate keyspec
    if {![regexp -- {(<Control-[[:alpha:]]>|<KeyPress-F[1-9]>|<KeyPress-F1[0-2]>|<Control-KeyPress-F[1-9]>|<Control-KeyPress-F1[0-2]>)+} $keyspec]} {
	ShowMessage [format [_ "%s is not a valid key specification"] $keyspec]
	return ;
    }
    #Set
    set ::KeyBindings($keyspec) $command;
}

set PopupList(DescribeKeyBindings) "";
proc DescribeKeyBindings {{bl KeyBindings}} {
    global CommandGlosses;
    upvar \#0 $bl kb;
    if {[PopupDown DescribeKeyBindings] ==1} {return}
    set po [CreateTextDisplay [_ "Key Bindings"] 88 9]
    set ::PopupList(DescribeKeyBindings) $po;
    BindKeys $po
    #Invert array and get maximum length of gloss while we are at it.
    set MaxGlossLength 0;
    foreach KeySeq [array names kb] {
	set Gloss $CommandGlosses($kb($KeySeq));
	set GlossLength [string length $Gloss];
	if {$MaxGlossLength < $GlossLength} {set MaxGlossLength $GlossLength}
	set GlossToKeySeq($Gloss) $KeySeq;
    }
    #Now generate entries in alphabetical order of command glosses
    foreach Gloss [lsort [array names GlossToKeySeq]] {
	AppendToTextDisplay $po \
	    [format "%-*s\t%s\n" $MaxGlossLength $Gloss $GlossToKeySeq($Gloss)];
    }
}

proc PopupShortcutCommands {} {
    global PopupList;
    if {[PopupDown PopupShortcutCommands] ==1} {return}
    set CommandNames [array names ::CommandGlosses]
    set maxglosslen 0;
    set maxtotallen 0;
    foreach c $CommandNames {
	set GlossLength [string length $::CommandGlosses($c)]
	set CommandLength [string length $c]
	set TotalLength [expr $CommandLength + $GlossLength]
	if {$GlossLength > $maxglosslen} {
	    set maxglosslen $GlossLength;
	}
	if {$TotalLength > $maxtotallen} {
	    set maxtotallen $TotalLength;
	}
    }
    set ht [llength $CommandNames]
    if {$ht > 15} {set ht 15}
    set po [CreateTextDisplay [_ "Commands Available for Shortcuts"] [expr $maxtotallen + 9] $ht]
    BindKeys $po;
    set PopupList(PopupShortcutCommands) $po;
    AppendToTextDisplay $po [format "%-*s  Command\n\n" $maxglosslen "Description"];
    foreach n $CommandNames {
	lappend GlossList [list $::CommandGlosses($n) $n]
    }
    foreach pair [lsort -dictionary -index 0 $GlossList] {
	set gloss [lindex $pair 0]
	set command [lindex $pair 1]
	AppendToTextDisplay $po [format "%-*s  %s\n" $maxglosslen $gloss $command];
    }
}

array set KeyBindings {
"<Control-a>"             ToggleIPAA
"<Control-b>" ToggleBalloonHelp
"<Control-d>"             ToggleIPAD
"<Control-E>"		  PopupUserClassEntry
"<Control-e>"             ExecuteRegexp
"<Control-f>"		  ClearRegexp
"<Control-h>"             hist::ToggleHistory
"<Control-i>"             ToggleActualRegexp
"<Control-j>"             ToggleIPAC
"<Control-k>"             DescribeKeyBindings
"<Control-L>" 		  GotoStandardLayout
"<Control-l>"             ToggleUserClassPalette
"<Control-m>"             ToggleSubstitutionMode
"<Control-o>"             SaveResults
"<Control-p>"             TogglePalette
"<Control-r>"             search::SearchResults
"<Control-u>"             search::SearchTestData
"<Control-w>"             ToggleIPAV
"<Control-z>"             resc::PopupCachedEntries
"<Control-x><Control-i>"  ClearInput
"<Control-x><Control-o>"  ClearOutput
"<Control-x><Control-q>"  ShutDown
"<KeyPress-F1>"	ShowUnicodeRanges
"<KeyPress-F2>"  ShowUnicodeGCP
"<KeyPress-F3>"  ToggleUnicodeRangesByCodepoint
"<KeyPress-F4>"  PopupCurrentProgramControls
"<KeyPress-F5>"  LoadRegularExpressionFromPrimarySelection
"<KeyPress-F6>"	 MoveResultsToTestData
"<KeyPress-F12>" AbortSearch
};

proc BindKeys {w {bl KeyBindings}} {
    upvar \#0 $bl kb;
    foreach KeySeq [array names kb] {
	bind $w $KeySeq $kb($KeySeq);
    }
}

proc SetRegReturnBinding {} {
    global DoSubstitutionsP;

    if {$DoSubstitutionsP} {
    	bind $::REG <Return> {focus -force $::SUB}
    } else {
	bind $::REG <Return> {ExecuteRegexp};
    }
}

proc ConfirmationDialog {WindowName TitleText MainText LeftText RightText} {
    global wret;
    global MainFont;
    
    toplevel $WindowName -borderwidth 4 -relief raised
    wm title $WindowName "";
    label  $WindowName.title -text $TitleText -font MainFont;
    text $WindowName.txt -width 60 -height 2 -font MainFont;
    $WindowName.txt insert insert $MainText;
    button $WindowName.okay   -text $RightText -command {set wret 1} -font MainFont;
    button $WindowName.cancel -text $LeftText  -command {set wret 0} -font MainFont;
    grid $WindowName.title     -row 0 -column 0 -sticky ew -columnspan 2
    grid $WindowName.txt     -row 1 -column 0 -sticky ew -columnspan 2
    grid $WindowName.cancel    -row 2 -column 0
    grid $WindowName.okay      -row 2 -column 1
    tkwait variable wret;
    destroy $WindowName;
    return $wret;
}

# This section provides user-defined character classes.

set UserClassCnt 0;
array set UserClasses {};
array set UserClassGlosses {};
set UserClassPaletteIsDisplayedP 0;
set UserClassPaletteToBeDisplayedP 1;
set MaxUserClassGlossLength 0;
set UserClassColumnSeparation 6;
set LeftUserClassDelimiter  {[_}; #This is what the user uses to insert classes.
set RightUserClassDelimiter {_]}; #This is what the user uses to insert classes.
set LUDlen [string length $LeftUserClassDelimiter];
set RUDlen [string length $RightUserClassDelimiter];
set LeftUserIntDelimiter {<};
set RightUserIntDelimiter {>};

proc WarnAboutDelimiters {re} {
    if { ([string first $::LeftUserIntDelimiter $re] > -1) ||
	 ([string first $:RighttUserIntDelimiter $re] > -1) } {
	if {$::UserClassCnt == 0} {
	    ShowMessage \
		[_ "Regular expression contains intersection markers but no classes are defined."]
	    return 1
	}
    }
    return 0;
}

proc ToggleUserClassesEnabled {} {
    global UserClassesEnabledP;
    global ToggleUserClassesEnabledIndex;
    global DescribeToggleUserClassesEnabledIndex;
    global m;

    if {$UserClassesEnabledP == 0} {
	set UserClassesEnabledP 1;
	ShowMessage [_ "User classes enabled."];
	$m.tools.classes entryconfigure $ToggleUserClassesEnabledIndex -label [_ "Disable User Classes"];
	CheckUserClassAvailability;
    } else {
	set UserClassesEnabledP 0;
	ShowMessage [_ "User classes disabled."];
	$m.tools.classes entryconfigure $ToggleUserClassesEnabledIndex -label  [_ "Enable User Classes"];
    }
}

# return a string comprised of the characters in the
# intersection of two strings S1 and S2
proc stringint { S1 S2 } {
#We begin by constructing two arrays whose indices are the characters
#in the input strings.
    set list1 [split $S1 ""];
    set list2 [split $S2 ""];
    array set set1 {}
    array set set2 {}
    foreach x $list1 {
	set set1($x) 1;
    }
    foreach x $list2 {
	set set2($x) 1;
    }
    #Now we actually find the intersection.
    array set intset {}
    foreach k [array names set2] {
	if {[info exists set1($k)]} then {
	    set intset($k) 1;
	}
    }
    #Now convert from array to list to string, sorting en passant.
    return [join [lsort [array names intset]] ""];
}


#This takes a cset and inserts any punctuation (dividers and quotation) required
#by the program for which it is destined.
proc FormatClass {Cset AltType} {

    set retlist [list];
    switch -exact -- $AltType {
	1 {
	    lappend retlist $Cset;
	}
	2 {
	    lappend retlist  [join [split $Cset ""] | ];
	}
	3 {
	    lappend retlist  [join [split $Cset ""] \\| ];
	}
	4 {
	    lappend retlist  [join [split $Cset ""] , ];
	}
	5 {
	    set letlist [split $Cset ""]
	    foreach x $letlist {
		lappend ql [format "\"%s\"" $x];
	    }
	    lappend retlist [join $ql |];
	}
	6 {
	    lappend retlist  [join [split $Cset ""] \\\\| ];
	}
	7 {
	    lappend retlist  [join [split $Cset ""] \\\\| ];
	}
	8 {
	    lappend retlist  [join [split $Cset ""] \\| ];
	}
    }
    return [join $retlist ""];
}

#It is probably best to provide user-settable flags governing the responses to:
#(a) unbalanced delimiters and
#(b) unrecognized character classes.
#Warnings should always be issued, but the user should be able to let them go
#so that it is possible to write regexps that contain such things as literals.

# Ways of handling alternation
# 0 Does not support alternation.
# 1 [ab]
# 2 (a|b)
# 3 (a\|b)
# 4 {a,b}
# 5 ("a"|"b")
# 6 (a\\|b)
# 7 \\(a\\|b\\)

#We first look for an intersection. If we find one, we take note of its
#location, process the material leading up to it, then process the
#intersection. Then we shift and do another iteration.
# return modified copy of regexp

proc InstantiateUserClasses {re AltType} {
    global LeftClassDelimiter;
    global RightClassDelimiter;
    global LeftUserClassDelimiter;
    global RightUserClassDelimiter;
    global LeftUserIntDelimiter;
    global RightUserIntDelimiter;
    global LUDlen;
    global RUDlen;

    set LIDlen [string length $LeftUserIntDelimiter];
    set RIDlen [string length $RightUserIntDelimiter];

    if { $AltType > 1 } {
	if {$AltType == 4} {
	   set LeftClassDelimiter  {\{} ;
  	   set RightClassDelimiter {\}} ;
	} elseif {$AltType == 7} {
	    set LeftClassDelimiter  {\\(} ;
   	    set RightClassDelimiter {\\)} ;
	} elseif {$AltType == 8} {
	    set LeftClassDelimiter  {\(} ;
   	    set RightClassDelimiter {\)} ;
	} else {
	    set LeftClassDelimiter  {(} ;
   	    set RightClassDelimiter {)} ;
	}
    } else {
	set LeftClassDelimiter  {[} ;
        set RightClassDelimiter {]} ;
    }

    set ss $re;
    while {[string length $ss] > 0} {
	set IntResult "";
	set NoIntResult "";
	set ldloc [string first $LeftUserIntDelimiter $ss];
	set rdloc [expr [string length $ss] - $RIDlen]; #Effect is that by default we consume the whole string.
	
	if {$ldloc < 0} {
	    if {[catch {InstRegWithoutIntersections $ss $AltType $LUDlen $RUDlen} NoIntResult] !=0} {
		return "";
	    } else {
		lappend strlist $NoIntResult;
	    }
	} else {
	    set rdloc [string first $RightUserIntDelimiter $ss];
	    if {$rdloc >= 0} {
		#If we get here, we've found a potential class intersection.
		if { [catch {InstantiateClassIntersection [string range $ss $ldloc $rdloc] $AltType $LIDlen} IntResult] != 0} {
		    #This means that the region was not a well-formed intersection.
		    #We handle it as a region not containing an intersection, only shift the
		    # right boundary of that region to the right delimiter of the putative intersection.
		    set NoIntersectionRegionEnd $rdloc;
		} else {
		    set NoIntersectionRegionEnd [expr $ldloc -1];
		}
	    } else {
		set NoIntersectionRegionEnd [expr [string length $ss] -1];
		set rdloc $NoIntersectionRegionEnd;
	    }
	    # Handle region with no intersections
	    if { [catch {InstRegWithoutIntersections [string range $ss 0 $NoIntersectionRegionEnd] $AltType $LUDlen $RUDlen} NoIntResult] != 0 } {
		puts "Caught exception on InstRegWithoutIntersections";
		return "";
	    } else {
		lappend strlist $NoIntResult;
	    }

	    lappend strlist $IntResult;
	}
	set ss [string range $ss [expr $rdloc + $RIDlen] end];
    }
    return [join $strlist ""];
}


# We are passed a string that should contain two or more classes.
# We validate this and in the course of this obtain the parse.
# If validation fails, throw an error and catch it above.
# If validation succeeds, we instantiate each of the classes,
# and return their intersection.
proc InstantiateClassIntersection {is AltType LIDlen} {
    global UserClasses;
    global LeftClassDelimiter;
    global RightClassDelimiter;
    global LUDlen;
    global RUDlen;

    set is [string range $is $LIDlen end-1]; #Ignore delimiters.
    set pre {(\[_[^][]+_\])};
    set IndexPairList [regexp -all -inline -indices $pre $is];
    set Matches [llength $IndexPairList];
    if {$Matches} {
	#Each entry is a pair containing the beginning and ending indices of [_name_] in is.
	set subcnt 0;
	set SetList [list];
	foreach k $IndexPairList {
	    set Left [lindex $k 0]
	    if {$Left < 0} {
		break
	    }
	    set Right [lindex $k 1]
	    if {$Right < 0} {
		break
	    }
	    set Name [string range $is [expr $Left+$LUDlen] [expr $Right-$RUDlen]]
	    if { [info exists UserClasses($Name)] } {
		lappend SetList $UserClasses($Name);
		incr subcnt;
	    } else {
		ShowMessage [format [_ "Undefined character class %s"] $Name];
		error $Name;
	    }
	}
	set accum [lindex $SetList 0];
	for {set j 1} {$j < $subcnt} {incr j} {
	    set accum [stringint $accum [lindex $SetList $j] ];
	}
	lappend retlist $LeftClassDelimiter;
	lappend retlist [FormatClass $accum $AltType];
	lappend retlist $RightClassDelimiter;
	return [join $retlist ""];
    }
}


proc InstRegWithoutIntersections { re AltType LDlen RDlen} {
    global UserClasses;
    global LeftClassDelimiter;
    global RightClassDelimiter;
    global LeftUserClassDelimiter;
    global RightUserClassDelimiter;

    set strlist "";
    set ss $re;
    while {[string length $ss] > 0} {
	set ldloc [string first $LeftUserClassDelimiter $ss];
	if {$ldloc < 0} {
	    lappend strlist $ss;
	    break
	} 
	set rdloc [string first $RightUserClassDelimiter $ss];
	if {$rdloc < 0} {
	    lappend strlist $ss;
	    ShowMessage [format [_ "Warning: left class delimiter without right counterpart in %s"] $ss];
	    break ;
	}
	set ClassName [string range $ss [expr $ldloc+$LDlen] [expr $rdloc-1]]
	if { [info exists UserClasses($ClassName)] } {
	    lappend strlist [string range $ss 0 [expr $ldloc -1]]; # Copy string up to $ldloc.
	    lappend strlist $LeftClassDelimiter;
	    lappend strlist [FormatClass $UserClasses($ClassName) $AltType];
	    lappend strlist $RightClassDelimiter;
	} else {
	    ShowMessage [format [_ "Undefined character class %s"] $ClassName];
	    error $re;
	}
	set ss [string range $ss [expr $rdloc + $RDlen] end]
    }
    return [join $strlist ""];
}

proc ToggleUserClassPalette {} {
    global m;
    global UserClassCnt;
    global UserClassPaletteIsDisplayedP;
    global UserClassPaletteToBeDisplayedP;
    global ToggleUserClassPaletteIndex
    global DescribeToggleUserClassPaletteIndex;

    if { $UserClassPaletteIsDisplayedP == 0} {
	if {$UserClassCnt == 0} {
	    ShowMessage [_ "No character classes have been defined."]
	    return 
	}
	if {[winfo exists .ucpal.lb] == 0} {
	    ConstructUserClassPalette;
	}
	pack .ucpal.lb;
	wm deiconify .ucpal
	$m.tools.classes entryconfigure $ToggleUserClassPaletteIndex -label [_ "Do Not Display User-Defined Class Palette"];
	set UserClassPaletteIsDisplayedP 1;
	set UserClassPaletteToBeDisplayedP 1;
    } else {
	if {[winfo exists .ucpal] == 1} {
	    wm withdraw .ucpal;
	    if {[winfo exists .ucpal.lb] == 1} {
		pack forget .ucpal.lb;
	    }
	}
	$m.tools.classes entryconfigure $ToggleUserClassPaletteIndex -label [_ "Display User-Defined Class Palette"];
	set UserClassPaletteIsDisplayedP 0;
	set UserClassPaletteToBeDisplayedP 0;
    }
}

proc ShowUserClassPalette {} {
    global .ucpal;
    global UserClassPaletteDisplayedP;

    if {$::UseScrollbarsP} {
	pack .ucpal.sbar -side right -expand 0 -fill y;
    }  
    pack .ucpal.lb -side left -expand 1 -fill both;
    wm deiconify .ucpal
    set UserClassPaletteDisplayedP 1;
}

# Ignore leading + and - unless they are the only distinction between the strings.
proc ClassCompare {a b} {
    set cmp [string compare [string trimleft $a "+-"] [string trimleft $b "+-"]];
    if {$cmp != 0} {
	return $cmp;
    } else {
	return [string compare $a $b];
    }
}

proc ListUserClassFromMenu {} {
    global LUDlen;
    global RUDlen;
    set renot [GetClassSpecFromClassMenu [.ucpal.lb get active]];
    #We can be sure that ClassName is defined since  we got it from the palette.
    ListUserClass [string range $renot $LUDlen end-$RUDlen];
}

proc ListUserClass {ClassName} {
    global UserClasses;
    set MinWidth 30;

    set SortedList [lsort [split $UserClasses($ClassName) ""]];
    set CharCnt [llength $SortedList];
    set Cset [join $SortedList ""];
    if {$CharCnt < 60} {
	set Width $CharCnt;
    } else {
	set Width 60;
    }
    if {$Width < $MinWidth} { set Width $MinWidth;}
    if {$CharCnt <= $Width} {
	set Lines 1
    } else {
	set Lines 3;
    }
    set ClassListPopup [CreateTextDisplay [format [_ "Class %s"] $ClassName] $Width $Lines];
    BindKeys $ClassListPopup;
    AppendToTextDisplay $ClassListPopup $Cset;
    return $ClassListPopup;
}

proc ConstructUserClassPalette { } {
    global UserClasses;
    global UserClassGlosses;
    global UserClassPaletteIsDisplayedP;
    global UserClassPaletteToBeDisplayedP;
    global MaxUserClassPaletteHeight;
    global MaxUserClassGlossLength;
    global UserClassCnt;
    global UserClassColumnSeparation;
    global LeftUserClassDelimiter;
    global RightUserClassDelimiter;
    global program;

    set MaxUserClassPaletteHeight 10;

    destroy .ucpal.lb;
    destroy .ucpal.sbar
    if {$UserClassCnt == 0} {
	destroy .ucpal;
	return;
    }
    set UserClassPaletteIsDisplayedP 0;
    if {[winfo exists .ucpal] == 0} {
	toplevel .ucpal;
    }
    wm title .ucpal [_ "User Defined Named Character Classes"];
    wm withdraw .ucpal
    if {$UserClassCnt > $MaxUserClassPaletteHeight} {
	set lbentries $MaxUserClassPaletteHeight;
    } else {
	set lbentries 0;
    }
    if {[winfo exists .ucpal.lb] == 0} {
	listbox .ucpal.lb -height $lbentries -width 0 -font MainFont  \
	    -yscrollcommand {.ucpal.sbar set} -fg $::ColorSpecs(UserClassPalette,Foreground) \
	    -bg $::ColorSpecs(UserClassPalette,Background);
	scrollbar .ucpal.sbar -command {.ucpal.lb yview} \
	    -troughcolor $::ColorSpecs(UserClassPalette,Background) \
	    -bg $::ColorSpecs(UserClassPalette,Background);
    }
    bind .ucpal.lb <Double-ButtonPress-1> {
	ListUserClassFromMenu;
    }
    bind .ucpal.lb <<B3>> {
	$::REG insert insert [GetClassSpecFromClassMenu [.ucpal.lb get active]]
    }
    bind .ucpal.lb <Destroy> {
	set UserClassPaletteIsDisplayedP 0;
    }
    bind .ucpal.sbar <<B3>> "ScrollbarMoveBigIncrement .ucpal.sbar 0.25 %x %y"
    BindKeys .ucpal;
    set SortedList [lsort -command ClassCompare [array names UserClassGlosses]];
    foreach ClassName  $SortedList {
	.ucpal.lb insert end [format {%-*s %s%s%s} \
	   [expr $MaxUserClassGlossLength + $UserClassColumnSeparation] \
	  $UserClassGlosses($ClassName) $LeftUserClassDelimiter $ClassName \
		  $RightUserClassDelimiter];
    }
    balloonhelp_for .ucpal.lb [_ "Left click to select. Right click to insert into regular expression.\nDouble left click to display members of class."]
    if {$UserClassPaletteToBeDisplayedP} {
	ShowUserClassPalette;
    }
}

proc StoreUserClassDefinition {name cset gloss} {
    global UserClassCnt;
    global UserClasses;
    global UserClassGlosses;
    global MaxUserClassGlossLength;

    set UserClassGlosses($name) $gloss;
    set UserClasses($name) $cset;
    set lg [string length $gloss];
    # We keep track of the maximum length so we can use it to compute
    # the field width in the palette.
    if { $lg > $MaxUserClassGlossLength} {
	set MaxUserClassGlossLength $lg;
    }
    incr UserClassCnt;
    CheckUserClassAvailability;
}

proc DefineUserClassFromPopup {} {
    global YesNoResponse;
    global UserClasses;

    set redo 0;
    set name  [.udcentry.nameent get];
    set cset  [.udcentry.charent get];
    set gloss [.udcentry.glosent get];
    set nl [string length $name]
    set cl [string length $cset]
    set gl [string length $gloss]
    if {[expr $nl * $cl * $gl] == 0} {
	set redo 1;
	lappend msg [_ "Missing fields: "];
	if {$nl < 1} {
	    lappend msg [_ "name"];
	}
        if {$cl < 1} {
	    lappend msg [_ "characters"];
	}
	if {$gl < 1} {
	    lappend msg [_ "gloss"];
	}
	ShowMessage [join $msg];
    }
    destroy .udcentry;
    if {$redo == 0} {
	if {[info exists UserClasses($name)]} {
	    set SortedList [lsort [split $UserClasses($name) ""]];
	    set resp [ConfirmationDialog .udcconf [format [_ "You are about to redefine character class %s.\nHere is the current definition:\n"] $name] $SortedList [_ "Cancel Redefinition"] [_ "Proceed with Redefinition"]];
	    if {$resp == 0} {
		set redo 1;
		set name "";
	    }
	}
    }
    if {$redo == 1} {
	PopupUserClassEntry $name $cset $gloss;
    } else {
	StoreUserClassDefinition $name $cset $gloss;
	ShowMessage [format [_ "Definition of character class %s added."] $name];
	ConstructUserClassPalette;
	set ::UserClassesEnabledP 1
    }
}

option add *udcentry*Button.background $::ColorSpecs(PopupWidgetButton,Background) 100
option add *udcentry*Button.foreground $::ColorSpecs(PopupWidgetButton,Foreground) 100
option add *udcentry*Entry.background $::ColorSpecs(PopupWidgetEntry,Background) 100
option add *udcentry*Entry.foreground $::ColorSpecs(PopupWidgetEntry,Foreground) 100
option add *udcentry*Label.background $::ColorSpecs(PopupWidgetLabel,Background) 100
option add *udcentry*Label.foreground $::ColorSpecs(PopupWidgetLabel,Foreground) 100

proc PopupUserClassEntry {{name ""} {cset ""} {gloss ""} } {
    global MainFont;

    if {[PopupDown UserClassEntry] == 1} {return}
    set po [toplevel .udcentry -borderwidth 4 -relief raised \
		-bg $::ColorSpecs(PopupWidgetDefault,Background)]
    set ::PopupList(UserClassEntry) $po;
    wm title .udcentry "";
    after idle {
	update idletasks
	set xmax [winfo screenwidth .udcentry]
	set ymax [winfo screenheight .udcentry]
	set x0 [expr 1 * ($xmax -[winfo reqwidth .udcentry])/3];
	set y0 [expr 1 * ($ymax -[winfo reqheight .udcentry])/3];
	wm geometry .udcentry "+$x0+$y0";
    }
    label  .udcentry.title -text [_ "Enter Character Class Definition"];
    label  .udcentry.namelab -text [format "%-12s" [_ "Name"]];
    entry  .udcentry.nameent -width 50 -font MainFont;
    .udcentry.nameent insert 0 $name;
    label  .udcentry.charlab  -text [format "%-12s" [_ "Characters"]];
    entry  .udcentry.charent -width 50 -font MainFont;
    .udcentry.charent insert 0 $cset;
    label  .udcentry.gloslab -text [format "%-12s" [_ "Gloss"]];
    entry  .udcentry.glosent -width 50 -font MainFont;
    .udcentry.glosent insert 0 $gloss;
    button .udcentry.okay   -text [_ "OK"]     -command DefineUserClassFromPopup;
    button .udcentry.cancel -text [_ "Cancel"] -command {destroy .udcentry}
    catch {.udcentry.title configure -font -*-Courier-bold-o-*--*-180-*}
    bind .udcentry.nameent <FocusIn> {SetInsertionTargets .udcentry.nameent}
    bind .udcentry.charent <FocusIn> {SetInsertionTargets .udcentry.charent}
    bind .udcentry.glosent <FocusIn> {SetInsertionTargets .udcentry.glosent}
    BindKeys .udcentry;

    grid .udcentry.title     -row 0 -column 0 -sticky ew -columnspan 3
    grid .udcentry.namelab   -row 1 -column 0
    grid .udcentry.nameent   -row 1 -column 1 -sticky w
    grid .udcentry.charlab   -row 2 -column 0
    grid .udcentry.charent   -row 2 -column 1 -sticky w
    grid .udcentry.gloslab   -row 3 -column 0
    grid .udcentry.glosent   -row 3 -column 1 -sticky w
    grid .udcentry.cancel    -row 4 -column 0
    grid .udcentry.okay      -row 4 -column 2
}

# Returns the number of fields found.
proc ParseUserClassEntry { def } {
    # First field is class name
    # Second field is set of characters
    # Third field is gloss

    set def [string trim $def];
    set tabloc1 [string first "\t" $def];
    if {$tabloc1 == -1} {
	return 1; 
    }
    set tabloc2 [string last "\t" $def];
    if {$tabloc1 == $tabloc2} {
	return 2;
    }
    set ClassName [string trim [string range $def 0 [expr $tabloc1 -1]]];
    set Cset [string trim [string range $def [expr $tabloc1 +1] [expr $tabloc2 -1]]];
    set Gloss [string trim [string range $def [expr $tabloc2 +1] end]];

    StoreUserClassDefinition $ClassName $Cset $Gloss;
    return 3;
}

proc DefineCharacterClass {name cset gloss} {
    StoreUserClassDefinition $name $cset $gloss
}

proc ReadUserClasses { UserClassFile } {
    set cnt 0;
    if { [file exists $UserClassFile] } {
	if {[ catch {open $UserClassFile "r"} UserClassHandle] == 0} {
	    while { [gets $UserClassHandle line] > 0} {
		incr cnt;
		set fields [ParseUserClassEntry $line];
		if {$fields < 3} {
		    ShowMessage [format [_ "The class definition at line %1\$d of file %2\$s is ill-formed."] $cnt $UserClassFile]
		    if {$fields == 2} {
			ShowMessage [_ "It has only two of the three required fields"];
		    } else {
			ShowMessage [_ "It has only one of the three required fields"]; 
		    }
		    close $UserClassHandle;
		    return;
		}
	    }
	    close $UserClassHandle;
	    ShowMessage [format  [_ "%d character classes read from file %s."] $cnt $UserClassFile];
	} else {
	    ShowMessage [format [_ "Cannot open file %s."] $UserClassFile];
	    close $UserClassHandle;
	    return;
	}
    } else {
	ShowMessage [format [_ "There is no file named %s"] $UserClassFile];
    }
    return;
}

proc ReadUserClassesInteractively { } {
    set UserClassFile [tk_getOpenFile];
    if {[string equal $UserClassFile ""] != 1} {
	ReadUserClasses $UserClassFile;
    } else {
	ShowMessage [_ "File selection aborted."];
    }
}

proc SaveUserClasses {} {
    set ClassList [array names ::UserClassGlosses]
    if {[llength $ClassList] == 0} {
	return ""
    }
    foreach ClassName [lsort $ClassList] {
	lappend sl [format "%s\t%s\t%s" $ClassName $::UserClasses($ClassName) $::UserClassGlosses($ClassName)]
    }
    return $sl;
}

proc SaveUserClassDefinitions {} {
    global UserClassGlosses;
    global UserClasses;
    global UserClassCnt;

    if {$UserClassCnt == 0} {
	ShowMessage [_ "No named character classes have been defined."];
	return ;
    }
    set SaveFile [tk_getSaveFile -initialfile [_ "ClassDefinitions"]];
    if {[string equal $SaveFile ""] == 1} {
	return ;
    } else {
        if { [catch {open $SaveFile "w+"} fh] != 0} {
	    ShowMessage [format [_ "Unable to open file %s in which to save class definitions."] \
			     [MinimizeFileName $SaveFile]];
	    return ;
        }
    }
    foreach ClassName [lsort [array names UserClassGlosses]] {
	puts $fh [format "%s\t%s\t%s\n" $ClassName $UserClasses($ClassName) $UserClassGlosses($ClassName)]
    }
    close $fh;
}

proc GetClassSpecFromClassMenu {mre} {
    global MaxUserClassGlossLength;
    global UserClassColumnSeparation;

    return [string trimleft [string range $mre [expr $MaxUserClassGlossLength + $UserClassColumnSeparation] end]];
}

proc ClearUserClasses {} {
    array set ::UserClasses {};
    array set ::UserClassGlosses {};
    set ::UserClassCnt 0;
    set ::MaxUserClassGlossLength 0;
    if {[winfo exists .ucpal]} {
	destroy .ucpal
    }
    $::m.tools.classes entryconfigure $::ToggleUserClassPaletteIndex \
	-label [_ "Display User-Defined Class Palette"];
    set ::UserClassPaletteIsDisplayedP 0;
    ShowMessage [_ "User classes cleared."]
}

#End of user-defined named character class section


proc LayoutWindows {} {
    global SideBySideLayoutP;
    global RegSubSideBySideP;
    global DoSubstitutionsP;
    global ComparisonWindowDisplayedP;
    global MainWidth;
    global MainHeight;
    global PixelHeight;
    global UseScrollbarsP;

    pack forget .sep1  .sep2  .sep3  .sepcmnds  .cmnds  .msg  .rsf  .dwf  .dwf.vwi  .dwf.vwo \
	.dwf.vwc  $::REG  $::SUB  $::IND  $::INDSB  $::OUT  $::OUTSB  $::COM  $::COMSB

    if {$::AquaP} {
	pack .cmnds -side top                     -fill x
	pack .sepcmnds                            -fill x
    }
    pack .msg       -side top                     -fill x
    pack .sep2                                   -fill x
    set HeightInLines [expr $PixelHeight / [font metrics MainFont -linespace]];
    incr HeightInLines -5; #For messages, re, sub, menubar. 

    #Take care of the regexp and subexp windows.
    if {$RegSubSideBySideP && $DoSubstitutionsP} {
	set IndWidth [expr $MainWidth / 2];
	$::REG  configure -width $IndWidth;
	$::SUB configure -width $IndWidth;
    }
    pack .rsf -side top -expand 0    -fill x;
    if {$DoSubstitutionsP} {
	if {$RegSubSideBySideP} {
	    pack $::REG        -side left   -expand yes   -fill x;
	    pack $::SUB       -side right  -expand yes   -fill x;
	} else {
	    pack $::REG        -side top                 -fill x;		
	    pack $::SUB       -side top                 -fill x;
	}
    } else {
	pack $::REG        -side top                 -fill x;	
    }
    
    #Compute the heights to use for the data windows.
    if {$SideBySideLayoutP == 0} {
	if {$ComparisonWindowDisplayedP} {
	    set IndHeight [expr $HeightInLines / 3];
	} else {
	    set IndHeight [expr $HeightInLines / 2];
	}
    } else {
	set IndHeight $MainHeight;
    }
    pack .dwf -side bottom -expand 1 -fill both;

    if {$SideBySideLayoutP == 0} {
	$::IND configure -width $MainWidth  -height $IndHeight;
	$::OUT configure -width $MainWidth  -height $IndHeight;
	$::COM configure -width $MainWidth  -height $IndHeight;
	if {$ComparisonWindowDisplayedP} {
	    if {$UseScrollbarsP} {
		pack .dwf.vwi  -side top    -fill both -expand 1
		pack .dwf.vwo  -side top    -fill both -expand 1
		pack .dwf.vwc  -side bottom -fill both -expand 1
		pack $::INDSB  -side right  -fill y    -expand 0 -in .dwf.vwi;
		pack $::IND    -side left   -fill both -expand 1 -in .dwf.vwi;
		pack $::OUTSB  -side right  -fill y    -expand 0 -in .dwf.vwo;
		pack $::OUT    -side left   -fill both -expand 1 -in .dwf.vwo;
		pack $::COMSB  -side right  -fill y    -expand 0 -in .dwf.vwc;
		pack $::COM    -side left   -fill both -expand 1 -in .dwf.vwc;
	    } else {
		pack $::IND    -side top     -fill both -expand 1
		pack .sep1                   -fill x
		pack $::OUT    -side top     -fill both -expand 1
		pack .sep2                   -fill x
		pack $::COM    -side bottom  -fill both -expand 1
	    }
	} else {
	    if {$UseScrollbarsP} {
		pack .dwf.vwi  -side top    -fill both -expand 1
		pack .dwf.vwo  -side bottom -fill both -expand 1
		pack $::INDSB  -side right  -fill y    -expand 0 -in .dwf.vwi;
		pack $::IND    -side left   -fill both -expand 1 -in .dwf.vwi;
		pack $::OUTSB  -side right  -fill y    -expand 0 -in .dwf.vwo;
		pack $::OUT    -side left   -fill both -expand 1 -in .dwf.vwo;
	    } else {
		pack $::IND    -side top     -fill both -expand 1
		pack .sep1                   -fill x
		pack $::OUT    -side bottom  -fill both -expand 1
	    }
	}
    } else {
	if {$ComparisonWindowDisplayedP} {
	    set SideWidth [expr $MainWidth / 3];
	    $::IND configure -width $SideWidth -height $IndHeight;
	    $::OUT configure -width $SideWidth -height $IndHeight;
	    $::COM configure -width $SideWidth  -height $IndHeight;
	    if {$UseScrollbarsP} {pack $::INDSB  -side left  -expand 0 -fill y}
	    if {$UseScrollbarsP} {pack $::COMSB  -side right -expand 0 -fill y}
	    pack $::IND    -side left  -expand 1 -fill both
	    if {$UseScrollbarsP} {pack $::OUTSB  -side left  -expand 0 -fill y}
	    pack $::OUT    -side left  -expand 1 -fill both
	    pack $::COM    -side right -expand 1 -fill both 
	} else {
	    set SideWidth [expr $MainWidth / 2];
	    $::IND configure -width $SideWidth  -height $IndHeight;
	    $::OUT configure -width $SideWidth  -height $IndHeight;
	    if {$UseScrollbarsP} {pack $::INDSB -side left  -fill y    -expand 0}
	    if {$UseScrollbarsP} {pack $::OUTSB -side right -fill y    -expand 0}
	    pack $::IND   -side left  -fill both -expand 1
	    pack $::OUT   -side right -fill both -expand 1
	}
    }
    if {$DoSubstitutionsP} {
	InOutScrollLinkage;
    }
}

set LeftArrowImage [image create photo -data {
    R0lGODlhFAAUAIAAAAAAAL+/vyH5BAEAAAEALAAAAAAUABQAAAIqjI+py43gGIAxTVrNxXVz
    54WTIopWGZ7oRq7X4o4wm2lvbX+ZjGv9/ysAADs=
}];

namespace eval search {
    variable SearchOffset;
    variable SrchWCnt 0;
    variable GotoCharWCnt 0;
    namespace export GetSearchTarget

    proc SearchInitialize {w} {
	variable SearchOffset;
	set SearchOffset($w,f) 1.0;
	set SearchOffset($w,b) 1.0;
    }

    proc SearchResults {} {
	if {[string length [$::OUT get 1.0 end]] <= 1 } {
	    ShowMessage [_ "There is no result text to search."]
	    return
	}
	PopupSearch $::OUT  [_ "Search Results"];
    }

    proc SearchTestData {} {
	if {[string length [$::IND get 1.0 end]] <= 1 } {
	    ShowMessage [_ "There is no input text to search."]
	    return
	}
	PopupSearch $::IND  [_ "Search Input Text"];
    }

    proc GotoCharResults {} {
	if {[string length [$::OUT get 1.0 end]] <= 1 } {
	    ShowMessage [_ "There are no results to search."]
	    return
	}
	PopupGotoChar $::OUT [_ "Go to Character in Results"];
    }

    proc GotoCharTestData {} {
	if {[string length [$::IND get 1.0 end]] <= 1 } {
	    ShowMessage [_ "There is no test data to search."]
	    return
	}
	PopupGotoChar $::IND [_ "Go to Character in Test Data"];
    }

    
    proc SearchText {w re forwardp cw} {
	variable SearchOffset;
	if {$forwardp} {
	    set df "-forward";
	    set Offset $SearchOffset($w,f);
	} else {
	    set df "-backward";
	    set Offset $SearchOffset($w,b);
	}
	set CurrentLine [lindex [split $Offset "."] 0]
	set CurrentChar [lindex [split $Offset "."] 1]
	set ind [$w search $df -regexp -count MatchLen $re $CurrentLine.$CurrentChar]
	if {$ind == ""} {
	    ShowMessage [_ "No match found"];
	    return 
	} else {
	    $w tag delete match;
	    $w tag configure "match" -background $::ColorSpecs(Match,Background);
	    $w tag add match $ind "$ind + $MatchLen chars"
	    $w see $ind
	    set MatchBegin [$w index match.first]
	    set MatchEnd   [$w index match.last-1chars];
	    set MatchBeginChar [CountChars [$w get 1.0 $MatchBegin-1chars]];
	    set MatchEndChar [expr $MatchBeginChar + [CountChars [$w get $MatchBegin $MatchEnd]]];
	    set msg [format [_ "Matched \[%s-%s\]  \[%s-%s\]"] $MatchBegin $MatchEnd [DelimitNumber $MatchBeginChar] [DelimitNumber $MatchEndChar]];
	    ShowMessage $msg
	    $cw.ri configure -text $msg;
	    set SearchOffset($w,f) "$ind + $MatchLen chars + 1 chars"
	    set SearchOffset($w,b) "$ind -1 chars"
	    return
	}
    }


    proc PopupSearch {w title} {
	global MainFont;
	variable SrchWCnt;
	incr SrchWCnt;

	set pn [format ".srch%d" $SrchWCnt];
	if {[winfo exists $pn]} {
	    raise $pn
	    return
	}
	toplevel $pn -borderwidth 4 -relief raised \
	    -bg $::ColorSpecs(PopupWidgetDefault,Background);
	wm title $pn $title;
	label $pn.ri  -bg $::ColorSpecs(PopupWidgetDefault,Background);
	entry $pn.ent -width 40 -font MainFont   \
	    -bg $::ColorSpecs(PopupWidgetDefault,Background);
	button $pn.f  -text [_ "Search Forward"] \
	    -command "search::SearchForEntry $w 1 $pn"  \
	    -bg $::ColorSpecs(PopupWidgetButton,Background);
	button $pn.b  -text [_ "Search Backward"] \
	    -command "search::SearchForEntry $w 0 $pn" \
	    -bg $::ColorSpecs(PopupWidgetButton,Background);
	button $pn.d  -text [_ "Dismiss"] \
	    -command "destroy $pn" \
	    -bg $::ColorSpecs(PopupWidgetButton,Background);
	pack $pn.ri -side top
	pack $pn.ent -side top
	pack $pn.f -side right
	pack $pn.d -side left
	pack $pn.b -side right
	raise $pn;
	set AfterIdleCmd [format {update idletasks
	    set TextLeftEdge [winfo rootx %s];
	    dmsg "TextLeftEdge=$TextLeftEdge"
	    set TextRightEdge [expr $TextLeftEdge +  [winfo width %s]];
	    dmsg "TextRightEdge=$TextRightEdge"
	    set PopupWidth [winfo width %s];
	    dmsg "PopupWidth=$PopupWidth"
	    set x [expr int($TextRightEdge - ((2.0/3.0) * $PopupWidth))]
	    dmsg "x=$x"
	    set TextTopEdge  [winfo rooty %s];
	    dmsg "TextTopEdge=$TextTopEdge"
	    set TextMidHeight [expr $TextTopEdge + ([winfo height %s]/2.0)]
	    dmsg "TextMidHeight=$TextMidHeight"
	    set PopupHeight [winfo height %s];
	    dmsg "PopupHeight=$PopupHeight"
	    set y [expr int ($TextMidHeight -((2.0/3.0) * $PopupHeight))]
	    dmsg "y=$y"
	    wm geometry %s "+$x+$y"
	} $w $w $pn $w $pn $w $pn];
	after idle $AfterIdleCmd;
	BindKeys $pn;
	bind $pn <FocusIn> "SetInsertionTargets $pn.ent"
	bind $pn.ent <FocusIn> "SetInsertionTargets $pn.ent"
	bind $pn.ent <Return> "search::SearchForEntry $w 1 $pn"
    }

    proc SearchForEntry {w d pn} {
	set tgt [$pn.ent get];
	SearchText $w $tgt $d $pn;
    }

    proc PopupGotoChar {w title} {
	global MainFont;
	variable GotoCharWCnt;
	incr GotoCharWCnt;

	set pn [format ".gotochar%s" [regsub -all "\\." $w "-"]]
	if {[winfo exists $pn]} {
	    raise $pn
	    return
	}
	toplevel $pn -borderwidth 4 -relief raised \
	    -bg $::ColorSpecs(PopupWidgetDefault,Background);
	wm title $pn "";
	label $pn.title -text $title \
	    -bg $::ColorSpecs(PopupWidgetDefault,Background);
	entry $pn.ent -width 40 -font MainFont \
    	    -bg $::ColorSpecs(PopupWidgetDefault,Background);
	bind $pn <FocusIn> "SetInsertionTargets $pn.ent"
	button $pn.f  -text [_ "Go"] \
	    -command "search::GotoCharInText $w $pn" \
	    -bg $::ColorSpecs(PopupWidgetButton,Background);
	button $pn.d  -text [_ "Dismiss"] \
	    -command "destroy $pn" \
	    -bg $::ColorSpecs(PopupWidgetButton,Background);
	pack $pn.title -side top
	pack $pn.ent -side top
	pack $pn.f -side right
	pack $pn.d -side left
	raise $pn;
	set AfterIdleCmd [format {update idletasks
	    set TextLeftEdge [winfo rootx %s];
	    dmsg "TextLeftEdge=$TextLeftEdge"
	    set TextRightEdge [expr $TextLeftEdge +  [winfo width %s]];
	    dmsg "TextRightEdge=$TextRightEdge"
	    set PopupWidth [winfo width %s];
	    dmsg "PopupWidth=$PopupWidth"
	    set x [expr int($TextRightEdge - ((2.0/3.0) * $PopupWidth))]
	    dmsg "x=$x"
	    set TextTopEdge  [winfo rooty %s];
	    dmsg "TextTopEdge=$TextTopEdge"
	    set TextMidHeight [expr $TextTopEdge + ([winfo height %s]/2.0)]
	    dmsg "TextMidHeight=$TextMidHeight"
	    set PopupHeight [winfo height %s];
	    dmsg "PopupHeight=$PopupHeight"
	    set y [expr int ($TextMidHeight -((2.0/3.0) * $PopupHeight))]
	    dmsg "y=$y"
	    wm geometry %s "+$x+$y"
	} $w $w $pn $w $pn $w $pn];
	after idle $AfterIdleCmd;
	BindKeys $pn;
	bind $pn.ent <FocusIn> "SetInsertionTargets $pn.ent"
	bind $pn.ent <Return>  "search::GotoCharInText $w $pn"
    }

    #tw = text window in which to locate character
    #cw = calling window - the name of the popup from which to get the character position.
    proc GotoCharInText {tw cw} {
	#Handle both tcl line.char format indices and pure character offsets.
	set CharPos [$cw.ent get]
	$tw tag delete goto;
	$tw tag configure "goto" -background $::ColorSpecs(Match,Background);
	if {[scan $CharPos %d.%d line char] >= 2} {
	    $tw tag add goto $CharPos "$CharPos + 1 chars"
	    $tw see $CharPos;
	} else {
	    $tw tag add goto 1.0+${CharPos}chars 1.1+${CharPos}chars
	    $tw see 1.0+${CharPos}chars
	}
    }
}


namespace eval resc {
    namespace export CacheResult ResetNumberOfResultsToStore PopupCachedEntries 
    variable ResultsToKeep 5;
    variable ResultsStored 0;
    variable EntriesDisplayed 0;
    variable ResultList;
    variable CacheChecked;
    variable EventNumber 0;

    array set CacheChecked {};

    proc CacheResult {res prg re se} {
	variable ResultsToKeep;
	variable ResultsStored;
	variable ResultList;
	variable EventNumber;
	global DoSubstitutionsP;

	incr EventNumber;
	if {$ResultsStored >= $ResultsToKeep} {
	    set ResultList [lreplace $ResultList 0 0]; #Remove 1st element from list.
	    incr ResultsStored -1;
	}
	if {$DoSubstitutionsP} {
	    lappend ResultList [list $EventNumber $res $prg $re $se];
	} else {
	    lappend ResultList [list $EventNumber $res $prg $re];
	}
	incr ResultsStored;
    }

    proc DeleteCacheEntry {k} {
	variable ResultsStored;
	variable ResultList;

	set ResultList [lreplace $ResultList $k $k]
	incr ResultsStored -1;
    }

    proc DeleteCacheEntries {} {
	variable ResultList

	set SelectedEntries [list];
	set SelectedEntryCnt 0;
	foreach i [array names ::CacheChecked] {
	    if {$::CacheChecked($i) == 1} {
		lappend SelectedEntries $i;
		incr SelectedEntryCnt;
	    }
	}
	if {$SelectedEntryCnt == 0} {return}

	set SelectedEntries [lsort -decreasing $SelectedEntries];
	foreach i $SelectedEntries {
	    DeleteCacheEntry [expr $i -1];
	    .cacentry.chk$i deselect
	}
	resc::UpdateCacheDisplay;
    }

    proc ResetNumberOfResultsToStore {New} {
	variable ResultsToKeep;
	variable ResultsStored;
	variable ResultList;

	if {$New < 0} {return}
	set ResultsToKeep $New;
	if {$New < $ResultsStored} {
	    set ResultList [lreplace $ResultList 0 [expr $ResultsStored - $New - 1]];
	    set ResultsStored $ResultsToKeep;
	}
    }

    proc SaveCacheEntries {} {
	variable ResultList

	set SelectedEntries [list];
	set SelectedEntryCnt 0;
	foreach i [array names ::CacheChecked] {
	    if {$::CacheChecked($i) == 1} {
		lappend SelectedEntries $i;
		incr SelectedEntryCnt;
	    }
	}
	for {set i 0} {$i < $SelectedEntryCnt} {incr i} {
	    set Entry [lindex $ResultList [expr [lindex $SelectedEntries $i] -1]]
	    set EntryEventNumber [lindex $Entry 0];
	    set SaveFile [tk_getSaveFile -initialfile \
			      [format [_ "Result-%03d"] $EntryEventNumber]];
	    if {[string equal $SaveFile ""] == 1} {
		ShowMessage [_ "File selection cancelled."];
		return ;
	    } else {
		if { [catch {open $SaveFile "w+"} fh] != 0} {
		    ShowMessage [format [_ "Unable to open file %s in which to save result."] \
				     [MinimizeFileName $SaveFile]];
		    return ;
		}
	    }
	    puts $fh [lindex $Entry 1];
	    close $fh;
	}
    }

    proc CompareCacheEntries {} {
	variable ResultList;
	set SelectedEntries [list];
	set SelectedEntryCnt 0;
	foreach i [array names ::CacheChecked] {
	    if {$::CacheChecked($i) == 1} {
		lappend SelectedEntries $i;
		incr SelectedEntryCnt;
	    }
	}
	if {$SelectedEntryCnt < 2} {
	    ShowMessage [_ "There's no point in comparing fewer than two results."]
	    return ;
	}

	for {set i 0} {$i < $SelectedEntryCnt} {incr i} {
	    for {set j [expr $i + 1]} {$j < $SelectedEntryCnt} {incr j} {
		set a [lindex $SelectedEntries $i]
		set b [lindex $SelectedEntries $j]
		if {[string equal [lindex [lindex $ResultList [expr $a -1]] 1]\
			 [lindex [lindex $ResultList [expr $b -1]] 1]]} {
		    lappend ol [format "%d=%d  "  $a $b];
		} else {
		    lappend ol [format "%d!=%d  " $a $b];
		}
	    }
	}
	if {$SelectedEntryCnt <=5} {
	    ShowMessage [join $ol]
	} else {
	    foreach i $ol {
		puts $i;
	    }
	    FlushJournal; #So that the results of multiple comparisons can be seen.
	}
    }

    proc FormatPopupString {k entry} {
	set MaxRELength 15;

	set EventNum [lindex $entry 0]; 
	set prog [lindex $entry 2]
	set lines [DelimitNumber [CountLines [lindex $entry 1]]] 
	set rexp [lindex $entry 3]
	if {[string length $rexp] > $MaxRELength} {
	    set rexp [string range $rexp 0 [expr $MaxRELength -1]]
	}
	if {[llength $entry] > 4} {
	    set sexp [lindex $entry 4]
	    if {[string length $sexp] > $MaxRELength} {
		set sexp [string range $sexp 0 [expr $MaxRELength -1]]
	    }
	    set txt\
		[format "%d  %3d %-10s %6s  %-*s %*s" $k $EventNum $prog $lines $MaxRELength $rexp $MaxRELength $sexp] 
	} else {
	    set txt \
		[format "%d  %3d %-10s %6s  %-*s" $k $EventNum $prog $lines $MaxRELength $rexp]
	}
	return $txt;
    }

    option add *cacentry*.background $::ColorSpecs(PopupWidgetDefault,Background) 100
    option add *cacentry*.foreground $::ColorSpecs(PopupWidgetDefault,Foreground) 100
    option add *cacentry*Button.background $::ColorSpecs(PopupWidgetButton,Background) 100
    option add *cacentry*Button.foreground $::ColorSpecs(PopupWidgetButton,Foreground) 100
    option add *cacentry*Checkbutton.background $::ColorSpecs(PopupWidgetDefault,Background) 100
    option add *cacentry*Checkbutton.foreground $::ColorSpecs(PopupWidgetCheckbutton,Foreground) 100
    option add *cacentry*Label.background $::ColorSpecs(PopupWidgetLabel,Background) 100
    option add *cacentry*Label.foreground $::ColorSpecs(PopupWidgetLabel,Foreground) 100
    
    proc PopupCachedEntries {} {
	if {[winfo exists .cacentry]} {
	    ShowMessage [_ "A recent result window already exists."]
	    return;
	}
	toplevel .cacentry -borderwidth 4 -relief raised \
	    -bg $::ColorSpecs(PopupWidgetDefault,Background)
	wm title .cacentry "";
	label .cacentry.title -text "Recent Results"
	grid .cacentry.title    -row 0 -column 0 -sticky ew -columnspan 5 

	button .cacentry.compare -text [_ "Compare"]    -command {resc::CompareCacheEntries}
	button .cacentry.save    -text [_ "Save"]       -command {resc::SaveCacheEntries}
	button .cacentry.delete  -text [_ "Delete"]     -command {resc::DeleteCacheEntries}
	button .cacentry.cancel  -text [_ "Dismiss"]     -command {destroy .cacentry}

	balloonhelp_for .cacentry.compare  [_ "Compare the selected entries."]
	balloonhelp_for .cacentry.save    [_ "Write the selected entries to a file."]
	balloonhelp_for .cacentry.delete    [_ "Delete the selected entries."]
	balloonhelp_for .cacentry.cancel   [_ "Dismiss the popup."]

	frame .cacentry.sep -height 10 -bg $::ColorSpecs(PopupWidgetDefault,Background)
	grid .cacentry.sep      -row 6 -column 0 -sticky ew  -columnspan 5
	grid .cacentry.compare  -row 7 -column 0
	grid .cacentry.save     -row 7 -column 1
	grid .cacentry.delete   -row 7 -column 3
	grid .cacentry.cancel   -row 7 -column 4
	UpdateCacheDisplay;
    }

    proc UpdateCacheDisplay {} {
	variable ResultList;
	variable ResultsStored;
	variable ResultsToKeep;
	variable EntriesDisplayed;

	for {set i 0} {$i < $EntriesDisplayed} {incr i} {
	    set I [expr $i + 1];
	    destroy .cacentry.chk$I
	    destroy .cacentry.txt$I
	}
	
	if {$ResultsStored < $ResultsToKeep} {
	    set EntriesToDisplay $ResultsStored;
	} else {
	    set EntriesToDisplay $ResultsToKeep;
	}

	for {set i 0} {$i < $EntriesToDisplay} {incr i} {
	    set I [expr $i + 1];
	    set ckbName .cacentry.chk$I
	    set labName .cacentry.txt$I
	    checkbutton $ckbName -width 2 -onvalue 1 -offvalue 0 -variable CacheChecked($I) \
		-relief sunken
	    label $labName  -justify left  -text \
		[FormatPopupString $I [lindex $ResultList $i]]
	    balloonhelp_for $labName  [lindex [lindex $ResultList $i] 2]
	    grid $ckbName  -row $I -column 0
	    grid $labName  -row $I -column 1 -sticky w  -columnspan 4
	}
	set EntriesDisplayed $EntriesToDisplay
    }
}

proc ExplainAlpha {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Alpha] ==1} {return}
    set po [CreateTextDisplay [_ "Alpha Characters"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Alpha) $po;
    AppendToTextDisplay $po [_ "The ASCII alpha characters are the letters a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z and their upper-case counterparts. In other writing systems the alpha characters are the characters considered equivalent in function, that is, in having primarily phonological content, as opposed to punctuation, numerals, spaces, and so forth. The definition of this class depends on the locale."];
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainAlphaNumWord {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown AlphaNumWord] ==1} {return}
    set po [CreateTextDisplay [_ "Alphanumeric and Word Characters"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(AlphaNumWord) $po;
    AppendToTextDisplay $po [_ "Two subtly different classes of characters are used in regular expressions. The more traditional class is the \`alphanumeric\' class, which is the union of the letters and the digits. In the ASCII character set and in, e.g., the C locale, the alphanumeric class consists therefore of the 52 letters of the alphabet, upper- and lower-case, and the ten digits 0-9. In other locales the membership of the alpha characters and digits may vary, but the alphanumeric class always consists of the union of the two sets."];
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "The related class of characters, sometimes confused with the alphanumerics and given the same name, is what are sometimes called the \`word\' characters. These are the characters that may be used in words, that is, in identifiers such as variables and function names, in certain programming languages. The word characters consist of the alphanumeric characters together with the underscore character."];
    AppendToTextDisplay $po "\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainAny {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Any] ==1} {return}
    set po [CreateTextDisplay [_ "Any"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Any) $po;
    AppendToTextDisplay $po [_ "This matches any number of repetitions, including zero, of the folowing character or block."];
}

proc ExplainBooleanAnd {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown BooleanAnd] ==1} {return}
    set po [CreateTextDisplay [_ "And"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(BooleanAnd) $po;
    AppendToTextDisplay $po [_ "This notation is used to require that the text match two regular expressions. The zero indicates that the two matches must be be located within zero lines of each other, that is, on the same line. In normal use, this program allows other values in this position, but since Redet is line-oriented these alternatives are not available."];
}


proc ExplainControlCharacter {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ControlCharacter] ==1} {return}
    set po [CreateTextDisplay [_ "ControlCharacter"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ControlCharacter) $po;
    AppendToTextDisplay $po [_ {The control characters are usually the ASCII control characters, namely the first 32 characters (0x00-0x1F) and the last ASCII character (0x7F). They are so named because their original purpose was to control actions of teletype machines, such as ringing the bell, as opposed to denoting printable characters. Many control characters are no longer routinely seen in text, but some are common since they include such characters as tab and linefeed. On many keyboards, pressing the Control key at the same time as typing another letter generates a code in the ASCII control range. Control characters are sometimes referred to by the combination of keys that generates them.  0x01 is Control-A, 0x02 is Control-B, through 0x26, which is control Z.  (The other keyboard equivalents are 0x00 = Control-@, 0x1B = Control-[, 0x1C = Control-\, 0x1D = Control-], 0x1E = Control-^, and 0x1F = Control-_.) The space character 0x20 is sometimes also considered a control character.}];
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "Additional control characters are defined in some encodings. For instance, in the ISO-8859-1 extension of ASCII (also known as Latin-1) widely used for European languages, codepoints 0x80-0x9F are also control characters. The named class of control characters used in regular expressions refers either to just the ASCII control characters or to additional control characters from the ISO-8859-1 range depending on the locale. Unicode does not introduce any control characters beyond those defined in ISO-8859-1.\n"];
    AppendToTextDisplay $po "\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainCrosshatchAny {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown CrosshatchAny] ==1} {return}
    set po [CreateTextDisplay [_ "Crosshatch"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(CrosshatchAny) $po;
    AppendToTextDisplay $po [_ "This matches one or more tokens of the preceding character."];
}


proc ExplainOrString {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown OrString] ==1} {return}
    set po [CreateTextDisplay [_ "String Disjunction"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(OrString) $po;
    AppendToTextDisplay $po [_ "This matches a string that contains either or both of the two argument strings."];
}

proc ExplainAndString {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(AndString)]} {
	if {[winfo exists $PopupList(AndString)]} {
	    destroy $PopupList(AndString);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "String Conjunction"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(AndString) $po;
    AppendToTextDisplay $po [_ "This matches a string that contains both of the two argument strings."];
}

proc ExplainDigit {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(Digit)]} {
	if {[winfo exists $PopupList(Digit)]} {
	    destroy $PopupList(Digit);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Digit"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Digit) $po;
    AppendToTextDisplay $po [_ "Digit here refers specifically to the decimal digits: 0 1 2 3 4 5 6 7 8 and 9. In some locales, additional local numerals may be included."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainLiteralMetachar {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(LiteralMetachar)]} {
	if {[winfo exists $PopupList(LiteralMetachar)]} {
	    destroy $PopupList(LiteralMetachar);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Literal Metacharacter"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(LiteralMetachar) $po;
    AppendToTextDisplay $po [_ "It is sometimes necessary to give their ordinary meaning to\
metacharacters, that is, characters that have a special meaning in regular expressions.\
For example, we may want to match the character *, not any number of characters or any\
number of the preceding regular expression.  When a character is a metacharacter,\
prefixing it with an escape character gives it its literal meaning. For example,\
if * is a metacharacter, in many programs \\* is a literal star."];
}

proc ExplainDot {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(Dot)]} {
	if {[winfo exists $PopupList(Dot)]} {
	    destroy $PopupList(Dot);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Dot"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Dot) $po;
    AppendToTextDisplay $po [_ "This matches any single character except, possibly, newline.\
Whether it matches newline depends on the program and sometimes can be set by the user.\
If you want dot to match newline, see if the matcher you are using supports the inline\
flag \`s\'. In several matchers, including Perl, Python, and Java, this flag causes dot\
to match newline."];
}

proc ExplainExactMatch {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(ExactMatch)]} {
	if {[winfo exists $PopupList(ExactMatch)]} {
	    destroy $PopupList(ExactMatch);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Exact Matching"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ExactMatch) $po;
    AppendToTextDisplay $po [_ "Some programs that support approximate matching provide ways of restricting the permissible location of inexact matches. One such device is to mark a substring as requiring an exact match by surrounding it with angle brackets. For example, with the total error level set to 1, \`r<ead>s\' matches \`ready\' and \`beads\', since in both cases the errors fall outside the marked substring, but does not match \`roads\', since the error (o instead of e) falls within the marked substring. The other device is the \{~0\} operator, which requires the preceding group to match exactly. In this notation, our example is: \`r(ead)\{~0\}s\'"];
}


proc ExplainOctalDigit {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown OctalDigit] ==1} {return}
    set po [CreateTextDisplay [_ "Octal Digit"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(OctalDigit) $po;
    AppendToTextDisplay $po [_ "The octal digits are the characters used to write numbers in base 8. These are: 0,1,2,3,4,5,6,7,8."];
}

proc ExplainHexDigit {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown HexDigit] ==1} {return}
    set po [CreateTextDisplay [_ "Hexadecimal Digit"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(HexDigit) $po;
    AppendToTextDisplay $po [_ "The hexadecimal digits are the characters used to write numbers in base 16.\
 These are: 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e, and f. The letters a-f may be either lower or upper case."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainHyphenPrev {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(HyphenPrev)]} {
	if {[winfo exists $PopupList(HyphenPrev)]} {
	    destroy $PopupList(HyphenPrev);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Hyphen"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(HyphenPrev) $po;
    AppendToTextDisplay $po [_ "This matches any number of repetitions, including zero, of the preceding group. The group may be explicitly marked or it may be an implicit group consisting of a single character. For example, \`sing-\' means \`the letters sin followed by any number, including zero, of gs\'. \`sing*\'therefore matches \`sin\' but does not match \`sings\, \`singlet\', or \`singer\'."]
}

proc ExplainPlus {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(Plus)]} {
	if {[winfo exists $PopupList(Plus)]} {
	    destroy $PopupList(Plus);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Plus"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Plus) $po;
    AppendToTextDisplay $po [_ "This matches one or more repetitions of the preceding group. The group may be explicitly marked or it may be an implicit group consisting of a single character. Thus \a+`\' matches \`a\', \`aa\', \`aaa\', \`aaaa\' and so forth, while, in a program in which parentheses are used for grouping, \`(abc)+\' matches \`abc\', \`abcabc\', \`abcabcabc\' and so forth. Since + quantifies another regular expression, it cannot stand alone. This usage should be distinguished from the alternative, found primarily in filename globbing, in which plus matches any string containing one or more characters. In that usage, plus does not quantify another regular expression and can therefore stand alone. For example, in the present usage \`sin+\' means matches \`match the sequence si followed by one or more ns\'. It therefore matches \`sin\' and \`sinn\' (if we include non-English words), but does not match \`sing\', \`sins\', or \`singlet\'. In the alternative usage, \`sing\', \`sins\', and \`singlet\' all match, but \`sin\' does not match, since the + requires that at least one character follow \`sin\'."]}

proc ExplainPlusAny {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(PlusAny)]} {
	if {[winfo exists $PopupList(PlusAny)]} {
	    destroy $PopupList(PlusAny);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Plus"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(PlusAny) $po;
    AppendToTextDisplay $po [_ "This matches any string containing at least one character. Since it does not quantify another regular expression, it can stand alone. This usage should be distinguished from the more common usage in which the + sign represents one or more repetitions of the preceding regular expression and therefore cannot stand alone. In the present usage, \`sing\', \`sins\', and \`singlet\' all match, but \`sin\' does not match, since the + requires that at least one character follow \`sin\'. In the alternative usage, \`sin+\' means \`match the sequence si followed by one or more ns\'. It therefore matches \`sin\' and \`sinn\' (if we include non-English words), but does not match \`sing\', \`sins\', or \`singlet\'."]}

proc ExplainSelfishQuantifier {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(SelfishQuantifier)]} {
	if {[winfo exists $PopupList(SelfishQuantifier)]} {
	    destroy $PopupList(SelfishQuantifier);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Selfish Quantifier"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(SelfishQuantifier) $po;
    AppendToTextDisplay $po [_ "Quantiers in regular expressions may be\
reluctant (also known as \`lazy\'), greedy, or selfish (also known as \`possessive\'.\
The traditional quantifiers are greedy. The distinction depends on how the quantifier interacts\
with other parts of the regular expression.\
An ordinary \`greedy\' quantifier matches as much as it can\
while still allowing other parts of the regular expression to match.\
A selfish quantifier matches the largest substring that it can, even\
if that causes other parts of the regular expression to fail to match and\
therefore causes the expression as a whole to fail to match."];
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "
For example, consider the regular expression\
\`(a)(b++)(b+)(a)\', where\
\`+\' is the ordinary quantifier meaning \`one or more  repetitions of the preceding\
group\' and \`++\' is its selfish counterpart. What will happen when this\
expression is applied to the string \`abbbba\'? The \`a\'s at either end\
will match. The question is, how will the two terms with \`b\'s divide\
up the four \`b\'s in the string between them? Since the first b-term is\
selfish, it will match the largest substring that satisfies it, which is\
all four \`b\'s. This will leave no \`b\' to be matched by the third term,\
so the regular expression as a whole will fail to match. If we change\
the quantifier in the second term from selsifh to ordinary, the regular\
expression will match since the non-selfish quantifier in the second\
term will cede the last \`b\' to the third term."];
}

proc ExplainReluctantQuantifier {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(ReluctantQuantifier)]} {
	if {[winfo exists $PopupList(ReluctantQuantifier)]} {
	    destroy $PopupList(ReluctantQuantifier);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Reluctant Quantifier"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ReluctantQuantifier) $po;
    AppendToTextDisplay $po [_ "Quantiers in regular expressions may be\
reluctant (also known as \`lazy\'), greedy, or selfish (also known as \`possessive\'.\
The traditional quantifiers are greedy. The distinction depends on how the quantifier interacts\
with other parts of the regular expression.\
A reluctant quantifier matches the smallest substring that it can.\
An ordinary \`greedy\' quantifier matches as much as it can\
while still allowing other parts of the regular expression to match."];
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "For example, consider the regular expression\
\`(a)(b+?)(b+)(a)\', where\
\`+\' is the ordinary quantifier meaning \`one or more  repetitions of the preceding\
group\' and \`+?\' is its reluctant counterpart. What will happen when this\
expression is applied to the string \`abbbba\'? The \`a\'s at either end\
will match. The question is, how will the two terms with \`b\'s divide\
up the four \`b\'s in the string between them? Since the first b-term is\
reluctant, it will match the smallest substring that satisfies it, which is\
a single \`b\'. The other three \`b\'s will be matched by the third term.\
How the \`b\'s are divided up makes no difference to the success of the match\
in this case, but it is relevant when doing substitutions and for backreferences."];
}

proc ExplainStar {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(Star)]} {
	if {[winfo exists $PopupList(Star)]} {
	    destroy $PopupList(Star);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Star"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Star) $po;
    AppendToTextDisplay $po [_ "This matches any number of repetitions, including zero, of the preceding group. The group may be explicitly marked or it may be an implicit group consisting of a single character. This usage of star should be distinguished from the alternative, familiar especially from filename globbing, in which the star stands for any number of any character. In the present usage, star cannot stand alone; it quantifies another regular expression. In the usage typical of filename globbing, star can stand alone. In other words, star in the globbing usage is equivalent to .* in the non-globbing usage (assuming that the program is one in which dot stands for any character). For example, in the present usage, \`sing*\' means \`the letters sin followed by any number, including zero, of gs\'. \`sing*\'therefore matches \`sin\' but does not match \`sings\, \`singlet\', or \`singer\'. in the other usage, \`sing*\' matches \`sings\, \`singlet\', and \`singer\', since the star indicates that anything may follow \`sing\', but not \`sin\', since the \`g\' is a fixed part of the expression."];
}

proc ExplainZeroOrMoreCurly {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ZeroOrMoreOnly] ==1} {return}
    set po [CreateTextDisplay [_ "Empty Range"] $HPWidth $HPLines]
    set PopupList(ZeroOrMoreOnly) $po;
    BindKeys $po;
    AppendToTextDisplay $po [_ "This matches any number of repetitions, including zero, of the preceding group. The group may be explicitly marked or it may be an implicit group consisting of a single character."];
}

proc ExplainStarAny {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown StarAny] ==1} {return}
    set po [CreateTextDisplay [_ "Star"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(StarAny) $po;
    AppendToTextDisplay $po [_ "This matches an arbitrary sequence of characters of any length, including zero. It should be distinguished from the more common usage of star in which a regular expression followed by star matches any number of repetitions of the regular expression. In that usage, star may not stand alone since it quantifies another regular expression. In the present usage, star may stand alone. For example, in the present usage, \`sing*\' matches \`sings\, \`singlet\', and \`singer\', since the star indicates that anything may follow \`sing\', but not \`sin\', since the \`g\' is a fixed part of the expression. In the other usage, \`sing*\' means \`the letters sin followed by any number, including zero, of gs\'. \`sing*\'therefore matches \`sin\' but does not match \`sings\, \`singlet\', or \`singer\'."];
}


proc ExplainBackReferenceSub {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(BackReferenceSub)]} {
	if {[winfo exists $PopupList(BackReferenceSub)]} {
	    destroy $PopupList(BackReferenceSub);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Substitution Backreferences"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(BackReferenceSub) $po;
    AppendToTextDisplay $po [_ "Expressions of this form insert a copy of the corresponding captured group in the regular expression."]
    AppendToTextDisplay $po [_ "For example, if the regular expression is {(.*)(ity|ness)},\
where the first parenthesis matches any string and the second parenthesis matches either \"ity\"\
or \"ness\", and the backreference notation is \$k, the expression \$2 in the substitution\
will insert whichever of the two suffixes was matched and \$1 will insert the part of the\
string  preceding the suffix. The substitution expression \"\$2 \$1-\$2 \" will produce\
a copy of the string preceded by the suffix and with the suffix separated from the\
rest of the word by a hyphen. For example, the input \"ability\" will produce the\
output \"ity abil-ity\"."];
    if {[string equal $::program perl]} {
	AppendToTextDisplay $po "\n\n";
	AppendToTextDisplay $po [_ "In Perl, backreferences within the regular expression proper use backslash followed by the group number. Backreferences from the substitution expression to the regular expression use dollar sign instead of backslash. Backslash works in some circumstances, but it is only sure to work within the match expression, so to be safe you should use dollar sign in substitutions."];
    }
    AppendToTextDisplay $po "\n\n";
    foreach x  [list \
		    SubBackRefBare\
		    SubBackReferenceDol\
		    SubBackReferencePercent\
		    SubBackRefbs\
		    SubBackRefParbs\
		    SubBackRefdbs\
		    SubBackRefPardbsdbs] {
	if {$::Features($x,$::program,$::InterfaceLocale)} {
	    if {$::Features(${x}AtLeastTen,$::program,$::InterfaceLocale) == 0} {
		if {![string equal $::Palette($x,Prefix) ""]} {
		    AppendToTextDisplay $po [format \
			 [_ "The back reference index with prefix %s must be no greater than 9."] \
					     $::Palette($x,Prefix)];
		} else {
		    AppendToTextDisplay $po \
			[_ "The back reference index must be no greater than 9."];
		}
	    } else {
		if {![string equal $::Palette($x,Prefix) ""]} {
		    AppendToTextDisplay $po [format \
			 [_ "The back reference index with prefix %s may exceed 9."] \
					     $::Palette($x,Prefix)];
		} else {
		    AppendToTextDisplay $po \
			[_ "The back reference index may exceed 9."];
		}
	    }
	}
    }
}

proc ExplainTRECostSetting {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(TRECostSetting)]} {
	if {[winfo exists $PopupList(TRECostSetting)]} {
	    destroy $PopupList(TRECostSetting);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "TRE Cost Setting"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(TRECostSetting) $po;
    AppendToTextDisplay $po [_ "This construction sets the error costs for the immediately preceding group. When using approximate matching, it is necessary to decide when an imperfect match is to count as good enough. This construction allows you to specify how to make this decision on a group-by-group basis."];
    AppendToTextDisplay $po [_ "\n\n"];
    AppendToTextDisplay $po [_ "Each cost specification consists of two parts, both optional. If both are present, they are separated by a comma. The first part sets limits on the number of different types of errors directly. The second part specifies a formula for computing the total error cost and setting a limit on it."];
    AppendToTextDisplay $po [_ "\n\n"];
    AppendToTextDisplay $po [_ "
Three types of error are recognized. An error is an insertion if the target string may be obtained from the match pattern by adding one character to it. For example, \`red\' becomes \`read\' by the insertion of an \`a\'. An error is a deletion if the target string may be obtained from the match pattern by removing one character from it. For example, \`read\' becomes \`red\' by deletion of an \`a\'. Two strings differing in that one contains one character more than the other may be regarded as related by either insertion or deletion, depending on which string is taken to be the source. In this case, the pattern is taken to be the source and the target string is taken to be the result of the transformation. Thus, the pattern \`red\' matches the string \`read\' if ane insertion is permitted but not if only deletions are permitted. An error is a substitution if one string may be obtained from the other by substituting one character for another. For example, \`read\' becomes \`road\' by substitution of \`o\' for \`e\'."];
    AppendToTextDisplay $po [_ "\n\n"];
    AppendToTextDisplay $po [_ "Limits on error numbers may be set on insertions, deletions, and substitutions individually or on the total number of errors, or both. The maximum permitted number of insertions takes the form \`+k\', where \`k\' is a non-negative integer. Similarly, the limit on deletions takes the form \`-k\', the number of substitutions the form \`\#k\', and the total number of errors of any type the form \`~k\'. The cost specification \`{+2-3\#1~4}\' therefore means that a maximum of two insertions, three deletions, and one substitution are permitted and that the total number of errors must not exceed four."];
    AppendToTextDisplay $po [_ "\n\n"];
    AppendToTextDisplay $po [_ "The cost equation (which is not really an equation) specifies the weight to be given to each of the three types of errors and sets a maximum total cost. The weights are specified by writing a non-negative integer before \`i\' for insertions, \`d\' for deletions, and \`s\' for substitutions. If more than one is specified, they may be separated by plus signs. The total cost, which is not optional (if a cost equation is given at all) consists of a less-than sign followed by a positive integer. Note that the less-than sign here does not have its usual mathematical meaning.  \`<k\' means that \`k\' is the maximum permitted, which is to say that the maximum total cost must be less than or equal to \`k\'. The cost equation \`1i + 3d + 2s < 4\' says that insertions count one unit, deletions three units, and substitutions two units, and that the total cost must be no greater than four. With this cost equation, \`reads\' matches \`brads\' because the total cost is one insertion and one deletion, for a permissible total of four, but not \`red\', because this requires two deletions, for an impermissible  total cost of six."];}

proc ExplainUnicodeCategory {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(UnicodeCategory)]} {
	if {[winfo exists $PopupList(UnicodeCategory)]} {
	    destroy $PopupList(UnicodeCategory);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Unicode Categories"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(UnicodeCategory) $po;
    AppendToTextDisplay $po [_ "Unicode characters are classified according to a number of properties, such as whether they are upper case letters, mathematical symbols, and so forth. Some programs allow you to refer to the classes of characters defined by these properties. For example, in Java \`\\p{Sm}\' matches any mathematical symbol.\n\n"];
    AppendToTextDisplay $po [_ "A list of the Unicode categories and their abbreviations is available under the \`Unicode General Character Properties\' on the \`Help\' menu. The classification of every character can be found in the file \`UnicodeData.txt\', which is distributed by the Unicode Consortium."];
    AppendToTextDisplay $po [_ "You can download a copy (approximately 950kb) here: "];
    AppendLinkToTextDisplay $po "UnicodeData.txt" {ShowWebPage http://www.unicode.org/Public/UNIDATA/UnicodeData.txt};
    AppendToTextDisplay $po [_ "\nIn Python this information is provided by the \`unicodedata\' module. Read the documentation: "];
    AppendLinkToTextDisplay $po "Python unicodedata module" {ShowWebPage http://www.python.org/doc/current/lib/module-unicodedata.html};
}

proc ExplainUnicodeRange {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(UnicodeRange)]} {
	if {[winfo exists $PopupList(UnicodeRange)]} {
	    destroy $PopupList(UnicodeRange);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Unicode Range"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(UnicodeRange) $po;
    AppendToTextDisplay $po [_ "Unicode characters are divided into \`ranges\', such as \`Basic Latin\', \`Armenian\', \`Georgian\' and \`Nebrew\'. As these names suggest, \`ranges\' correspond roughly to writing systems. For example, the Tamil range contains the characters specific to Tamil. However, the correspondance is only approximate. Many languages use characters drawn from two or more ranges. For example, Tamil uses the letters in the Tamil range but spaces and punctuation from the Basic Latin range, while Japanese uses the several ranges containng Chinese characters plus the Hiragana and Katakana ranges and the Basic Latin range. Conversely, many ranges contain characters from more than one writing system. The Canadian Aboriginal Syllabics range, for example, combines the historically related but distinct writing systems of Cree, Inuktitut, Carrier and severalother languages. Unicode ranges are therefore useful for some purposes, but it is a mistake to assume that they can be used straightforwardly to identify text in a particular writing system or language.\n\n"];
    AppendToTextDisplay $po [_ "A list of the Unicode ranges is available under \`Unicode Ranges\' on the \`Help\' menu. PDF files showing the contents of the various ranges may be downloaded from the Unicode Consortium: "];
    AppendLinkToTextDisplay $po "here" {ShowWebPage http://www.unicode.org/charts/PDF/};
    AppendToTextDisplay $po [_ " A list of ranges with links to web pages displaying the range and the above PDF files is available: "];
    AppendLinkToTextDisplay $po "here" {ShowWebPage http://www.ling.upenn.edu/courses/ling538/UnicodeRanges.html};
}

proc ExplainUnicodeName {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(UnicodeName)]} {
	if {[winfo exists $PopupList(UnicodeName)]} {
	    destroy $PopupList(UnicodeName);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Unicode Name"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(UnicodeName) $po;
    AppendToTextDisplay $po [_ "Every Unicode character has an official name by which it is designated in the Unicode standard. One way to include an arbitrary Unicode character in a regular expression is to refer to it by this name. (The other is to refer to it by its code number.)\n\n"];
    AppendToTextDisplay $po [_ "A list of Unicode characters and their names can be found in the file \`NamesList.txt\', which is distributed by the Unicode Consortium."];
    AppendToTextDisplay $po [_ "You can download a copy (approximately 786k) here: "];
    AppendLinkToTextDisplay $po "NamesList.txt" {ShowWebPage http://www.unicode.org/Public/UNIDATA/NamesList.txt};
    AppendToTextDisplay $po [_ " However, this file does not illustrate the characters. If you need to look at examples of the characters to determine their names, you can consult the PDF files containing the sections of the Unicode standard devoted to the various ranges "];
    AppendLinkToTextDisplay $po "here" {ShowWebPage http://www.unicode.org/charts/PDF/};
    AppendToTextDisplay $po [_ " or you can use a character map program such as "];
    AppendLinkToTextDisplay $po "gucharmap" {ShowWebPage http://gucharmap.sourceforge.net/}
    AppendToTextDisplay $po [_ " You can also look at the characters as they are rendered by your browser on pages such as "];
    AppendLinkToTextDisplay $po "these" {ShowWebPage http://www.ling.upenn.edu/courses/ling538/UnicodeCharts/UnicodeIndex.html}
    AppendToTextDisplay $po [_ " (The computer program used to generate these pages is available "];
    AppendLinkToTextDisplay $po "here" {ShowWebPage http://www.billposer.org/Software/software.html#unicodechart}
    AppendToTextDisplay $po [_ ") You can then use the NamesList to convert from codepoint to name."];
}

proc ExplainWhitespace {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(Whitespace)]} {
	if {[winfo exists $PopupList(Whitespace)]} {
	    destroy $PopupList(Whitespace);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Whitespace"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Whitespace) $po;
    AppendToTextDisplay $po [_ "\`Whitespace\' traditionally refers to the ASCII characters: space (0x0020), tab (0x0009), vertical tab (0x000B), newline/linefeed (0x000A), carriage return (0x000D), and formfeed (0x000C). Vertical tab and formfeed will of course rarely be encountered in normal text. Carriage return and linefeed are generally encountered only as end-of-line markers (on Unix systems, linefeed alone, on Macintosh systems, carriage return alone, and on DOS and MS Windows systems, carriage return followed by linefeed). When working with line-oriented software, then, in practice \`whitespace\' will usually refer to just space and (horizontal) tab. Outside of the ASCII range, however, there are other characters that may be considered whitespace, such as 0x3000 IDEOGRAPHIC SPACE, which is commonly found in Japanese text. Whether these other characters are included depends on the locale."];
    AppendToTextDisplay $po "\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}


proc ExplainBell {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(Bell)]} {
	if {[winfo exists $PopupList(Bell)]} {
	    destroy $PopupList(Bell);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "Bell"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Bell) $po;
    AppendToTextDisplay $po [_ "The bell character, ASCII 0x07, is a non-printing character that used to ring the bell on teletype machines. On modern computers it will generally make a bell-like sound. On some systems it may be redefined to attract attention in some other way, such as by flashing the screen."];
}

proc ExplainASCIIChar {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[info exists PopupList(ASCIIChar)]} {
	if {[winfo exists $PopupList(ASCIIChar)]} {
	    destroy $PopupList(ASCIIChar);
	    return;
	}
    }
    set po [CreateTextDisplay [_ "ASCII Character"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ASCIIChar) $po;
    AppendToTextDisplay $po [_ "This matches any ASCII character. An ASCII character is one of the 128 characters defined in the American Standard for Computer Information Interchange. The international equivalent is ISO 646. The ASCII characters consist of the 26 letters used in English, upper- and lower-case, the digits 0-9, 32 punctuation symbols, 33 control characters, most of which are not used in text, and the space character. The first 128 characters of Unicode are the same as in ASCII."];
    AppendToTextDisplay $po [_ "\n\n"];
    AppendToTextDisplay $po [_ "ASCII charts are widely available. On any UNIX system the command \`man 7 ascii\' should produce an ASCII chart. Charts may be found on the web at locations including:"];
    AppendLinkToTextDisplay $po "here, " {ShowWebPage http://www.jimprice.com/jim-asc.htm}
    AppendLinkToTextDisplay $po "here, " {ShowWebPage http://www.ling.upenn.edu/courses/ling538/ascii.html}
    AppendLinkToTextDisplay $po "here, " {ShowWebPage http://ostermiller.org/calc/ascii.html}
    AppendLinkToTextDisplay $po "and here." {ShowWebPage http://www.asciitable.com}
    AppendToTextDisplay $po [_ "\n"];
     AppendToTextDisplay $po [_ "An ASCII chart color-coded for the POSIX character classes is included in the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po "\n"
}

proc ExplainTaggedgroup {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown TaggedGroup] ==1} {return}
    set po [CreateTextDisplay [_ "Tagged Group"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Taggedgroup) $po;
    AppendToTextDisplay $po [_ "Tagged groups provide a more mnemonic way to refer to subexpressions. Traditionally, capture groups can be identified only by their position: one specifies the first group, the third, or whatever. Tagged groups associate an identifier with each group. Backreferences may then be made using this identifier."];
}

proc ExplainTaggedBackReference {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown TaggedBackReference] ==1} {return}
    set po [CreateTextDisplay [_ "Tagged Group Backreference"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(TaggedBackReference) $po;
    AppendToTextDisplay $po [_ "This matches the preceding group with the same tag."];
}

proc ExplainEndOfString {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown EndOfString] ==1} {return}
    set po [CreateTextDisplay [_ "End Of String"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(EndOfString) $po;
    AppendToTextDisplay $po [_ "This matches the end of the string. Some regular expression matchers consider it to match only at the abolute end of the string. Others will ignore a terminating end-of-line marker."];
    AppendToTextDisplay $po [_ "\n\n"];
    AppendToTextDisplay $po [_ "If you find that patterns ending in end-of-string fail to match at the ends of lines, the problem may be the presence of end-of-line markers. This can arise in several ways. First, if you are reading data from a file line by line, readline functions vary as to whether or not they include the end-of-line marker at the end of the string. If they do, and if the regular expression matcher you are using is one in which a character is not considered to be at the end of the string if it is followed by end-of-line characters, what appears to you to be the last character in the string will not be treated as such. Second, if your data come from a DOS or MS Windows system in which end-of-line is marked by the sequence Carriage Return-Line Feed (0x0D 0x0A) and you are using a Unix system and no translation to native text format is done, even if your readline function strips the Line Feed, it will leave the Carriage Return, which from its point of view is not part of the end-of-line marker. The regular expression matcher will treat the Carriage Return as an ordinary character and so will not consider the character preceding it to be at the end of the string."];
    AppendToTextDisplay $po [_ "\n"];

}
proc ExplainAbsoluteEndOfString {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown EndOfString] ==1} {return}
    set po [CreateTextDisplay [_ "Absolute End Of String"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(EndOfString) $po;
    AppendToTextDisplay $po [_ "This matches the end of the string. Some regular expression matchers consider it to match only at the abolute end of the string. Others will ignore a terminating end-of-line marker."];
    AppendToTextDisplay $po [_ "\n\n"];
    AppendToTextDisplay $po [_ "If you find that patterns ending in end-of-string fail to match at the ends of lines, the problem may be the presence of end-of-line markers. This can arise in several ways. First, if you are reading data from a file line by line, readline functions vary as to whether or not they include the end-of-line marker at the end of the string. If they do, and if the regular expression matcher you are using is one in which a character is not considered to be at the end of the string if it is followed by end-of-line characters, what appears to you to be the last character in the string will not be treated as such. Second, if your data come from a DOS or MS Windows system in which end-of-line is marked by the sequence Carriage Return-Line Feed (0x0D 0x0A) and you are using a Unix system and no translation to native text format is done, even if your readline function strips the Line Feed, it will leave the Carriage Return, which from its point of view is not part of the end-of-line marker. The regular expression matcher will treat the Carriage Return as an ordinary character and so will not consider the character preceding it to be at the end of the string."];
    AppendToTextDisplay $po [_ "\n"];

}


proc ExplainTab {} {
    global HPWidth;
    global HPLines;
    if {[PopupDown Tab] ==1} {return}
    set po [CreateTextDisplay [_ "Tab"] $HPWidth $HPLines]
    BindKeys $po;
    set ::PopupList(Tab) $po;
    AppendToTextDisplay $po [_ "This matches the horizontal tab character (0x09)."];
}

proc ExplainSpace {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Blank] ==1} {return}
    set po [CreateTextDisplay [_ "Blank"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Blank) $po;
    AppendToTextDisplay $po [_ "The Blank class consists of just space (0x20) and horizontal tab (0x09). It is a subset of Whitespace. In some locales it may contain equivalent characters from other ranges, such as 0x3000 Ideographic Space, which is used in Chinese, Japanese, and Korean."];
    AppendToTextDisplay $po "\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainGroup {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Group] ==1} {return}
    set po [CreateTextDisplay [_ "Group"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Group) $po;
    AppendToTextDisplay $po [_ "Group notation serves two purposes.\
First, it groups together characters to which an\
operator such as a quantifier should apply as a unit. For example, in matchers\
in which + means \`one or more repetitions of the preceding group\', \
\`(ab)+\' matches \`ab\', \`abab\', \`ababab\', etc., whereas \`ab+\' matches\
\`ab\', \`abb\', \`abbb\', etc. Secondly, it creates subexpressions which can\
be referred to by  later portions of the same regular expression or by\
a substitution expression. For example, in matchers in which the expression\
\`(\\d{5})(-\\d{4})?)\' matches US zip codes consisting of five digits optionally\
followed by a hyphen and four digits, the parentheses create the possibility\
of backreferences to the two components of long form zip codes. A substitution\
could replace the input with just the first component, thereby converting\
any well-formed zip code into the short form. Groups that serve this second\
function are called \`capture groups\' to differentiate them from\
the \`no capture groups\' that some matchers provide, which are ignored for\
the purpose of back-references."];}

proc ExplainNoCaptureGroup {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown NoCaptureGroup] ==1} {return}
    set po [CreateTextDisplay [_ "No Capture Group"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(NoCaptureGroup) $po;
    AppendToTextDisplay $po [_ "A no capture group is like an ordinary group in that it\
groups together characters to which an operator such as a quantifier\
should apply as a unit. It differs from an ordinary group in that\
it does not create a target for backreferences. For example, in a\
matcher in which \`(abc)\' is an ordinary group, \`(?:abc)\' is a no\
capture group,  and back references are of the form\
\`\\k\', the regular expression \`(ab)(?:cd)(ef)\\2\\1\'\
will match \`abcdefefab\', not \`abcdefcdab\'. Since\
\`cd\' is in a no capture group, it is ignored by backreferences."]}

proc ExplainBackReferenceMatch {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown BackReferenceMatch] ==1} {return}
    set po [CreateTextDisplay [_ "Match BackReference"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(BackReferenceMatch) $po;
    AppendToTextDisplay $po [_ "This matches whatever was matched by the corresponding\
capture group. For example, in a matcher in which bare parentheses delimit capture groups\
and in which the notation for back reference is of the form \`\\k\', the expression\
\`(..)-\\1\'  matches any string consisting of two characters, a hyphen, and the same\
two characters, such as\`ab-ab\', \`fa-fa\', or \`oh-oh\'. "];
    if {$::Features([WhichMatchBackReference]AtLeastTen,$::program,$::InterfaceLocale) == 0} {
	AppendToTextDisplay $po "\n\n";
	AppendToTextDisplay $po "The back reference index must be no greater than 9.";
    }
}


#Returns the name of the match back reference feature that
#is available for the current program and locale, or the empty string
#if there is none.
proc WhichMatchBackReference {} {
    foreach x  [list \
		    backref\
		    backrefdbs\
		    backrefper\
		    backrefbsall\
		    backrefksh\
		    backrefdbsall] {
	if {$::Features($x,$::program,$::InterfaceLocale)} {
	    return $x;
	}
    }
    return "";
}

proc PopupDown {n} {
    global PopupList;
    if {[info exists PopupList($n)]} {
	if {[winfo exists $PopupList($n)]} {
	    destroy $PopupList($n);
	    return 1;
	}
    }
    return 0;
}

proc ExplainStarNext {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown StarNext] ==1} {return}
    set po [CreateTextDisplay [_ "Star Next"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(StarNext) $po;
    AppendToTextDisplay $po [_ "This expression matches zero or more occurences of the parenthesized group."];
}

proc ExplainPlusNext {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown PlusNext] ==1} {return}
    set po [CreateTextDisplay [_ "Plus Next"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(PlusNext) $po;
    AppendToTextDisplay $po [_ "This expression matches one or more occurences of the parenthesized group."];
}

proc ExplainZeroOneQMarkNext {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ZeroOneQMarkNext] ==1} {return}
    set po [CreateTextDisplay [_ "Question Mark Next"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ZeroOneQMarkNext) $po;
    AppendToTextDisplay $po [_ "This expression matches zero or one occurences of the parenthesized group."];
}

proc ExplainAtSignOneNext {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown AtSignOneNext] ==1} {return}
    set po [CreateTextDisplay [_ "At Sign Next"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(AtSignOneNext) $po;
    AppendToTextDisplay $po [_ "This expression matches exactly one expression from the parenthesized group. If the group is non-compound, it matches the parenthesized group. If the group contains alternatives, it matches any one of them."];
}

proc ExplainGroupComplement {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown GroupComplement] ==1} {return}
    set po [CreateTextDisplay [_ "Group Complement"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(GroupComplement) $po;
    AppendToTextDisplay $po [_ "This expression matches anything that does not match the parenthesized group."];
}
proc ExplainObligatoryQuantifierGroup {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ObligatoryQuantifierGroup] ==1} {return}
    set po [CreateTextDisplay [_ "Obligatorily Quantified Group"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ObligatoryQuantifierGroup) $po;
    AppendToTextDisplay $po [_ "The material within parentheses is treated as a group. The opening parenthesis must be preceded by one of the quantifiers: ?,+,*,@, or !. The parenthesized material may be a simple string, e.g. (abc) or it may be an alternative expression consisting of strings or quantified groups separated by | symbols, For example, the expression @(ab|cd) matches the strings ab and cd. The expression +(ab|cd|ef) matches strings including ab, cd, ef, abcd, cdef, abcdef, and cdabefab. It does not match bc, de, or abcde. The expression @(abc|*(cd)) matches the null string and the strings abc,cd,cdcd,cdcdcd, etc."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "These groups may be referred to by backreferences. The difference between the expressions @(abc) and abc is that the former creates a capture group to which a backreference may refer whereas the latter does not."]
}


proc ExplainNCopies {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown NCopies] ==1} {return}
    set po [CreateTextDisplay [_ "N Copies"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(NCopies) $po;
    AppendToTextDisplay $po [_ "This matches exactly N copies of the immediately\
preceding group. For example, \`b{3}\' matches \`bbb\' but\
not \`bb\'. This notation is a special case of the more general\
\`from M to N copies\' construction."];
}

proc ExplainMNAtLeast {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown MNAtLeast] ==1} {return}
    set po [CreateTextDisplay [_ "At Least N Copies"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(MNAtLeast) $po;
    AppendToTextDisplay $po [_ "This matches at least N copies of the immediately\
preceding group. For example, \`b{3,}\' matches \`bbb\'and \`bbbb\' but\
not \`bb\'. This notation is a special case of the more general\
\`from M to N copies\' construction."];
}

proc ExplainMNAtMost {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown MNAtMost] ==1} {return}
    set po [CreateTextDisplay [_ "At Most N Copies"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(MNAtMost) $po;
    AppendToTextDisplay $po [_ "This matches at most N copies of the immediately\
preceding group. For example, in one notation, \`b\\\{,3\\\}\' matches \`b\', \`bb\' and \`bbb\'
but not \`bbbb\'. This is a special case of the more general
\`from M to N copies\' construction. Many matchers do not allow the beginning of the range to be omitted."];
}

proc ExplainMNRange {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown MNRange] ==1} {return}
    set po [CreateTextDisplay [_ "Match From M to N Copies"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(MNRange) $po;
    AppendToTextDisplay $po [_ "This matches at least M copies and at most N copies\
of the immediately preceding group. For example,\
\`b{2,4}\' matches \`bb\', \'bbb\', and \`bbbb\' but not \`b\' or \`bbbbb\'"];
}

proc ExplainPunctuation {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Punctuation] ==1} {return}
    set po [CreateTextDisplay [_ "Punctuation"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Punctuation) $po;
    AppendToTextDisplay $po [_ {In the C locale and in purely ASCII systems, the punctuation class contains the 32 ASCII punctuation symbols: \
	    \" \# $ % & ' ( ) * + , - . / : ; < = > ? @ [ \\ ] ^ _ ` \{ | \} ~ \
In other locales, additional characters may be included and some of the ASCI\
characters may be excluded. Which characters fall into the punctuation class\
in a particular combination of program and locale is variable. Note that a common\
behavior is for programs to restrict the class to the ASCII characters in\
non-Unicode locales and to expand it to include all Unicode punctuation in\
Unicode locales, including punctuation that is not relevant to the locale.\
If the details matter to you, you should run tests to determine the membership\
of this class in your environment.}];
}

proc ExplainASCIIPunctuation {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ASCIIPunctuation] ==1} {return}
    set po [CreateTextDisplay [_ "ASCII Punctuation"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ASCIIPunctuation) $po;
    AppendToTextDisplay $po [_ {These sets are defined purely in terms of the ASCII\
punctuation set, which consists of the 32 characters:\
	! " \# $ % & ' ( ) * + , - . / : ; < = > ? @ [ \\ ] ^ _ ` \{ | \} ~ }];
}
# "

proc ExplainOctalCode {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown OctalCode] ==1} {return}
    set po [CreateTextDisplay [_ "Octal Character Codes"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(OctalCode) $po;
    AppendToTextDisplay $po [_ "\
It is traditional to give character codes and other numbers\
relevant to the internal operation of computers in octal, that is,\
base 8. The main reason for this is that it is convenient to use numbers\
that are integral powers of two because they are easily convertible\
into the binary (base two) representation that directly reflects the\
bit patterns in the computer's memory. More recently, numbers such as\
character codes have come to be given in hexadecimal (base 16)."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "\
In octal, each place represents a power of 8 rather than a power\
of 10. For example, the number 61 in octal is equivalent to decimal\
49 because it represents (6*8)+(1*1). The same number in binary is\
110001, representing (1*32)+(1*16)+(0*8)+(0*4)+(0*2)+(1*1). Octal\
numbers are usually written with a leading 0 as an indication that\
they are octal."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "\
It is useful to be able to refer to characters by their\
numerical codes when they have special meaning to the language\
which will process them or for some other reason cannot appear\
as such. For example, entering a newline character directly\
may disarrange your text or trigger a command that you do not\
want to trigger. Entering the numerical code for newline\
(012) allows you to refer to a newline and pass it on\
to another program or level of processing."];
}

proc ExplainDecimalCode {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown DecimalCode] ==1} {return}
    set po [CreateTextDisplay [_ "Decimal Character Codes"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(DecimalCode) $po;
    AppendToTextDisplay $po [_ "\
It is traditional to give character codes and other numbers\
relevant to the internal operation of computers in octal, that is,\
base 8. The main reason for this is that it is convenient to use numbers\
that are integral powers of two because they are easily convertible\
into the binary (base two) representation that directly reflects the\
bit patterns in the computer's memory. More recently, numbers such as\
character codes have come to be given in hexadecimal (base 16)."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po "This program, however, lets you use decimal\
    (base 10, like ordinary numbers) character codes if you wish to."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "\
It is useful to be able to refer to characters by their\
numerical codes when they have special meaning to the language\
which will process them or for some other reason cannot appear\
as such. For example, entering a newline character directly\
may disarrange your text or trigger a command that you do not\
want to trigger. Entering the numerical code for newline\
(012) allows you to refer to a newline and pass it on\
to another program or level of processing."];
}


proc ExplainHexCode {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown HexCode] ==1} {return}
    set po [CreateTextDisplay [_ "Hexadecimal Character Codes"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(HexCode) $po;
    AppendToTextDisplay $po [_ "\
Character codes and other numbers relevant to the internal operation\
of computers are usually given in hexadeciaml, that is, base 16.\
The main reason for this is that it is convenient to use numbers\
that are integral powers of two because they are easily convertible\
into the binary (base two) representation that directly reflects the\
bit patterns in the computer's memory."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "\
In hexadecimal, each place represents a power of 16 rather than a power\
of 10. For example, the number 61 in hexadecimal is equivalent to decimal\
97 because it represents (6*16)+(1*1). The same number in binary is\
01100001, representing (1*64)+(1*32)+(0*16)+(0*8)+(0*4)+(0*2)+(1*1). Hexadecimal\
numbers are usually written with a leading 0x as an indication that\
they are hexadecimal. The digits greater than nine are written with the\
first six letters of the alphabet: a = 10, b = 11, and so on.\
Some programs accept either upper- or lower-case letters, while others\
insist on one or the other."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "\
It is useful to be able to refer to characters by their\
numerical codes when they have special meaning to the language\
which will process them or for some other reason cannot appear\
as such. For example, entering a newline character directly\
may disarrange your text or trigger a command that you do not\
want to trigger. Entering the numerical code for newline\
(0x0A) allows you to refer to a newline and pass it on\
to another program or level of processing. Similarly, using\
numerical codes you can enter Unicode characters that you cannot\
enter by other means."];
}


proc ExplainEscape {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Escape] ==1} {return}
    set po [CreateTextDisplay [_ "Escape"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Escape) $po;
    AppendToTextDisplay $po [_ "
\`Escape\', ASCII/Unicode 0x1B, is not found in normal text. Its usual use\
is to send commands and messages to teletypes, terminals, and other such devices.\
It alerts the device that the next character is not to be interpreted as a\
normal character but rather is a code representing a special command.\
It is called \`Escape\' because it provides for an escape from the standard\
interpretation of the character codes. On most keyboards, the key labelled \`Esc\'
generates this character code."];
}

proc ExplainCarriageReturn {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown CarriageReturn] ==1} {return}
    set po [CreateTextDisplay [_ "Carriage Return"] $HPWidth $HPLines]
    BindKeys $po;
    AppendToTextDisplay $po [_ "Carriage Return (0x0D) is one of the characters used to\
mark end-of-line. On Unix systems, end-of-line is marked by Newline (0x0A). On Macintoshen,\
end-of-lineis marked by Carriage Return. On DOS and MS Windows sytems, end-of-line is\
marked by the sequence of Carriage Return followed by Newline."];
}

proc ExplainComment {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Comment] ==1} {return}
    set po [CreateTextDisplay [_ "Comment"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Comment) $po;
    AppendToTextDisplay $po [_ "Some matchers use this notation to allow you to\
put comments and whitespace inside regular expressions. A comment consists of whatever text\
you would like to insert. It is there only for the benefit of people reading the program.\
It has no effect on the match. Comments begin with a crosshatch (\#) and continue until\
the end of the line. If this flag is set whitespace within the regular expression is\
ignored. This provides greater freedom in laying out the regular expression. This is\
especially useful if you are preparing teaching materials or if the regular expression is\
complex or obscure and therefore deserves explication."];
}

proc ExplainCaseSensitiveInitial {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown CaseSensitive] ==1} {return}
    set po [CreateTextDisplay [_ "Case Sensitive"] $HPWidth 4]
    BindKeys $po;
    set PopupList(CaseSensitive) $po;
    AppendToTextDisplay $po [_ "This flag causes matching in the subsequent part of the regular expression to be case sensitive. It is permitted only at the beginning of the regular expression."];
    AppendToTextDisplay $po [_ "It is useful only when the command-line case-insensitive flag is set."]
}

proc ExplainCaseSensitive {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown CaseSensitive] ==1} {return}
    set po [CreateTextDisplay [_ "Case Sensitive"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(CaseSensitive) $po;
    AppendToTextDisplay $po [_ "This flag causes matching in the subsequent part of the regular expression to be case sensitive."];
}

proc ExplainCaseInsensitive {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown CaseInsensitive] ==1} {return}
    set po [CreateTextDisplay [_ "Case Insensitive Comparison"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(CaseInsensitive) $po;
    AppendToTextDisplay $po [_ "A comparison is case-sensitive if two strings\
differing only in the case of one or more characters are considered\
different. If two strings differing only in case are considered the same, the\
comparison is case-insensitive. Case-insensitive matching can always be arranged\
by using disjunctions of upper- and lower-case pairs, e.g. \[Cc\]\[Aa\]\[Tt\], but this is\
tedious, so many matchers provide a flag for requesting case-insensitive matching.\
Matchers that support this notation allow you to set this flag from within the\
regular expression."];
    AppendToTextDisplay $po "\n\n"
    if {(!$::Features(CaseInsensitiveOctal,$::program,$::InterfaceLocale)) && \
	    (!$::Features(CaseInsensitiveHex,$::program,$::InterfaceLocale))} {
	AppendToTextDisplay $po "This flag does not apply to octal or hex escapes.\n\n"
    } elseif {!$::Features(CaseInsensitiveOctal,$::program,$::InterfaceLocale)} {
	AppendToTextDisplay $po "This flag does not apply to octal escapes.\n\n"
    } elseif {!$::Features(CaseInsensitiveHex,$::program,$::InterfaceLocale)} {
	AppendToTextDisplay $po "This flag does not apply to hex escapes.\n\n"
    }
    if {$::Features(CaseInsensitiveFlagWideScope,$::program,$::InterfaceLocale)} {
	AppendToTextDisplay $po "This flag has scope over the entire expression, including anything that precedes it."
    } else {
	AppendToTextDisplay $po "This flag takes effect where it is placed and remains in force until the end of the expression, the end of the group, or a countervailing flag."
    }
    if {!$::Features(CaseInsensitiveNonAsciiLiteral,$::program,$::InterfaceLocale)} {
	AppendToTextDisplay $po "\n\n"
	AppendToTextDisplay $po [_ "This flag affects only the ASCII characters."]
	if {!$::Features(CaseInsensitiveAsciiClass,$::program,$::InterfaceLocale)} {
	    AppendToTextDisplay $po "\n\n"
	    AppendToTextDisplay $po [_ "It has no effect on builtin character classes."]
	} else {
	    if {!$::Features(CaseInsensitiveAsciiClassSymmetric,$::program,$::InterfaceLocale)} {
		AppendToTextDisplay $po "\n\n"
		AppendToTextDisplay $po [_ "It affects builtin character classes asymmetrically."];
		AppendToTextDisplay $po [_ "It makes upper-case characters match \[:lower:\] but it does not make lower-case characters match \[:upper:\]"];
	    }
	}
    } else {
	if {!$::Features(CaseInsensitiveAsciiClass,$::program,$::InterfaceLocale)} {
	    AppendToTextDisplay $po "\n\n"
	    AppendToTextDisplay $po [_ "It has no effect on builtin character classes."];
	} else {
	    if {!$::Features(CaseInsensitiveNonAsciiClass,$::program,$::InterfaceLocale)} {
		AppendToTextDisplay $po "\n\n"
		AppendToTextDisplay $po [_ "It has no effect on builtin character classes outside the ASCII range."];
	    } else {
		if { (!$::Features(CaseInsensitiveAsciiClassSymmetric,$::program,$::InterfaceLocale)) && \
			 (!$::Features(CaseInsensitiveNonAsciiClassSymmetric,$::program,$::InterfaceLocale))} {
		    AppendToTextDisplay $po "\n\n"
		    AppendToTextDisplay $po [_ "It affects builtin character classes asymmetrically."];
		    AppendToTextDisplay $po [_ "It makes upper-case characters match \[:lower:\] but it does not make lower-case characters match \[:upper:\]"];
		} else {
		    if {$::Features(CaseInsensitiveAsciiClassSymmetric,$::program,$::InterfaceLocale)} {
			AppendToTextDisplay $po "\n\n"
			AppendToTextDisplay $po [_ "It affects builtin character classes asymmetrically outside the ASCII range."];
			AppendToTextDisplay $po [_ "It makes upper-case characters match \[:lower:\] but it does not make lower-case characters match \[:upper:\]"];
		    }
		}
	    }
	}
    }
}

proc ExplainCaseInsensitiveIU {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown CaseInsensitiveIU] ==1} {return}
    set po [CreateTextDisplay [_ "Unicode Case Insensitive Comparison"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(CaseInsensitiveIU) $po;
    AppendToTextDisplay $po [_ "A comparison is case-sensitive if two strings\
differing only in the case of one or more characters are considered\
different. If two strings differing only in case are considered the same, the\
comparison is case-insensitive. Case-insensitive matching can always be arranged\
by using disjunctions of upper- and lower-case pairs, e.g. \[Cc\]\[Aa\]\[Tt\], but this is\
tedious, so many matchers provide a flag for requesting case-insensitive matching.\
Matchers that support this notation allow you to set this flag from within the\
regular expression."];
    AppendToTextDisplay $po "\n\n"
    if {$::Features(CaseInsensitiveFlagWideScope,$::program,$::InterfaceLocale)} {
	AppendToTextDisplay $po "This flag has scope over the entire expression, including anything that precedes it."
    } else {
	AppendToTextDisplay $po "This flag takes effect where it is placed and remains in force until the end of the expression, the end of the group, or a countervailing flag."
    }
    if {!$::Features(CaseInsensitiveuNonAsciiLiteral,$::program,$::InterfaceLocale)} {
	AppendToTextDisplay $po "\n\n"
	AppendToTextDisplay $po [_ "This flag affects only the ASCII characters."]
	if {!$::Features(CaseInsensitiveAsciiClass,$::program,$::InterfaceLocale)} {
	    AppendToTextDisplay $po "\n\n"
	    AppendToTextDisplay $po [_ "It has no effect on builtin character classes."]
	} else {
	    if {!$::Features(CaseInsensitiveAsciiClassSymmetric,$::program,$::InterfaceLocale)} {
		AppendToTextDisplay $po "\n\n"
		AppendToTextDisplay $po [_ "It affects builtin character classes asymmetrically."];
		AppendToTextDisplay $po [_ "It makes upper-case characters match \[:lower:\] but it does not make lower-case characters match \[:upper:\]"];
	    }
	}
    } else {
	if {!$::Features(CaseInsensitiveAsciiClass,$::program,$::InterfaceLocale)} {
	    AppendToTextDisplay $po "\n\n"
	    AppendToTextDisplay $po [_ "It has no effect on builtin character classes."];
	} else {
	    if {!$::Features(CaseInsensitiveuNonAsciiClass,$::program,$::InterfaceLocale)} {
		AppendToTextDisplay $po "\n\n"
		AppendToTextDisplay $po [_ "It has no effect on builtin character classes outside the ASCII range."];
	    } else {
		if { (!$::Features(CaseInsensitiveAsciiClassSymmetric,$::program,$::InterfaceLocale)) && \
			 (!$::Features(CaseInsensitiveuNonAsciiClassSymmetric,$::program,$::InterfaceLocale))} {
		    AppendToTextDisplay $po "\n\n"
		    AppendToTextDisplay $po [_ "It affects builtin character classes asymmetrically."];
		    AppendToTextDisplay $po [_ "It makes upper-case characters match \[:lower:\] but it does not make lower-case characters match \[:upper:\]"];
		} else {
		    if {$::Features(CaseInsensitiveAsciiClassSymmetric,$::program,$::InterfaceLocale)} {
			AppendToTextDisplay $po "\n\n"
			AppendToTextDisplay $po [_ "It affects builtin character classes asymmetrically outside the ASCII range."];
			AppendToTextDisplay $po [_ "It makes upper-case characters match \[:lower:\] but it does not make lower-case characters match \[:upper:\]"];
		    }
		}
	    }
	}
    }
}

proc ExplainVisible {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Visible] ==1} {return}
    set po [CreateTextDisplay [_ "Visible ASCII Characters - Graph and Print"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Visible) $po;
    AppendToTextDisplay $po [_ "\
The POSIX standard defines two similar classes of \`visible\' chracters.\
The category \`graph\' may be defined as the set of characters that leave\
ink on the page. Within the ASCII character set, this means the classes\
\`alpha\', \`digit\', and \`punct\'. It does not include the space character.\
The complement of this class therefore consists of the control characters\
and the space character."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "\
The category \`print\' consists of all characters other than the control\
characters. In ASCII, this means that the only difference between \`graph\'\
and \`print\' is that the latter includes the space character."]
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "Some documentation, both printed and on the web,\
incorrectly describes\`graph\' and \`print\' as identical. They are not."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainIntersection {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Intersection] ==1} {return}
    set po [CreateTextDisplay [_ "Intersection"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Intersection) $po;
    AppendToTextDisplay $po [_ "\
This notation represents the intersection of two character classes, that is,\
the characters that belong to both classes.\
This is a recent innovation that most matchers do not provide."]
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "Note that Redet provides a facility for intersecting\
user-defined character classes\
that does not depend on the ability of the regular expression matcher to\
do so."];
}


proc ExplainInsertPostMatch {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown InsertPostMatch] ==1} {return}
    set po [CreateTextDisplay [_ "Insert the Portion Following the Match"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(InsertPostMatch) $po;
    AppendToTextDisplay $po [_ "In matchers that treat a string as matching a\
regular expression if some substring\
matches, the match may be regarded as splitting the string into three parts: the\
substring that actually matched, the part of the string preceding the substring\
that matched, and the part of the string following the substring that matched.\
For example, if the regular expression is \`ment\' and the input string is\
\`segmentally\', the substring that actually matches is \`ment\', the\
prefix is \`seg\', and the suffix is \`ally\'.\
This notation stands for the suffix to the matching substring."];
}

proc ExplainInsertPreMatch {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown InsertPreMatch] ==1} {return}
    set po [CreateTextDisplay [_ "Insert the Portion Preceding the Match"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(InsertPreMatch) $po;
    AppendToTextDisplay $po [_ "In matchers that treat a string as matching a\
regular expression if some substring\
matches, the match may be regarded as splitting the string into three parts: the\
substring that actually matched, the part of the string preceding the substring\
that matched, and the part of the string following the substring that matched.\
For example, if the regular expression is \`ment\' and the input string is\
\`segmentally\', the substring that actually matches is \`ment\', the\
prefix is \`seg\', and the suffix is \`ally\'.\
This notation stands for the prefix to the matching substring."];
}

proc ExplainInsertEntireMatch {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown InsertEntireMatch] ==1} {return}
    set po [CreateTextDisplay [_ "Insert Entire Match"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(InsertEntireMatch) $po;
    AppendToTextDisplay $po [_ "This notation inserts into the substitution\
a copy of the entire match to the\
regular expression. It is useful when the purpose of the operation is not\
to change the matched text but to add to it in a conditional way.\
For example, if we wanted to make a list of all of the stems that occur\
with the prefix \`pre\' and the suffix \`al\' we might (using Perl notation)\
use the regular expression \`^(pre)(.*)(al)\$\' and the substitution\
expression \`\$2\\t$&\', which inserts a copy of the second captured group,\
a tab, and a copy of the entire match. The result would be two columns, first the stem,\
then the entire word."];
    AppendToTextDisplay $po [_ "For further information on substitution backreferences see: \n"]
    AppendLinkToTextDisplay $po [_ "Substitution Backreferences."] {ExplainBackReferenceSub};
}

proc ExplainUpperCaseASCIILetter {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown UpperCaseASCIILetter] ==1} {return}
    set po [CreateTextDisplay [_ "Upper Case ASCII Letter"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(UpperCaseASCIILetter) $po;
    AppendToTextDisplay $po [_ "The class of upper case ASCII letters consists of the \
26 letters: A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z"];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainUpperCaseLetter {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown UpperCaseLetter] ==1} {return}
    set po [CreateTextDisplay [_ "Upper Case Letter"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(UpperCaseLetter) $po;
    AppendToTextDisplay $po [_ "The class of upper case letters, including not only the \
ASCII letters A, B, C, etc. but upper-case letters in other writing systems that have \
a case distinction, such as Armenian, Cyrillic, and Greek."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainLowerCaseASCIILetter {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown LowerCaseASCIILetter] ==1} {return}
    set po [CreateTextDisplay [_ "Lower Case ASCII Letter"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(LowerCaseASCIILetter) $po;
    AppendToTextDisplay $po [_ "The class of lower case ASCII letters consists of the \
26: letters a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z"];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainLowerCaseLetter {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown LowerCaseLetter] ==1} {return}
    set po [CreateTextDisplay [_ "Lower Case Letter"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(LowerCaseLetter) $po;
    AppendToTextDisplay $po [_ "The class of lower case letters, including not only the \
ASCII letters a, b, c, etc. but lower-case letters in other writing systems that have \
a case distinction, such as Armenian, Cyrillic, and Greek."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "For details on the POSIX character classes, including\
an ASCII chart color-coded for the POSIX classes, see the reference manual section "];
    set url [PathToFileURL [file join $::ManualDirectory builtincharclass.html]]
    AppendLinkToTextDisplay $po "Builtin Character Classes" [list ShowWebPage $url]
    AppendToTextDisplay $po ".\n"
}

proc ExplainMustPair {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown MustPair] ==1} {return}
    set po [CreateTextDisplay [_ "Paired Character Sets"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(MustPair) $po;
    AppendToTextDisplay $po [_ {Certain character sets cannot stand alone but must be
used in pairs, one set being mapped to the other set.\
For example, the tr command: "tr '[:upper:]' ' [:lower:]'"
is a valid command that converts upper case letters to lower case, but the\
command "tr '[:upper:]' X", intended to replace all upper case letters with the\
letter 'X', is not. (This can be accomplished by listing the characters in the\
first set explicitly: "tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'X'".)}];
    AppendToTextDisplay $po "\n\n"
AppendToTextDisplay $po [_ {This restriction applies only to mappings between\
two sets of characters. The command "tr -d [:upper:]]" is a valid command which\
strips upper case letters from its input.}];
    AppendToTextDisplay $po "\n"
}

proc ExplainXYpair {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown XYpair] ==1} {return}
    set po [CreateTextDisplay [_ "Balanced Delimiters"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(XYpair) $po;
    AppendToTextDisplay $po [_ "This construction is intended for matching strings\
surrounded by balanced delimiters. The expression \`%b()\', for example, will\
a string surrounded by parentheses, such as \`(abc)\'"];
}

proc ExplainClassComplement {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ClassComplement] ==1} {return}
    set po [CreateTextDisplay [_ "Complements of Named Classes"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ClassComplement) $po;
    AppendToTextDisplay $po [_ "This notation denotes the complement of a named
character class, that is, the set of characters that do not belong to it. For example,
if the class is \`\[:lower:\]\', the set of lower-case letters, its complement
consists of all characters that are not lower-case letters, including upper-case
letters, digits, punctuation, and control characters."];
}

proc ExplainUnicodeCase {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown UnicodeCase] ==1} {return}
    set po [CreateTextDisplay [_ "Unicode Case Flag"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(UnicodeCase) $po;
    AppendToTextDisplay $po [_ "This flag makes matches case-insensitive for all
Unicode characters. It must be used in conjunction with the basic case-insensitive
flag, which by itself affects only the ASCII letters."];
}

proc ExplainZeroOneQMark {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ZeroOneQMark] ==1} {return}
    set po [CreateTextDisplay [_ "Optional Quantifier"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ZeroOneQMark) $po;
    AppendToTextDisplay $po [_ "This quantifier indicates that the preceding group\
may be either present or absent. In other words, it says that a matching string will contain\
either zero or one token of the group."];
}

proc ExplainBeginningOfString {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown BeginningOfString] ==1} {return}
    set po [CreateTextDisplay [_ "Beginning of String"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(BeginningOfString) $po;
    AppendToTextDisplay $po [_ "This matches at the beginning of the string."];
}

proc ExplainBeginningOfWord {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown BeginningOfWord] ==1} {return}
    set po [CreateTextDisplay [_ "Beginning of Word"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(BeginningOfWord) $po;
    AppendToTextDisplay $po [_ "This matches at the beginning of a word.\
A word is considered to begin at the transition from a non-word character\
to a word character, where a word character is an alphanumeric character or\
underscore."];
}

proc ExplainEndOfWord {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown EndOfWord] ==1} {return}
    set po [CreateTextDisplay [_ "End of Word"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(EndOfWord) $po;
    AppendToTextDisplay $po [_ "This matches at the end of a word.\
A word is considered to end at the transition from a word character\
to a non-word character, where a word character is an alphanumeric character or\
underscore."];
}


proc ExplainWordBoundary {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown WordBoundary] ==1} {return}
    set po [CreateTextDisplay [_ "Word Boundary"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(WordBoundary) $po;
    AppendToTextDisplay $po [_ "This matches at a word boundary, where a word\
boundary is considered to occur between any two adjacent characters of which\
one is a word character and the other is a non-word character."];
}

proc ExplainNonWordBoundary {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown NonWordBoundary] ==1} {return}
    set po [CreateTextDisplay [_ "NonWordBoundary"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(NonWordBoundary) $po;
    AppendToTextDisplay $po [_ "This matches anywhere that is not word boundary, where a word\
boundary is considered to occur between any two adjacent characters of which\
one is a word character and the other is a non-word character. In other words, it\
matches if both characters are word characters or both are non-word characters."];
}

proc ExplainSet {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Set] ==1} {return}
    set po [CreateTextDisplay [_ "Set"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Set) $po;
    AppendToTextDisplay $po [_ "This matches any of the characters in the set."];
}

proc ExplainSetComplement {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown SetComplement] ==1} {return}
    set po [CreateTextDisplay [_ "SetComplement"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(SetComplement) $po;
    AppendToTextDisplay $po [_ "This matches the complement of the characters in the set,\
that is, any character that is not a member of the set. If you want to include circumflex\
in the set, just put it somewhere other than first; it denotes the complement only\
when it immediately follows the left square bracket."];
}

proc ExplainRange {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown Range] ==1} {return}
    set po [CreateTextDisplay [_ "Character Ranges"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(Range) $po;
    AppendToTextDisplay $po [_ "This denotes the range of characters from a through d inclusive.\
Traditionally, the characters between the endpoints are those whose codes fall\
numerically between those of the endponts. For exmaple, in ASCII the range \[g-k\] consists\
of g, h, i, j, and k."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "In the locale system, the meaning of a range depends on the\
collating order (sort order) defined for the locale, which may not be the same as the\
numerical order of codepoints. If you are writing code that may be used in a variety\
of locales, it is best to avoid the use of ranges. They can always be replaced by explicit\
lists."];
   if { $::Features(unicodebmp,$::program,$::InterfaceLocale) && \
	 (!$::Features(CrossUnicodeBlockP,$::program,$::InterfaceLocale))} {
    	AppendToTextDisplay $po [_ "\n\nCharacter ranges may not cross Unicode block boundaries."];
   }   
   if {$::Features(Range128,$::program,$::InterfaceLocale) \
	&& (!$::Features(Range129,$::program,$::InterfaceLocale))} {
       AppendToTextDisplay $po [_ "\n\nRanges may span no more than 128 codepoints."]
   }
}

proc ExplainMultiRange {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown MultiRange] ==1} {return}
    set po [CreateTextDisplay [_ "Multiple Character Ranges"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(MultiRange) $po;
    AppendToTextDisplay $po [_ "Multiple ranges may be included in the same character set. Each hyphen defines a range\
consisting of the the characters on either side of it. Any characters not adjacent to hyphens are individual\
members of the set. Thus, \[a-dw-z\] is the union of the ranges \[a-d\] and \[w-z\], in the C locale therefore\
a,b,c,d,w,x,y, and z. \[a-dsw-z\] is the union of the ranges \[a-d\] and \[w-z\] plus the letter \`s\', which is to\
say, the letters: a,b,c,d,s,w,x,y, and z."];
}

proc ExplainTRStar {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown TRStar] ==1} {return}
    set po [CreateTextDisplay [_ "TR Star"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(TRStar) $po;
    AppendToTextDisplay $po [_ "Insert into the target character list as many copies of the\
specified character as are necessary to make the target list as long as the source list.\
For example, if the source list is \`aeioubcdfghklmnpqrstvwxyz\' and you want to map the vowels\
onto themselves and the consonants onto X, the second list could be written\
\`aeiouX*\'."];
}

proc ExplainTRStarN {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown TRStarN] ==1} {return}
    set po [CreateTextDisplay [_ "TR Star N"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(TRStarN) $po;
    AppendToTextDisplay $po [_ "This is shorthand for N copies of a character. If N begins\
with a 0, it is taken to be in octal."];
}

proc ExplainInsertLiteralString {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown InsertLiteralString] ==1} {return}
    set po [CreateTextDisplay [_ "Insert Literal String"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(InsertLiteralString) $po;
    AppendToTextDisplay $po [_ "In a substitution, insert the string between quotes."];
}


proc ExplainPositiveForwardAssertion {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown PositiveForwardAssertion] ==1} {return}
    set po [CreateTextDisplay [_ "Positive Forward Assertion"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(PositiveForwardAssertion) $po;
    AppendToTextDisplay $po [_ "A positive forward assertion requires that the string\
match the pattern in the assertion but does not consume the characters that match."];
}

proc ExplainPositiveBackwardAssertion {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown PositiveBackwardAssertion] ==1} {return}
    set po [CreateTextDisplay [_ "Positive Backward Assertion"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(PositiveBackwardAssertion) $po;
    AppendToTextDisplay $po [_ "A positive backward assertion checks whether the
pattern in the assertion matches the string preceding the current candidate."];
}

proc ExplainNegativeForwardAssertion {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown NegativeForwardAssertion] ==1} {return}
    set po [CreateTextDisplay [_ "Negative Forward Assertion"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(NegativeForwardAssertion) $po;
    AppendToTextDisplay $po [_ "A negative forward assertion requires that the string\
not match the pattern in the asertion. It does not consume any characters."];
}

proc ExplainNegativeBackwardAssertion {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown NegativeBackwardAssertion] ==1} {return}
    set po [CreateTextDisplay [_ "Negative Backward Assertion"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(NegativeBackwardAssertion) $po;
    AppendToTextDisplay $po [_ "A negative backward assertion checks to see that the\
pattern in the assertion does not match the string preceding the current candidate."];
}

proc ExplainSelfishNoCaptureGroup {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown SelfishNoCaptureGroup] ==1} {return}
    set po [CreateTextDisplay [_ "Selfish No Capture Group"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(SelfishNoCaptureGroup) $po;
    AppendToTextDisplay $po [_ "A selfish no capture group is a no capture group\
(one that does not count for purposes of backreference) that matches without regard\
to whether the rest of the regular expression can be matched. It may absorb characters\
needed by other parts of the regular expression. An ordinary group (capture or no capture)\
will relinquish matching characters if other parts of the regular expression are\
unable to match without them."];
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "For example, consider the expression \`(?>a+)a\'.
This consists of a selfish no capture group matching one or more tokens of \`a\'
followed by a single \`a\'. In order for the regular expression to match, the final\
\`a\' must match. This can never happen because the \`a+\' will absorb all of the\
\`a\'s."];
}

proc ExplainSimpleGroupConditional {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown SimpleGroupConditional] ==1} {return}
    set po [CreateTextDisplay [_ "Simple Backreference Group Conditional"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(SimpleGroupConditional) $po;
    AppendToTextDisplay $po [_ "A conditional regular expression is one in which\
whether one portion of the regular expression must match the target depends on\
whether another portion of\
the regular expression matches. Conditional regular expressions vary on two\
main dimensions: (a) what sort of condition they use; (b) whether or not\
they have an \`else\' clause."];
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "This is the simplest type of conditional regular\
expression. The condition is whether or not a specified capture group matched.\
In the schema shown on the palette, k is the index of the group and x is the\
regular expression that must be matched if the specified group matched. For\
example, suppose that the entire regular expression is: \`(<)(.+)(?(1)>) \'.\
This consists of three parts: a capture group consisting of just a left\
angle bracket, another capture group consisting of \`.+\/, and a conditional\
expression. The conditional consists of a condition,\
namely that the first capture group match, and a regular expression, which in this\
case is the single character right angle bracket. This regular expression matches\
any non-null string that is either bare or enclosed by a balanced pair of\
angle brackets. No angle brackets are required, but if there is a left,\
angle bracket there must also be a right angle bracket."];
}

proc ExplainElseGroupConditional {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ElseGroupConditional] ==1} {return}
    set po [CreateTextDisplay [_ "Group Backreference Conditional With Else Clause"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ElseGroupConditional) $po;
    AppendToTextDisplay $po [_ "A conditional regular expression is one in which\
whether one portion of the regular expression must match the target depends on\
whether another portion of\
the regular expression matches. Conditional regular expressions vary on two\
main dimensions: (a) what sort of condition they use; (b) whether or not\
they have an \`else\' clause."];
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "This schema represents the type of condition\
in which the condition is whether or not a specified capture group matched\
and in which there is an else clause.\
In the schema shown on the palette, k is the index of the group, x is the\
regular expression that must be matched if the specified group matched, and\
y is the regular expression that must be matched if the group does not match.\
For example, suppose that the entire regular expression is: \`(<)(.+)(?(1)>|\[^>\])\'.\
(Depending on the language you are using and how you are entering the regular\
expression, additional quoting may be necessary.)\
This consists of three parts: a capture group consisting of just a left\
angle bracket, another capture group consisting of \`.+\/, and a conditional\
expression. The conditional consists of a condition,\
namely that the first capture group match, and two regular expressions separated\
by a pipe symbol. The first regular expression in the conditional\
is the single character right angle bracket. The second regular expression in the\
conditional is the set of characters other than right angle bracket.\
This regular expression matches\ any non-null string that is either bare or enclosed by\
a balanced pair of angle brackets. No angle brackets are required, but if there\
is a left angle bracket, there must also be a right angle bracket.\
The else clause requires that the string\
not end in a right angle bracket if it does not begin with left angle bracket"];
}


proc ExplainSimpleLookaroundConditional {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown SimpleLookaroundConditional] ==1} {return}
    set po [CreateTextDisplay [_ "SimpleLookaroundConditional"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(SimpleLookaroundConditional) $po;
    AppendToTextDisplay $po [_ "A conditional regular expression is one in which\
whether one portion of the regular expression must match the target depends on\
whether another portion of\
the regular expression matches. Conditional regular expressions vary on two\
main dimensions: (a) what sort of condition they use; (b) whether or not\
they have an \`else\' clause."];
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "This schema shown is for the case in which the\
condition is an assertion and there is no else clause. The condition may consist\
of any of the four types of assertion: positive forward, negative forward, positive backward,\
and negative backward. The general form is: \`(?(assertion)re) \', where \'re\' is\
the regular expression that must be matched if the assertion is true. The assertion\
will take the form \`?=y\', \`?<=y\', \`?!y\',\`?<!y\' where \`y\' is a regular\
expression and the preceding characters indicate which kind of assertion it is,\
just as they do elsewhere."];
}

proc ExplainElseLookaroundConditional {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ElseLookaroundConditional] ==1} {return}
    set po [CreateTextDisplay [_ "ElseLookaroundConditional"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ElseLookaroundConditional) $po;
    AppendToTextDisplay $po [_ "A conditional regular expression is one in which\
whether one portion of the regular expression must match the target depends on\
whether another portion of\
the regular expression matches. Conditional regular expressions vary on two\
main dimensions: (a) what sort of condition they use; (b) whether or not\
they have an \`else\' clause."];
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po [_ "This schema shown is for the case in which the\
condition is an assertion and there is an else clause. The condition may consist\
of any of the four types of assertion: positive forward, negative forward, positive bachkward,\
and negative backward. The general form is: \`(?(assertion)re1|re2) \', where \'re1\' is\
the regular expression that must be matched if the assertion is true and re2 is\
the regular expression that must be matched if the assertion is false. The assertion\
will take the form \`?=y\', \`?<=y\', \`?!y\',\`?<!y\' where \`y\' is a regular\
expression and the preceding characters indicate which kind of assertion it is,\
just as they do elsewhere. "];
}

proc ExplainInsertLastGroup {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown InsertLastGroup] ==1} {return}
    set po [CreateTextDisplay [_ "Insert Last Captured Group"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(InsertLastGroup) $po;
    AppendToTextDisplay $po [_ "In a substitution expression, this inserts the last\
captured group from the regular expression. For example,\
if the regular expression is \`(a.*)(b.*)(c.*)\', whatever \`c.*\' matched will be inserted.\
If the regular expression is \`(a.*)(b.*)\', whatever \`b.*\' matched will be inserted."];
}

proc ExplainUnsetFlag {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown UnsetFlag] ==1} {return}
    set po [CreateTextDisplay [_ "Inline Unset Flag"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(UnsetFlag) $po;
    AppendToTextDisplay $po [_ "Where f is an inline flag,  this unsets it. For example,\
where\`?i\' sets the case-insensitive flag, \`?-i\' unsets it, making subsequent\
matches case-sensitive. It overrides any previous in-line setting of the flag as well as\
a setting from the command-line or in the argument to a function or method."];
    AppendToTextDisplay $po "\n\n"
    AppendToTextDisplay $po [_ "For further information on case-sensitivity, see: \n"]
    AppendLinkToTextDisplay $po "Case Sensitivity" {ExplainCaseInsensitive};
}

proc ExplainStarClass {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown StarClass] ==1} {return}
    set po [CreateTextDisplay [_ "Class Star"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(StarClass) $po;
    AppendToTextDisplay $po [_ "This quantifier matches zero or more tokens belonging\
to the preceding character class. For example, \`%d*\' matches a sequence of any number\
of digits."];
}

proc ExplainPlusClass {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown PlusClass] ==1} {return}
    set po [CreateTextDisplay [_ "Class Plus"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(PlusClass) $po;
    AppendToTextDisplay $po [_ "This quantifier matches one or more tokens belonging\
to the preceding character class. For example, \`%d+\' matches a sequence of one or\
more digits."];
}

proc ExplainZeroOneQMarkClass {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown QMarkClass] ==1} {return}
    set po [CreateTextDisplay [_ "Question Mark Class"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(QMarkClass) $po;
    AppendToTextDisplay $po [_ "This quantifier matches zero or one token of the\
preceding character class. For example, \`%d%d?\' matches either one or two digits."];
}

proc ExplainHyphenClass {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown HyphenClass] ==1} {return}
    set po [CreateTextDisplay [_ "Hyphen Class"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(HyphenClass) $po;
    AppendToTextDisplay $po [_ "This quantifier matches zero or more tokens belonging\
to the preceding character class. For example, \`%d-\' matches a sequence of any number\
of digits. However, unlike other similar quantifiers, it is a reluctant\
quantifier. For example, if the expression \`(a)(%u-)(%u*)(a)\' is matched against\
the string \`aBBBBa\', the third group will match \`BBBB\'. The second group\
contains nothing because the quantifier matches as little as it has to, and\
the subexpression \`(%u-)\'is satisfied with a match of the empty string."];
}

proc ExplainCollationClass {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown CollationClass] ==1} {return}
    set po [CreateTextDisplay [_ "CollationClass"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(CollationClass) $po;
    AppendToTextDisplay $po [_ "A collation class is the set of characters that are assigned the same sort rank. For example, in languages in which vowels occur with a variety of accents or with no accent, as a primary sort key all versions of the same vowel are usually assigned the same sort rank, so that, for example, e, \u00E8, and \u00E9 will be treated the same. In a regular expression, a collation class matches any member of the class. A collation class is specified by listing any of its members."];
}


proc ExplainCollatingElementNamed {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ExplainCollatingElementNamed] ==1} {return}
    set po [CreateTextDisplay [_ "Named Collating Element"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ExplainCollatingElementNamed) $po;
    AppendToTextDisplay $po [_ "A named collating element is a symbolic name for a collating element, which may consist of a single character or may itself be a multicharacter collating element. See section 2.2.2.33 of POSIX ISO/IEC 9945-2:1993."];
}

proc ExplainCollatingElementMultichar {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ExplainCollatingElementMultichar] ==1} {return}
    set po [CreateTextDisplay [_ "Multicharacter Collating Element"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ExplainCollatingElementMultichar) $po;
    AppendToTextDisplay $po [_ "A multicharacter collating element is a sequence of characters that are treated as a single unit for purposes of sorting. For example, in Spanish the sequence ch is conventionally treated as a single letter which follows c and precedes d. In a regular expression a multicharacter collating element is treated as a single character when counting letters. For example, if ch is defined as a collating element, the regular expression [[.ch.]]*c matches the string chchc. See section 2.2.2.33 of POSIX ISO/IEC 9945-2:1993."];
}

proc ExplainIntegerRange {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown IntegerRange] ==1} {return}
    set po [CreateTextDisplay [_ "Integer Range"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(IntegerRange) $po;
    AppendToTextDisplay $po [_ "This expression matches any integer k such that m \u2264 k \u2264 n where m and n are non-negative integers and m \u2264 n. Note that this notation conflicts with our notation for intersection of named user-defined character classes. In order to make use integer ranges you will need to disable  named user-defined character classes from Tools:Classes."];
}

proc ExplainIntegerRangeDoubleDot {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown IntegerRange] ==1} {return}
    set po [CreateTextDisplay [_ "Integer Range"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(IntegerRange) $po;
    AppendToTextDisplay $po [_ "This expression matches any integer k such that m \u2264 k \u2264 n where m and n are non-negative integers and m \u2264 n."];
}

proc ExplainIntegerMultiple {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown IntegerMultiple] ==1} {return}
    set po [CreateTextDisplay [_ "Integer Multiple"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(IntegerMultiple) $po;
    AppendToTextDisplay $po [_ "The expression mp, where p is a positive integer, matches any positive integer that is an integral multiples of p, that is, any integer k > 0 such that k = jp for some integer j. For example, m3 matches any multiple of 3, e.g. 3,6,9, and 12."];
}

proc ExplainIntegerFactor {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown IntegerFactor] ==1} {return}
    set po [CreateTextDisplay [_ "Integer Factor"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(IntegerFactor) $po;
    AppendToTextDisplay $po [_ "The expression fp, where p is a positive integer, matches any positive integer that is a factor of p, that is, any integer k > 0 such that kj = p for some positive integer j. For example, f12 matches 1,2,3,4,6, and 12."];
}

proc ExplainVerboseFlag {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown VerboseFlag] ==1} {return}
    set po [CreateTextDisplay [_ "Verbose Flag"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(VerboseFlag) $po;
    AppendToTextDisplay $po [_ "If this flag is set, whitespace within the regular expression is ignored except within character classes and when preceded by an unescaped backslash, and crosshatch is interpreted as a comment character, so that the crosshatch and everything following it on the same line are ignored."];
}

proc ExplainLiteralFlag {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown LiteralFlag] ==1} {return}
    set po [CreateTextDisplay [_ "Literal Flag"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(LiteralFlag) $po;
    AppendToTextDisplay $po [_ "The literal flag indicates that everything following it is to be treated as a literal string: nothing is to be interpreted as a metacharacter. For example, (?l)*** matches a string of three asterisks."];
}

proc ExplainBasicFlag {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown BasicFlag] ==1} {return}
    set po [CreateTextDisplay [_ "Basic Flag"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(BasicFlag) $po;
    AppendToTextDisplay $po [_ "The basic flag indicates that everything following is to be interpreted as a basic regular expression. Extended regular expression notation is not to be recognized."];
}

proc ExplainExtendedFlag {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ExtendedFlag] ==1} {return}
    set po [CreateTextDisplay [_ "Extended Flag"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ExtendedFlag) $po;
    AppendToTextDisplay $po [_ "The extended flag indicates that everything following is to be interpreted as an extended regular expression."]
}

proc ExplainTotalErrorCrosshatchA {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown TotalErrorCrosshatchA] ==1} {return}
    set po [CreateTextDisplay [_ "Error Limit"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(TotalErrorCrosshatchA) $po;
    AppendToTextDisplay $po [_ "This flag sets the  total number of deviations from an exact match to N, which must be a non-negative integer. The setting applies to the remainder of the current group. For example, ((\#a0)ab)((\#a1)cd)((\#a0)ef) matches abcdef,abcef,abdef,abdcef,abczef,and abzdef but not acdef,abcde,kbcdef,akcdef,abcdeg, or abcdkf. The groups ab and ef must be matched exactly; it is only the group cd which need not match exactly."];
}

proc ExplainAsymmetricCaseInsensitive {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown AsymmetricCaseInsensitive] ==1} {return}
    set po [CreateTextDisplay [_ "Asymmetric Case Insensitive"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(AsymmetricCaseInsensitive) $po;
    AppendToTextDisplay $po [_ "This flag causes lower-case letters in the subsequent portion of the pattern to match without regard to case. Upper-case letters in the pattern match only upper-case letters."];
}

proc ExplainJResidueHydrophobic {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown JResidueHydrophobic] ==1} {return}
    set po [CreateTextDisplay [_ "Hydrophobic Residues"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(JResidueHydrophobic) $po;
    AppendToTextDisplay $po [_ "This matches any of the hydrophobic residues:
Alanine (A)
Cysteine (C)
Glycine (G)
Isoleucine (I)
Leucine (L)
Methionine (M)
Phenylalanine (F)
Tryptphan (W)
Tyrosine (Y)
Valine (V)"];
}

proc ExplainOResidueHydrophilic {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown OResidueHydrophilic] ==1} {return}
    set po [CreateTextDisplay [_ "Hydrophilic Residues"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(OResidueHydrophilic) $po;
    AppendToTextDisplay $po [_ "This matches any of the hydrophilic residues:
Arginine (R)
Asparagine (N)
Aspartate (D)
Glutamate (E)
Glutamine (Q)
Histidine (H)
Lysine (K)
Serine (S)
Threonine (T)"];
}

proc ExplainPerlPrint {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown PerlPrint] ==1} {return}
    set po [CreateTextDisplay [_ "Perl Print"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(PerlPrint) $po;
    AppendToTextDisplay $po [_ "This character class consists of the alphanumeric characters, the punctuation, and all of the characters in the \[:space:\] class, namely U+0020 SPACE, U+0009 TAB, U+000B VERTICAL TAB, U+000C FORM FEED, U+000A NEWLINE, and U+000D CARRIAGE RETURN."];
    AppendToTextDisplay $po [_ "It differs from the standard POSIX \[:print:\] class in including the \[:space:\] characters other than SPACE. In short, POSIX \[:print:\] = \[:graph:\] \u222A Space; Perl \[:print:\] = \[:graph:\] \u222A \[:space:\]."];
}

proc ExplainMockPrint {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown MockPrint] ==1} {return}
    set po [CreateTextDisplay [_ "Print"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(MockPrint) $po;
    AppendToTextDisplay $po [_ "This class consists of the alpha characters and digits and so is the same as \[:alnum:\]. This definition is idiosyncratic: the POSIX \[:print:\] class is the union of \[:alpha:\], \[:digit:\], \[:punct:\], and space."];
}

proc ExplainIgnoreCombiningCharacters {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown IgnoreCombiningCharacters] ==1} {return}
    set po [CreateTextDisplay [_ "Ignore Combining Characters"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(IgnoreCombiningCharacters) $po;
    AppendToTextDisplay $po [_ "Combining characters are characters like accents that do not normally stand on their own but are intended to be combined with other characters."];
    AppendToTextDisplay $po [_ "This flag causes combining characters to be ignored, which has the approximate effect of treating characters with diacritics the same as the corresponding character without any diacritic."];
    AppendToTextDisplay $po [_ "If, however, the text contains characters that intrinsically combine a base character and a diacritic, ignoring combining characters will not have the effect of equating characters with diacritics with their base character."];
    AppendToTextDisplay $po [_ "For example, in Unicode a lower case e with acute accent (\u00e9) may be encoded either as a single character U+00E9 or as a sequence of two characters, a plain e U+0065 and an acute accent U+0301. If the latter encoding is used, ignoring combining characters will have the effect of equating e with \u00e9, but if the former encoding is used, it will not."]
}

proc ExplainZeroOneEqual {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ZeroOneEqual] ==1} {return}
    set po [CreateTextDisplay [_ "Zero or One"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ZeroOneEqual) $po;
    AppendToTextDisplay $po[_ "This expression matches zero or one occurences of the parenthesized group."];
}

proc ExplainEndCaseDomain {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown EndCaseDomain] ==1} {return}
    set po [CreateTextDisplay [_ "End Case Domain"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(EndCaseDomain) $po;
    AppendToTextDisplay $po [_ "This flag terminates the effect of a preceding case-setting flag. "];
    AppendToTextDisplay $po [_ "For example, if the regular expression is \'^\\(.\\)\\(.*\\)\\(.\\)$\' (where backslashed parentheses are metacharacters delimiting capture groups) and the substitution expression is \'\\1\\U\\2\E\\3\' (where \\E is the end case domain flag), the result of the substitution is the input with every character of each line except for the first and the last made upper-case. The regular expression matches any string containing at least two characters and creates three groups, one consisting of the first character, one consisting of the last character, the third consisting of any intervening characters. The substitution copies the first and last characters with their case unchanged, but the case of the remainder is set to upper by the \'\\U\' flag. The \'\\E\' flag prevents the upcase string flag from affecting the last group."]
}

proc ExplainQuoteFollowingMetachars {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown QuoteFollowingMetachars] ==1} {return}
    set po [CreateTextDisplay [_ "Quote Following Metacharacters"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(QuoteFollowingMetachars) $po;
    AppendToTextDisplay $po [_ "This flag causes subsequent characters in the pattern to be treated literally even if they would normally be metacharacters."];
    AppendToTextDisplay $po [_ "For example, in a matcher that treats a period as a metacharacter matching any single character, the pattern \'...\' will match any three characters."]
AppendToTextDisplay $po [_ "However, if this flag precedes the pattern, it will only match the sequence \'...\'."]
}

proc ExplainDowncaseCharacter {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown DowncaseFollowingCharacter] ==1} {return}
    set po [CreateTextDisplay [_ "Downcase Following Character"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(DowncaseFollowingCharacter) $po;
    AppendToTextDisplay $po [_ "In a substitution this flag makes the case of the following character lower case if it has a lower-case counterpart."];
    AppendToTextDisplay $po [_ "For example, if the regular expression is \'^\\(.*\\)$\' (where backslashed parentheses are metacharacters delimiting capture groups) and the substitution expression is \'\\l\\1\', the result of the substitution is the input with the first character of each line made lower-case. The regular expression matches any string and creates a single group, which is copied in the substitution. The \'\\l\' flag causes the first character of the substitution to be lower-case."]
}

proc ExplainUpcaseCharacter {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown UpcaseFollowingCharacter] ==1} {return}
    set po [CreateTextDisplay [_ "Upcase Following Character"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(UpcaseFollowingCharacter) $po;
    AppendToTextDisplay $po [_ "In a substitution this flag makes the case of the following character upper case if it has an upper-case counterpart."];
    AppendToTextDisplay $po [_ "For example, if the regular expression is \'^\\(.*\\)$\' (where backslashed parentheses are metacharacters delimiting capture groups) and the substitution expression is \'\\u\\1\', the result of the substitution is the input with the first character of each line made upper-case. The regular expression matches any string and creates a single group, which is copied in the substitution. The \'\\u\' flag causes the first character of the substitution to be upper-case."]
}

proc ExplainUpcaseString {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown UpcaseFollowingString] ==1} {return}
    set po [CreateTextDisplay [_ "Upcase Following String"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(UpcaseFollowingString) $po;
    AppendToTextDisplay $po [_ "In a substitution this flag makes the case of the following string upper case where the characters have upper-case counterparts."];
    AppendToTextDisplay $po [_ "For example, if the regular expression is \'^\\(.\\)\\(.*\\)$\' (where backslashed parentheses are metacharacters delimiting capture groups) and the substitution expression is \'\\1\\U\\2\', the result of the substitution is the input with every character of each line except for the first made upper-case. The regular expression matches any string containing at least one character and creates two groups, one consisting of the first character, the other consisting of any following characters. The substitution copies the first character with its case unchanged, but the case of the remainder is set to upper by the \'\\U\' flag."]
}

proc ExplainDowncaseString {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown DowncaseFollowingString] ==1} {return}
    set po [CreateTextDisplay [_ "Downcase Following String"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(DowncaseFollowingString) $po;
    AppendToTextDisplay $po [_ "In a substitution this flag makes the case of the following string lower case where the characters have lower-case counterparts."];
    AppendToTextDisplay $po [_ "For example, if the regular expression is \'^\\(.\\)\\(.*\\)$\' (where backslashed parentheses are metacharacters delimiting capture groups) and the substitution expression is \'\\1\\L\\2\', the result of the substitution is the input with every character of each line except for the first made lower-case. The regular expression matches any string containing at least one character and creates two groups, one consisting of the first character, the other consisting of any following characters. The substitution copies the first character with its case unchanged, but the case of the remainder is set to lower by the \'\\L\' flag."]
}

proc ExplainSubNewline {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown SubNewline] ==1} {return}
    set po [CreateTextDisplay [_ "Insert Line Break"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(SubNewline) $po;
    AppendToTextDisplay $po [_ "This construct inserts a line break at the current position in the substitution."];
}

proc ExplainShiftBackToMagic {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ShiftBackToMagic] ==1} {return}
    set po [CreateTextDisplay [_ "Shift Back To Magic"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ShiftBackToMagic) $po;
    AppendToTextDisplay $po [_ "This flag terminates the effect of a preceding Quote Following Metacharacters flag with the effect that subsequent characters in the pattern are treated as metacharacters if that is their normal behavior."];
    AppendToTextDisplay $po [_ "For example, in a matcher that treats a period as a metacharacter matching any single character, the pattern \'...\' will match any three characters."]
    AppendToTextDisplay $po [_ "If this pattern is preceded by the Quote Following Metacharacters flag, it will only match the string \'...\'."]
    AppendToTextDisplay $po [_ "The pattern \'...\\M...\\m...\' matches a string of nine characters consisting of any three characters followed by three periods followed by any three characters, assuming that \'\\M\' and \'\\m\' are the Quote Following Metacharacters and Shift Back To Magic flags."]
}

proc ExplainBeginningOfFile {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown BeginningOfFile] ==1} {return}
    set po [CreateTextDisplay [_ "Beginning of File"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(BeginningOfFile) $po;
    AppendToTextDisplay $po [_ "This construct matches at the beginning of the file or, if used in a string match rather than an editor buffer, the beginning of the string."];
}

proc ExplainEndOfFile {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown EndOfFile] ==1} {return}
    set po [CreateTextDisplay [_ "End of File"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(EndOfFile) $po;
    AppendToTextDisplay $po [_ "This construct matches at the end of the file or, if used in a string match rather than an editor buffer, the end of the string."];
}

proc ExplainColumnSpecifier {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown ColumnSpecifier] ==1} {return}
    set po [CreateTextDisplay [_ "Match in Specified Column"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(ColumnSpecifier) $po;
    AppendToTextDisplay $po [_ "The following item matches only if it is located in the specified column, or, in string matches, at the specified character offset."];
}

proc ExplainPreColumnSpecifier {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown PreColumnSpecifier] ==1} {return}
    set po [CreateTextDisplay [_ "Match Prior to the Specified Column"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(PreColumnSpecifier) $po;
    AppendToTextDisplay $po [_ "The following item matches only if it is located before the specified column, or, in string matches, the specified character offset."];
}

proc ExplainPostColumnSpecifier {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown PostColumnSpecifier] ==1} {return}
    set po [CreateTextDisplay [_ "Match Following the Specified Column"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(PostColumnSpecifier) $po;
    AppendToTextDisplay $po [_ "The following item matches only if it is located after the specified column, or, in string matches, the specified character offset."];
}

proc ExplainAmpersandAnd {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown AmpersandAnd] ==1} {return}
    set po [CreateTextDisplay [_ "And"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(AmpersandAnd) $po;
    AppendToTextDisplay $po [_ "This construct matches if both of the conjuncts independently match ."];
    AppendToTextDisplay $po [_ "For example, the expression \'.*dog\\&.*cat\' matches \'dogcat\', \'dogncat\', and \'catndog\' but not \'dog\' or \'digncat.\'"];
    AppendToTextDisplay $po [_ "The expression \'dog\\&cat\' matches only the null string because there is no non-null string that matches both \'dog\' and \'cat\' exactly."]
    AppendToTextDisplay $po [_ "The expression \'.*dog\\&cat\' matches \'catdog\' and \'catndog\' but not \'dogcat\' or \'dogncat\'."];
}

proc ExplainHexWideCharCurly {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown HexWideCharCurly] ==1} {return}
    set po [CreateTextDisplay [_ "Hexadecimal Wide Character Format \\x\{abcd\}"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(HexWideCharCurly) $po;
    AppendToTextDisplay $po [_ "This notation represents a Unicode character by its hexadecimal code."];
    AppendToTextDisplay $po [_ " For example, \\x\{0561\} represents the character U+0561 \u0561 ARMENIAN SMALL LETTER AYB, decimal 1377."];
}

proc ExplainSingleOctet {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown SingleOctet] ==1} {return}
    set po [CreateTextDisplay [_ "SingleOctet"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(SingleOctet) $po;
    AppendToTextDisplay $po [_ "This matches a single octet (byte) whether or not it constitutes an entire character. If the internal representation is UTF-8, as it is in Perl, then the character \u0065 will match \\C since its UTF-8 encoding is 0x65. The character \u0565 will match \\C\\C since its UTF-8 encoding is 0xD5 0xA1. The character \u53CB will match \\C\\C\\C since its UTF-8 encoding is 0xE5 0x8F 0x8B. If the internal representation is UTF-16, all characters will match \\C\\C since all occupy two bytes. Similarly, if the internal representation is UTF-32, all characters will match \\C\\C\\C\\C since all characters occupy four bytes."];
}

if {0} {
#Template
proc ExplainXX {} {
    global HPWidth;
    global HPLines;
    global PopupList;
    if {[PopupDown XX] ==1} {return}
    set po [CreateTextDisplay [_ "XX"] $HPWidth $HPLines]
    BindKeys $po;
    set PopupList(XX) $po;
    AppendToTextDisplay $po [_ ""];
}
}

#This provides an addition to the default methods of the Scrollbar
#widget. The default method, bound to <B1>, #increments or decrements
#the value by the resolution, by default 1. If you want a larger
#increment, you can use a larger resolution, but sometimes it is
#convenient to have a finer resolutio available while also being
#able to move in larger increments. A solution is to bind to
#<B3>, or some other event if you wish, a larger movement.
#This procedure moves by the specified multiplier k times
#the resolution of the Scrollbar. 

proc ScrollbarMoveBigIncrement {w f x y} {
    set part [$w identify $x $y]
    switch -exact -- $part {
	trough1 {
	    set dir -1;
	}
	arrow1 {
	    set dir -1;
	}
	trough2 {
	    set dir  1;
	}
	arrow2 {
	    set dir  1;
	}
	default {
	    return ;
	}
    }
    set CurrentFraction [lindex [$w get] 0]
    set NewFraction [expr $CurrentFraction + ($dir * $f)]
    eval [concat [$w cget -command] moveto $NewFraction]
}


option add *proginfo.*Background $::ColorSpecs(ProgramInfoPopup,Background)	
option add *proginfo.*Foreground $::ColorSpecs(ProgramInfoPopup,Foreground)

proc PopupProgramInfo {} {
    global ColorSpecs;
    if {[winfo exists .proginfo]} {
	destroy .proginfo;
	return
    }
    toplevel .proginfo -borderwidth 4 -relief raised 
    wm title .proginfo [_ "Program Information"];
    after idle {
	update idletasks
	set xmax [winfo screenwidth .proginfo]
	set ymax [winfo screenheight .proginfo]
	set x0 [expr int(2.4 * ($xmax -[winfo reqwidth .proginfo])/3.0)];
	set y0 [expr int(2.3 * ($ymax -[winfo reqheight .proginfo])/3.0)];
	wm geometry .proginfo "+$x0+$y0";
    }
    set txt [format [_ "Properties of %s"] [NameProgram]]
    append txt [format "\n\[%s\]" $::ProgramInfo($::program,version)]
    label .proginfo.title -text $txt
    button .proginfo.dismiss -text [_ "Dismiss"] -command {destroy .proginfo} -anchor e
    pack .proginfo.title -side top -expand 1 -fill x 

    if {![FeaturesUnSetP $::program $::InterfaceLocale] } {
	if {$::Features(unicodefull,$::program,$::InterfaceLocale)} {
	    set txt [_ "Supports full Unicode in this locale."];
	} elseif {$::Features(unicodebmp,$::program,$::InterfaceLocale)} {
	    set txt [_ "Supports just the Basic Multilingual Plane of Unicode in this locale."];
	} else {
	    set txt [_ "Does not support Unicode in this locale."];
	}
	label .proginfo.unicode -text $txt -anchor w

	if {($::Features(dollar,$::program,$::InterfaceLocale) == 0) && \
		($::Features(AbsoluteEndOfString,$::program,$::InterfaceLocale))} {
	    set txt [_ "Treats newline as an ordinary character."];
	} else {
	    set txt [_ "Does not treat newline as an ordinary character"];
	}
	label .proginfo.newlineordinary -text $txt -anchor w

	if {[info exists ::ExecCmd($::program,match)]} {
	    if {[info exists ::ExecCmd($::program,sub)]} {
		set txt [_ "Is capable of both matching and substitution."];
	    } else {
		set txt [_ "Is capable of matching only."];
	    }
	} else {
	    set txt [_ "Is capable of substitution only."];
	}
	label .proginfo.matchsub -text $txt -anchor w

	pack .proginfo.unicode -side top  -expand 1 -fill x -padx 3 -pady 2
	pack .proginfo.newlineordinary -side top  -expand 1 -fill x -padx 3 -pady 2
	pack .proginfo.matchsub -side top  -expand 1 -fill x -padx 3 -pady 2
    } else {
	label .proginfo.whynot -text [_ "Feature testing is disabled."]
	pack .proginfo.whynot -side top -expand 1 -fill x 
    }
    pack .proginfo.dismiss -side bottom -anchor e -expand 1 -fill y -padx 3 -pady 6;
    catch {.proginfo.title configure -font -*-Courier-bold-o-normal--*-140-*}
}

#If the program info popup exists, recreate it so that it will be up to date.
proc RefreshProginfo {} {
    if {[winfo exists .proginfo]} {
	destroy .proginfo;
	PopupProgramInfo;
    }
}

proc WriteExecutionInfo {ExpList CLAndProg} {
    set Regexp [lindex $ExpList 0];
    set Subexp "";
    set DaughterProgram "";
    if {[llength $ExpList] > 1} {
	set Subexp [lindex $ExpList 1];
    }
    set CommandLine [lindex $CLAndProg 0]
    if {[llength $CLAndProg] > 1} {
	set DaughterProgram [lindex $CLAndProg 1];
    }

    #Get a file to write it to 
    set ExecInfoSaveFile [tk_getSaveFile -initialfile \
			      [format [_ "%sCommandInfo"] $::Program]]
    if {[ string equal $ExecInfoSaveFile ""]} {
	ShowMessage [_ "File selection cancelled."]
	return ;
    } else {
	if { [catch {open $ExecInfoSaveFile "w+"} ExecInfoSaveHandle]} {
	    ShowMessage [format [_ "Unable to open file %s to save command information"] \
			     [MinimizeFileName $ExecInfoSaveFile]];
	    return ;
	}
    }

    #Write out the info
    puts $ExecInfoSaveHandle [format [_ "Generated by Redet using %s %s"] \
			 $::Program  [clock format [clock seconds]]];
    puts $ExecInfoSaveHandle [format [_ "Command Line\n\t%s"] $CommandLine]
    puts $ExecInfoSaveHandle [format [_ "Regular Expression:\n\t%s"] $Regexp]
    if {![string equal $Subexp ""]} {
	puts $ExecInfoSaveHandle [format [_ "Substitution Expression:\n\t%s"] $Subexp]
    }
    if {![string equal $DaughterProgram ""]} {
	puts $ExecInfoSaveHandle [format [_ "Daughter Program:\n------------------\n%s"] \
				      $DaughterProgram]
    }
    close $ExecInfoSaveHandle;
    ShowMessage [format [_ "Command information saved in file %s."] [MinimizeFileName $ExecInfoSaveFile]]
} 

proc SaveCommandInfo {} {
    set ::ExecutionFlag CommandInfo;
    ExecuteRegexp;
    set ::ExecutionFlag Normal;
}

proc ShowCommandLine {} {
    set ::ExecutionFlag CommandLine;
    ExecuteRegexp;
    set ::ExecutionFlag Normal;
}

proc GetHomeDir {} {
    set cwd [pwd];
    cd;
    set hd [pwd];
    cd $cwd;
    return $hd;
}

set CustomCharacterChartFileNameList "";
proc StoreCustomCharacterChartFileName {fn} {
    lappend ::CustomCharacterChartFileNameList $fn;
}

set CustomCharacterChartDataList "";
proc StoreCustomCharacterChartInPlace {dl} {
    lappend ::CustomCharacterChartDataList $dl;
}

#Initialization file stuff

#This creates a procedure for setting the color of each combination of
#object and feature. The procedure validates the color specification, so
#invalid color specifications are trapped in the slave interpreter.
proc DefineColorSettingProcs {} {
    global ColorProcList;
    foreach cs [array names ::ColorSpecs] {
	set csl [split $cs ","]
	set obj   [lindex $csl 0]
	set which [lindex $csl 1]
	set procname [format "Set%s%sColor" $obj $which]
	lappend ColorProcList $procname
	eval [list "proc" $procname \
		   \
		  "\{cs\}" \
		  "if \{!\[::validcolor::IsColorSpecQ \$cs\]\} \{
		  puts \[format \[_ \"\\\"%s\\\" is not a valid color specification.\"\] \$cs\]
		  return;
		 \}
		  set ::ColorSpecs($obj,$which) \$cs"]
    }
}

proc SetStandardLayoutP {b} {
    set ::StandardConfigurationP [Boolean $b];
}

proc SetUseScrollbarsP {b} {
    set ::UseScrollbarsP [Boolean $b];
}

proc SetBalloonHelpShowP {b} {
    set ::BalloonHelpP [Boolean $b];
}

proc SetFocusFollowsMouseP {b} {
    set ::FocusFollowsMouseP [Boolean $b];
    if {$::FocusFollowsMouseP} {
	tk_focusFollowsMouse;
    }
}

proc SetHistoryIncludeProgramP {b} {
    set hist::HistoryShowProgP [Boolean $b];
}

proc SelectBrowser {s} {
    set ::Browser $s;
}

proc SetHistoryCentralP {b} {
    set hist::LocalP [Boolean $b];
} 

proc SetAutoClearRegexpP {b} {
    set ::AutoClearRegexpP [Boolean $b];
} 

proc SetOutputOnlyChangedLinesP {b} {
    set ::OutputOnlyChangedLinesP [Boolean $b];
} 

proc SetUserClassesEnabledP {b} {
   set ::UserClassesEnabledP [Boolean $b];
}

proc SetLeftUserClassIntersectionDelimiter {s} {
    set ::LeftUserIntDelimiter [lindex [split $s] 0];
}

proc SetRightUserClassIntersectionDelimiter {s} {
    set ::RightUserIntDelimiter [lindex [split $s] 0];
}

#Commands for setting program-specific parameters

proc SetAgrepCaseInsensitiveP {b} {
    set ::ProgramInfo(agrep,CaseInsensitiveP) [Boolean $b];
}

proc SetAgrepBestResultsP {b} {
    set ::ProgramInfo(agrep,BestResults) [Boolean $b];
}

proc SetAgrepErrorLimit {s} {
    set ::ProgramInfo(agrep,ErrorLimit) $s;
}

proc SetAgrepDeletionCost {s} {
    set ::ProgramInfo(agrep,DeletionCost) $s;
}

proc SetAgrepInsertionCost {s} {
    set ::ProgramInfo(agrep,InsertionCost) $s;
}

proc SetAgrepSubstitutionCost {s} {
    set ::ProgramInfo(agrep,SubstitutionCost) $s;
}

proc SetArenaCaseInsensitiveP {b} {
    set ::ProgramInfo(arena,CaseInsensitiveP) [Boolean $b];
}

proc SetArenaVerboseP {b} {
    set ::ProgramInfo(arena,VerboseP) [Boolean $b];
}

proc SetBashExtendedP {b} {
    set ::ProgramInfo(bash,ExtendedP) [Boolean $b];
}

proc SetBusyBoxEgrepCaseInsensitiveP {b} {
    set ::ProgramInfo(BusyBoxEgrep,CaseInsensitiveP) [Boolean $b];
}

proc SetBusyBoxEgrepComplementP {b} {
    set ::ProgramInfo(BusyBoxEgrep,Complement) [Boolean $b];
}

proc SetCgrepCaseInsensitiveP {b} {
    set ::ProgramInfo(cgrep,CaseInsensitiveP) [Boolean $b];
}

proc SetCgrepComplementP {b} {
    set ::ProgramInfo(cgrep,Complement) [Boolean $b];
}

proc SetCgrepExtendedP {b} {
    set ::ProgramInfo(cgrep,ExtendedP) [Boolean $b];
}

proc SetCgrepTotalCost {s} {
    set ::ProgramInfo(cgrep,TotalCost) $s;
}

proc SetCgrepInsertionCost {s} {
    set ::ProgramInfo(cgrep,InsertionCost) $s;
}

proc SetCgrepDeletionCost {s} {
    set ::ProgramInfo(cgrep,DeletionCost) $s;
}

proc SetCgrepSubstitutionCost {s} {
    set ::ProgramInfo(cgrep,SubstitutionCost) $s;
}

proc SetEgrepCaseInsensitiveP {b} {
    set ::ProgramInfo(egrep,CaseInsensitiveP) [Boolean $b];
}

proc SetEgrepEmitMatchOnlyP {b} {
    set ::ProgramInfo(egrep,EmitMatchOnly) [Boolean $b];
}

proc SetEgrepComplementP {b} {
    set ::ProgramInfo(egrep,Complement) [Boolean $b];
}

proc SetEmacsFoldCaseMatchP {b} {
    set ::ProgramInfo(emacs,FoldCaseMatchP) [Boolean $b];
}

proc SetEmacsFoldCaseReplaceP {b} {
    set ::ProgramInfo(emacs,FoldCaseReplaceP) [Boolean $b];
}

proc SetFgrepCaseInsensitiveP {b} {
    set ::ProgramInfo(fgrep,CaseInsensitiveP) [Boolean $b];
}

proc SetFgrepEmitMatchOnlyP {b} {
    set ::ProgramInfo(fgrep,EmitMatchOnly) [Boolean $b];
}

proc SetFgrepComplementP {b} {
    set ::ProgramInfo(fgrep,Complement) [Boolean $b];
}

proc SetGawkCaseInsensitiveP {b} {
    set ::ProgramInfo(gawk,CaseInsensitiveP) [Boolean $b];
}

proc SetGawkIntervalExpressionsP {b} {
    set ::ProgramInfo(gawk,IntervalExpressions) [Boolean $b];
}

proc SetGawkNotation {s} {
    set ::ProgramInfo(gawk,Notation) $s;
}

proc SetGlarkCaseInsensitiveP {b} {
    set ::ProgramInfo(glark,CaseInsensitiveP) [Boolean $b];
}

proc SetGlarkEmitMatchOnlyP {b} {
    set ::ProgramInfo(glark,EmitMatchOnly) [Boolean $b];
}

proc SetGlarkComplementP {b} {
    set ::ProgramInfo(glark,Complement [Boolean $b];
}

proc SetGlarkMatchEntireLineP {b} {
    set ::ProgramInfo(glark,MatchEntireLineP) [Boolean $b];
}

proc SetGrepCaseInsensitiveP {b} {
    set ::ProgramInfo(grep,CaseInsensitiveP) [Boolean $b];
}

proc SetGrepEmitMatchOnlyP {b} {
    set ::ProgramInfo(grep,EmitMatchOnly) [Boolean $b];
}

proc SetGrepComplementP {b} {
    set ::ProgramInfo(grep,Complement) [Boolean $b];
}

proc SetGrepNotation {s} {
    set ::ProgramInfo(grep,Notation) $s;
}

proc SetIciCaseInsensitiveP {b} {
    set ::ProgramInfo(ici,CaseInsensitiveP) [Boolean $b];
}

proc SetIciVerboseP {b} {
    set ::ProgramInfo(ici,VerboseP) [Boolean $b];
}

proc SetIciExpandedP {b} {
    set ::ProgramInfo(ici,VerboseP) [Boolean $b];
}

proc SetJavaCanonEQP {b} {
    set ::ProgramInfo(java,CanonEQ) [Boolean $b];
}

proc SetJavaCaseInsensitiveP {b} {
    set ::ProgramInfo(java,CaseInsensitiveP) [Boolean $b];
}

proc SetJavaUnicodeCaseP {b} {
    set ::ProgramInfo(java,UnicodeCase) [Boolean $b];
}

proc SetJgrepCaseInsensitiveP {b} {
    set ::ProgramInfo(jgrep,CaseInsensitiveP) [Boolean $b];
}

proc SetMysqlRegexpP {b} {
    set ::ProgramInfo(mysql,RegexpP) [Boolean $b];
}

proc SetNrgrepCaseInsensitiveP {b} {
    set ::ProgramInfo(nrgrep,CaseInsensitiveP) [Boolean $b];
}

proc SetNrgrepComplementP {b} {
    set ::ProgramInfo(nrgrep,ComplementP) [Boolean $b];
}

proc SetNrgrepTotalCost {s} {
    set ::ProgramInfo(nrgrep,TotalCost) $s;
}

proc SetNrgrepInsertionsP {b} {
    set ::ProgramInfo(nrgrep,InsertionsP) [Boolean $b];
}

proc SetNrgrepDeletionsP {b} {
    set ::ProgramInfo(nrgrep,DeletionsP) [Boolean $b];
}

proc SetNrgrepSubstitutionsP {b} {
    set ::ProgramInfo(nrgrep,SubstitutionsP) [Boolean $b];
}

proc SetNrgrepTranspositionsP {b} {
    set ::ProgramInfo(nrgrep,TranspositionsP) [Boolean $b];
}

proc SetNumgrepOutputNumberByNumberP {b} {
    set ::ProgramInfo(numgrep,OutputNumberByNumberP) [Boolean $b];
}

proc SetPerlUnicodeLocaleDependentP {b} {
    set ::ProgramInfo(perl,UnicodeLocaleDependentP) [Boolean $b];
}

proc SetPatmatchResidueType {s} {
    set ::ProgramInfo(patmatch,ResidueType) $s;
}

proc SetPatmatchMismatchNumber {s} {
    set ::ProgramInfo(patmatch,MismatchNumber) $s;
}

proc SetPatmatchMismatchTypes {s} {
    set ::ProgramInfo(patmatch,MismatchTypes) $s;
}

proc SetPcregrepCaseInsensitiveP {b} {
    set ::ProgramInfo(pcregrep,CaseInsensitiveP) [Boolean $b];
}

proc SetPcregrepEmitMatchOnlyP {b} {
    set ::ProgramInfo(pcregrep,EmitMatchOnly) [Boolean $b];
}

proc SetPcregrepComplementP {b} {
    set ::ProgramInfo(pcregrep,Complement) [Boolean $b];
}

proc SetPythonRawStringP {b} {
    set ::ProgramInfo(python,RawStringP) [Boolean $b];
}

proc SetSedExtendedRegexpP {b} {
    set ::ProgramInfo(sed,ExtendedRegexp) [Boolean $b];
}

proc SetSgrepCaseInsensitiveP {b} {
    set ::ProgramInfo(sgrep,CaseInsensitiveP) [Boolean $b];
}

proc SetSsedPOSIXP {b} {
    set ::ProgramInfo(ssed,POSIX) [Boolean $b];
}

proc SetSsedRegexpType {s} {
    if {[string match -nocase basic $s]} {
	set ::ProgramInfo(ssed,RegexpType) basic
    } elseif {[string match -nocase extended $s]} { 
	set ::ProgramInfo(ssed,RegexpType) extended
    } elseif {[string match -nocase perl $s]} {
	set ::ProgramInfo(ssed,RegexpType) perl
    } else {
	ShowMessage [format [_ "%s is not a possible ssed regular expression type"] $s]
    }
}

proc SetTclCaseInsensitiveP {b} {
    set ::ProgramInfo(tcl,CaseInsensitiveP) [Boolean $b];
}

proc SetTclEmitMatchOnlyP {b} {
    set ::ProgramInfo(tcl,EmitMatchOnlyP) [Boolean $b];
}

proc SetTclExpandedP {b} {
    set ::ProgramInfo(tcl,ExpandedP) [Boolean $b];
}

proc SetTrComplementP {b} {
    set ::ProgramInfo(tr,Complement) [Boolean $b];
}

proc SetTrSqueezeP {b} {
    set ::ProgramInfo(tr,Squeeze) [Boolean $b];
}

proc SetTrTruncateP {b} {
    set ::ProgramInfo(tr,Truncate) [Boolean $b];
}

proc SetVimCaseInsensitiveP {b} {
    set ::ProgramInfo(vim,CaseInsensitiveP) [Boolean $b];
}

proc SetVimSmartCaseP {b} {
    set ::ProgramInfo(vim,SmartCaseP) [Boolean $b];
}

proc SetVimSubstitutionGlobalP {b} {
    set ::ProgramInfo(vim,SubstitutionGlobalP) [Boolean $b];
}

proc SetZshExtendedGlobP {b} {
    set ::ProgramInfo(zsh,ExtendedGlobP) [Boolean $b];
}

proc SetZshKornQuantifiersP {b} {
    set ::ProgramInfo(zsh,KornQuantifiersP) [Boolean $b];
}

proc SetShellItemLimit {s} {
    if {![string is integer -strict $s]} {
	return ;
    }
    if {$s < 1} {
	return
    }
    set ::ShellItemLimit $s;
}

#Returns a list of init file commands representing the current user-defined palette entries.
proc SavePaletteEntries {} {
    set cl [list]
    foreach pe [array names ::UserPalette] {
	set pel [split $pe ","]
	set EntryName [lindex $pel 1];
	if {$EntryName == 0} {continue}
	set WhichProgram [lindex $pel 0];
	set e $::UserPalette($WhichProgram,$EntryName);
	set Body [list [lindex $e 0]]
	set Etext [lindex $e 1]
	lappend cl [format "AddUserPaletteEntry %s %s %s %s" \
			$WhichProgram $EntryName $Body $Etext]
    }
    return [lsort $cl];
}


#Returns a list of init file commands representing the current color settings.
proc SaveColorSettings {} {
    set cl [list]
    foreach cs [array names ::ColorSpecs] {
	set csl [split $cs ","]
	set obj   [lindex $csl 0]
	set which [lindex $csl 1]
	set ps $::ColorSpecs($cs)
	if {[string index $ps 0] == "\#"} {
	    set ps \\$::ColorSpecs($cs)
	} else {
	    set ps [list $ps];
	}
	lappend cl [format "%s%sColor %s" $obj $which $ps]
    }
    return [lsort $cl];
}

#Check whether the argument represents a Boolean value
#and interpret it if it is.
proc Boolean {s} {
     switch -regexp $s {
	 1	{return 1}
	 T.*	{return 1}
	 t.*	{return 1}
	 Y.*	{return 1}
	 y.*	{return 1}
	 ok	{return 1}
	 on	{return 1}
	 0 	{return 0}
	 F.*	{return 0}
	 f.*	{return 0}
	 N.*	{return 0}
	 n.*	{return 0}
	 off	{return 0}
	 default {error}
     }
}

proc GetInitCommands {} {
    # We want a fresh interpreter so that we don't
    # list any commands defined in a user's init file.
    if { [interp exists init]} {
	interp delete init
    }
    InitFileSetup;
    set n 0
    #We rely on the fact that all builtin commands have lower-case
    #case names to separate the commands we provide from the builtins.
    return [interp eval init {lsort [info commands \[A-Z\]*]}]
}

proc SaveInitCommands {} {
    set SaveFile [tk_getSaveFile -initialfile [_ "InitFileCommands"]];
    if {[string equal $SaveFile ""]} {
	return ;
    } else {
        if { [catch {open $SaveFile "w+"} fh] != 0} {
	    ShowMessage [format \
		     [_ "Unable to open file %s in which to save class definitions."] \
			     [MinimizeFileName $SaveFile]];
	    return ;
        }
    }
    set n 0;
    foreach l [GetInitCommands] {
	incr n;
	puts $fh [format "\[%03d\] %s" $n $l]
    }
    close $fh;
}

proc GetInitTclCommands {} {
    # We want a fresh interpreter so that we don't
    # list any commands defined in a user's init file.
    if { [interp exists init]} {
	interp delete init
    }
    interp create -safe -- init
    set n 0
    #We rely on the fact that all builtin commands have lower-case
    #case names to separate the commands we provide from the builtins.
    return [interp eval init {lsort [info commands \[a-z\]*]}]
}

proc PopupInitCommandList {} {
    if {[PopupDown InitCommandList] ==1} {return}
    set po  [CreateTextDisplay [_ "Redet-Specific Initialization File Commands"] 65 10];
    set ::PopupList(InitCommandList) $po;
    BindKeys $po;
    set n 0;
    foreach l [GetInitCommands] {
	incr n;
	AppendToTextDisplay $po [format "\[%03d\] %s\n" $n $l];
    }
}

proc SaveInitTclCommands {} {
    set SaveFile [tk_getSaveFile -initialfile [_ "InitFileTclCommands"]];
    if {[string equal $SaveFile ""]} {
	return ;
    } else {
        if { [catch {open $SaveFile "w+"} fh] != 0} {
	    ShowMessage [format \
		     [_ "Unable to open file %s in which to save Tcl commands."] \
			     [MinimizeFileName $SaveFile]];
	    return ;
        }
    }
    set n 0;
    foreach l [GetInitTclCommands] {
	incr n;
	puts $fh [format "\[%03d\] %s" $n $l]
    }
    close $fh;
}

proc PopupInitTclCommandList {} {
    if {[PopupDown InitTclCommandList] ==1} {return}
    set po  [CreateTextDisplay [_ "Initialization File Tcl Commands"] 65 12];
    set ::PopupList(InitTclCommandList) $po;
    BindKeys $po;
    set n 0;
    foreach l [GetInitTclCommands] {
	incr n;
	AppendToTextDisplay $po [format "\[%03d\] %s\n" $n $l];
    }
}

proc SaveMiscellaneousSettings {} {
    set MiscellaneousInitCommandList \
	[list \
	     [SlaveName SetTestDataEncoding] $::Pars(TestDataEncoding)\
	     [SlaveName SetComparisonDataEncoding] $::Pars(ComparisonDataEncoding)\
	     [SlaveName SetResultEncoding] $::Pars(ResultEncoding)\
	     [SlaveName SetPaletteHeightLimit] $::PaletteHeightLimit\
	     [SlaveName SetUserClassesEnabledP] $::UserClassesEnabledP\
	     [SlaveName SetLeftUserClassIntersectionDelimiter] $::LeftUserIntDelimiter\
	     [SlaveName SetRightUserClassIntersectionDelimiter] $::RightUserIntDelimiter\
	     [SlaveName SetAutoClearRegexpP] $::AutoClearRegexpP \
	     [SlaveName SelectBrowser] $::DefaultBrowser\
	     [SlaveName SetFocusFollowsMouseP] $::FocusFollowsMouseP \
	     [SlaveName SetHistoryCentralP] $hist::LocalP\
	     [SlaveName SetHistoryIncludeProgramP] $hist::HistoryShowProgP\
	     [SlaveName SetOutputOnlyChangedLinesP] $::OutputOnlyChangedLinesP\
	     [SlaveName SelectProgramInitFile] $::program \
	     [SlaveName SetStandardLayoutP] $::StandardConfigurationP\
	     [SlaveName SubstitutionModeInitFileP] $::DoSubstitutionsP\
	     [SlaveName SetUseScrollbarsP] $::UseScrollbarsP\
	     [SlaveName SetBalloonHelpShowP]			$::BalloonHelpP \
	     [SlaveName SetDisplayConsonantChartColumnLabelsP]	$::DisplayConsonantChartColumnLabelsP \
	     [SlaveName SetDisplayConsonantChartRowLabelsP]	$::DisplayConsonantChartRowLabelsP \
	     [SlaveName SetDisplayVowelChartColumnLabelsP]	$::DisplayVowelChartColumnLabelsP \
	     [SlaveName SetDisplayVowelChartRowLabelsP]		$::DisplayVowelChartRowLabelsP \
	     [SlaveName SetUseScrollbarsP]			$::UseScrollbarsP \
	     [SlaveName SetAgrepBestResultsP]	$::ProgramInfo(agrep,BestResults) \
	     [SlaveName SetAgrepCaseInsensitiveP]	$::ProgramInfo(agrep,CaseInsensitiveP) \
	     [SlaveName SetAgrepErrorLimit]	$::ProgramInfo(agrep,TotalCost) \
	     [SlaveName SetAgrepDeletionCost]	$::ProgramInfo(agrep,DeletionCost) \
	     [SlaveName SetAgrepInsertionCost]	$::ProgramInfo(agrep,InsertionCost) \
	     [SlaveName SetAgrepSubstitutionCost]	$::ProgramInfo(agrep,SubstitutionCost) \
	     [SlaveName SetArenaCaseInsensitiveP]	$::ProgramInfo(arena,CaseInsensitiveP) \
	     [SlaveName SetArenaVerboseP]	$::ProgramInfo(arena,VerboseP) \
	     [SlaveName SetBashExtendedP]	$::ProgramInfo(bash,ExtendedP) \
	     [SlaveName SetBusyBoxEgrepCaseInsensitiveP]	$::ProgramInfo(BusyBoxEgrep,CaseInsensitiveP) \
	     [SlaveName SetBusyBoxEgrepComplementP]	$::ProgramInfo(BusyBoxEgrep,Complement) \
	     [SlaveName SetCgrepCaseInsensitiveP]	$::ProgramInfo(cgrep,CaseInsensitiveP) \
	     [SlaveName SetCgrepComplementP]	$::ProgramInfo(cgrep,Complement) \
	     [SlaveName SetCgrepExtendedP]	$::ProgramInfo(cgrep,ExtendedP) \
	     [SlaveName SetCgrepTotalCost]	$::ProgramInfo(cgrep,TotalCost) \
	     [SlaveName SetCgrepInsertionCost]	$::ProgramInfo(cgrep,InsertionCost) \
	     [SlaveName SetCgrepDeletionCost]	$::ProgramInfo(cgrep,DeletionCost) \
	     [SlaveName SetCgrepSubstitutionCost]	$::ProgramInfo(cgrep,SubstitutionCost) \
	     [SlaveName SetEgrepCaseInsensitiveP]	$::ProgramInfo(egrep,CaseInsensitiveP) \
	     [SlaveName SetEgrepEmitMatchOnlyP]	$::ProgramInfo(egrep,EmitMatchOnly) \
	     [SlaveName SetEgrepComplementP]	$::ProgramInfo(egrep,Complement) \
	     [SlaveName SetEmacsFoldCaseMatchP]	$::ProgramInfo(emacs,FoldCaseMatchP) \
	     [SlaveName SetEmacsFoldCaseReplaceP]	$::ProgramInfo(emacs,FoldCaseReplaceP) \
	     [SlaveName SetFgrepCaseInsensitiveP]	$::ProgramInfo(fgrep,CaseInsensitiveP) \
	     [SlaveName SetFgrepEmitMatchOnlyP]	$::ProgramInfo(fgrep,EmitMatchOnly) \
	     [SlaveName SetFgrepComplementP]	$::ProgramInfo(fgrep,Complement) \
	     [SlaveName SetGawkCaseInsensitiveP]	$::ProgramInfo(gawk,CaseInsensitiveP) \
	     [SlaveName SetGawkIntervalExpressionsP]	$::ProgramInfo(gawk,IntervalExpressions) \
	     [SlaveName SetGawkNotation]	$::ProgramInfo(gawk,Notation) \
	     [SlaveName SetGlarkCaseInsensitiveP]	$::ProgramInfo(glark,CaseInsensitiveP) \
	     [SlaveName SetGlarkEmitMatchOnlyP]	$::ProgramInfo(glark,EmitMatchOnly) \
	     [SlaveName SetGlarkComplementP]	$::ProgramInfo(glark,Complement) \
	     [SlaveName SetGlarkMatchEntireLineP]	$::ProgramInfo(glark,MatchEntireLine) \
	     [SlaveName SetGrepCaseInsensitiveP]	$::ProgramInfo(grep,CaseInsensitiveP) \
	     [SlaveName SetGrepEmitMatchOnlyP]	$::ProgramInfo(grep,EmitMatchOnly) \
	     [SlaveName SetGrepComplementP]	$::ProgramInfo(grep,Complement) \
	     [SlaveName SetGrepNotation]	$::ProgramInfo(grep,Notation) \
	     [SlaveName SetIciCaseInsensitiveP]	$::ProgramInfo(ici,CaseInsensitiveP) \
	     [SlaveName SetIciVerboseP]	$::ProgramInfo(ici,VerboseP) \
	     [SlaveName SetJavaCanonEQP]	$::ProgramInfo(java,CanonEQ) \
	     [SlaveName SetJavaCaseInsensitiveP]	$::ProgramInfo(java,CaseInsensitiveP) \
	     [SlaveName SetJavaUnicodeCaseP]	$::ProgramInfo(java,UnicodeCase) \
	     [SlaveName SetJgrepCaseInsensitiveP]	$::ProgramInfo(jgrep,CaseInsensitiveP) \
	     [SlaveName SetMysqlRegexpP]	$::ProgramInfo(mysql,RegexpP) \
	     [SlaveName SetNrgrepCaseInsensitiveP]	$::ProgramInfo(nrgrep,CaseInsensitiveP) \
	     [SlaveName SetNrgrepComplementP]	$::ProgramInfo(nrgrep,ComplementP) \
	     [SlaveName SetNrgrepTotalCost]	$::ProgramInfo(nrgrep,TotalCost) \
	     [SlaveName SetNrgrepInsertionsP]	$::ProgramInfo(nrgrep,InsertionsP) \
	     [SlaveName SetNrgrepDeletionsP]	$::ProgramInfo(nrgrep,DeletionsP) \
	     [SlaveName SetNrgrepSubstitutionsP]	$::ProgramInfo(nrgrep,SubstitutionsP) \
	     [SlaveName SetNrgrepTranspositionsP]	$::ProgramInfo(nrgrep,TranspositionsP) \
	     [SlaveName SetNumgrepOutputNumberByNumberP]	$::ProgramInfo(numgrep,OutputNumberByNumberP) \
	     [SlaveName SetPatmatchResidueType] $::ProgramInfo(patmatch,ResidueType) \
	     [SlaveName SetPatmatchMismatchNumber] $::ProgramInfo(patmatch,MismatchNumber) \
	     [SlaveName SetPatmatchMismatchTypes] $::ProgramInfo(patmatch,MismatchTypes) \
	     [SlaveName SetPcregrepCaseInsensitiveP]	$::ProgramInfo(pcregrep,CaseInsensitiveP) \
	     [SlaveName SetPcregrepEmitMatchOnlyP]	$::ProgramInfo(pcregrep,EmitMatchOnly) \
	     [SlaveName SetPcregrepComplementP]	$::ProgramInfo(pcregrep,Complement) \
	     [SlaveName SetPerlUnicodeLocaleDependentP]	$::ProgramInfo(perl,UnicodeLocaleDependentP) \
	     [SlaveName SetPythonRawStringP]	$::ProgramInfo(python,RawStringP) \
	     [SlaveName SetSedExtendedRegexpP]	$::ProgramInfo(sed,ExtendedRegexp) \
	     [SlaveName SetSgrepCaseInsensitiveP]	$::ProgramInfo(sgrep,CaseInsensitiveP) \
	     [SlaveName SetSsedPOSIXP]	$::ProgramInfo(ssed,POSIX) \
	     [SlaveName SetSsedRegexpType]	$::ProgramInfo(ssed,RegexpType) \
	     [SlaveName SetTclCaseInsensitiveP]	$::ProgramInfo(tcl,CaseInsensitiveP) \
	     [SlaveName SetTclEmitMatchOnlyP]	$::ProgramInfo(tcl,EmitMatchOnlyP) \
	     [SlaveName SetTclExpandedP]	$::ProgramInfo(tcl,ExpandedP) \
	     [SlaveName SetTrComplementP]	$::ProgramInfo(tr,Complement) \
	     [SlaveName SetTrSqueezeP]	$::ProgramInfo(tr,Squeeze) \
	     [SlaveName SetTrTruncateP]	$::ProgramInfo(tr,Truncate) \
	     [SlaveName SetVimCaseInsensitiveP]	$::ProgramInfo(vim,CaseInsensitiveP) \
	     [SlaveName SetVimSmartCaseP]	$::ProgramInfo(vim,SmartCaseP) \
	     [SlaveName SetVimSubstitutionGlobalP]	$::ProgramInfo(vim,SubstitutionGlobalP) \
	     [SlaveName SetZshExtendedGlobP]	$::ProgramInfo(zsh,ExtendedGlobP) \
	     [SlaveName SetZshKornQuantifiersP]	$::ProgramInfo(zsh,KornQuantifiersP) \
	     [SlaveName SetShellItemLimit]	$::ShellItemLimit]

    if {[info exists ::AccentedLettersPerRow]} {
	lappend MiscellaneousInitCommandList [SlaveName SetAccentedLetterColumns]
	lappend MiscellaneousInitCommandList $::AccentedLettersPerRow
    }

    set cl [list]
    foreach {command value} $MiscellaneousInitCommandList {
	lappend cl [format "%s %s" $command $value]
    }
    foreach title [array names ::SpecialCharacterPalette] {
	if {[string match "*WidgetName" $title]} {continue}
	set info $::SpecialCharacterPalette($title);
	if {[llength $info] > 2} {
	    lappend cl [list ReadCharacterChart [lindex $info 2]];
	} else {
	    lappend cl [ReconstructCharacterChartDefinition $title];
	}
    }
    return $cl;
}

proc ReconstructCharacterChartDefinition {Title} {
    set info $::SpecialCharacterPalette($Title);
    set txt DefineCharacterChart;
    append txt " \{\n"
    append txt [format "%s" [Quote $Title]]
    set flds [llength $info];
    if {$flds > 1} {
	append txt [format "|%d" [lindex $info 1]];# Number of columns
    }
    if {$flds > 2} {
	append txt [format "|%s" [lindex $info 2]];# Font family
    }
    if {$flds > 3} {
	append txt [format "|%s" [lindex $info 3]];# Font size
    }
    append txt "\n"
    #Each entry consists of a unicode string and a gloss
    foreach x [lindex $info 0] {
	set string [lindex $x 0]
	set gloss  [lindex $x 1]
	append txt [format "%s|%s\n" [UnicodeStringToHex $string] [Quote $gloss]];
    }
    append txt "\}"
    return  $txt;
}

#This is a kludge but I encountered quoting hell trying to use (\\s) -> \\ \\1
#e.g.   regsub -all "\\s" $s {\ } r

#Escape spaces and tabs
proc Quote {s} {
    regsub -all "\u0020" $s {\ } r
    regsub -all "\t" $r {\	} ret
    return $ret
}

proc UnicodeStringToHex {s} {
    set rv "";
    foreach c [split $s ""] {
	scan $c "%c" t
	if {$t <= 0xFF} {
	    append rv $c;
	} else {
	    append rv [format "\\u%04X" $t];
	}
    }
    return $rv;
 }

#This package defines a routine IsColorSpecQ that validates X11 color specifications.
#It returns 1 if its argument is either a recognized X11 color name or
#a well formed hexadecimal RGB specification. If so desired, the two routines on
#which it is based, IsColorNameQ and IsColorNumericQ can also be exported.
namespace eval validcolor {
    namespace export IsColorSpecQ;
    variable CN;

    set CN([list ghost white]) 1
    set CN([list white smoke]) 1
    set CN([list floral white]) 1
    set CN([list antique white]) 1
    set CN([list old lace]) 1
    set CN([list papaya whip]) 1
    set CN([list blanched almond]) 1
    set CN([list peach puff]) 1
    set CN([list navajo white]) 1
    set CN([list lemon chiffon]) 1
    set CN([list mint cream]) 1
    set CN([list alice blue]) 1
    set CN([list lavender blush]) 1
    set CN([list misty rose]) 1
    set CN([list dark slate gray]) 1
    set CN([list dark slate grey]) 1
    set CN([list dim gray]) 1
    set CN([list dim grey]) 1
    set CN([list slate gray]) 1
    set CN([list slate grey]) 1
    set CN([list light slate gray]) 1
    set CN([list light slate grey]) 1
    set CN([list light grey]) 1
    set CN([list light gray]) 1
    set CN([list midnight blue]) 1
    set CN([list navy blue]) 1
    set CN([list cornflower blue]) 1
    set CN([list dark slate blue]) 1
    set CN([list slate blue]) 1
    set CN([list medium slate blue]) 1
    set CN([list light slate blue]) 1
    set CN([list medium blue]) 1
    set CN([list royal blue]) 1
    set CN([list dodger blue]) 1
    set CN([list deep sky blue]) 1
    set CN([list sky blue]) 1
    set CN([list light sky blue]) 1
    set CN([list steel blue]) 1
    set CN([list light steel blue]) 1
    set CN([list light blue]) 1
    set CN([list powder blue]) 1
    set CN([list pale turquoise]) 1
    set CN([list dark turquoise]) 1
    set CN([list medium turquoise]) 1
    set CN([list light cyan]) 1
    set CN([list cadet blue]) 1
    set CN([list medium aquamarine]) 1
    set CN([list dark green]) 1
    set CN([list dark olive green]) 1
    set CN([list dark sea green]) 1
    set CN([list sea green]) 1
    set CN([list medium sea green]) 1
    set CN([list light sea green]) 1
    set CN([list pale green]) 1
    set CN([list spring green]) 1
    set CN([list lawn green]) 1
    set CN([list medium spring green]) 1
    set CN([list green yellow]) 1
    set CN([list lime green]) 1
    set CN([list yellow green]) 1
    set CN([list forest green]) 1
    set CN([list olive drab]) 1
    set CN([list dark khaki]) 1
    set CN([list pale goldenrod]) 1
    set CN([list light goldenrod yellow]) 1
    set CN([list light yellow]) 1
    set CN([list light goldenrod]) 1
    set CN([list dark goldenrod]) 1
    set CN([list rosy brown]) 1
    set CN([list indian red]) 1
    set CN([list saddle brown]) 1
    set CN([list sandy brown]) 1
    set CN([list dark salmon]) 1
    set CN([list light salmon]) 1
    set CN([list dark orange]) 1
    set CN([list light coral]) 1
    set CN([list orange red]) 1
    set CN([list hot pink]) 1
    set CN([list deep pink]) 1
    set CN([list light pink]) 1
    set CN([list pale violet red]) 1
    set CN([list medium violet red]) 1
    set CN([list violet red]) 1
    set CN([list medium orchid]) 1
    set CN([list dark orchid]) 1
    set CN([list dark violet]) 1
    set CN([list blue violet]) 1
    set CN([list medium purple]) 1
    set CN(snow) 1
    set CN(GhostWhite) 1
    set CN(WhiteSmoke) 1
    set CN(gainsboro) 1
    set CN(FloralWhite) 1
    set CN(OldLace) 1
    set CN(linen) 1
    set CN(AntiqueWhite) 1
    set CN(PapayaWhip) 1
    set CN(BlanchedAlmond) 1
    set CN(bisque) 1
    set CN(PeachPuff) 1
    set CN(NavajoWhite) 1
    set CN(moccasin) 1
    set CN(cornsilk) 1
    set CN(ivory) 1
    set CN(LemonChiffon) 1
    set CN(seashell) 1
    set CN(honeydew) 1
    set CN(MintCream) 1
    set CN(azure) 1
    set CN(AliceBlue) 1
    set CN(lavender) 1
    set CN(LavenderBlush) 1
    set CN(MistyRose) 1
    set CN(white) 1
    set CN(black) 1
    set CN(DarkSlateGray) 1
    set CN(DarkSlateGrey) 1
    set CN(DimGray) 1
    set CN(DimGrey) 1
    set CN(SlateGray) 1
    set CN(SlateGrey) 1
    set CN(LightSlateGray) 1
    set CN(LightSlateGrey) 1
    set CN(gray) 1
    set CN(grey) 1
    set CN(LightGrey) 1
    set CN(LightGray) 1
    set CN(MidnightBlue) 1
    set CN(navy) 1
    set CN(NavyBlue) 1
    set CN(CornflowerBlue) 1
    set CN(DarkSlateBlue) 1
    set CN(SlateBlue) 1
    set CN(MediumSlateBlue) 1
    set CN(LightSlateBlue) 1
    set CN(MediumBlue) 1
    set CN(RoyalBlue) 1
    set CN(blue) 1
    set CN(DodgerBlue) 1
    set CN(DeepSkyBlue) 1
    set CN(SkyBlue) 1
    set CN(LightSkyBlue) 1
    set CN(SteelBlue) 1
    set CN(LightSteelBlue) 1
    set CN(LightBlue) 1
    set CN(PowderBlue) 1
    set CN(PaleTurquoise) 1
    set CN(DarkTurquoise) 1
    set CN(MediumTurquoise) 1
    set CN(turquoise) 1
    set CN(cyan) 1
    set CN(LightCyan) 1
    set CN(CadetBlue) 1
    set CN(MediumAquamarine) 1
    set CN(aquamarine) 1
    set CN(DarkGreen) 1
    set CN(DarkOliveGreen) 1
    set CN(DarkSeaGreen) 1
    set CN(SeaGreen) 1
    set CN(MediumSeaGreen) 1
    set CN(LightSeaGreen) 1
    set CN(PaleGreen) 1
    set CN(SpringGreen) 1
    set CN(LawnGreen) 1
    set CN(green) 1
    set CN(chartreuse) 1
    set CN(MediumSpringGreen) 1
    set CN(GreenYellow) 1
    set CN(LimeGreen) 1
    set CN(YellowGreen) 1
    set CN(ForestGreen) 1
    set CN(OliveDrab) 1
    set CN(DarkKhaki) 1
    set CN(khaki) 1
    set CN(PaleGoldenrod) 1
    set CN(LightGoldenrodYellow) 1
    set CN(LightYellow) 1
    set CN(yellow) 1
    set CN(gold) 1
    set CN(LightGoldenrod) 1
    set CN(goldenrod) 1
    set CN(DarkGoldenrod) 1
    set CN(RosyBrown) 1
    set CN(IndianRed) 1
    set CN(SaddleBrown) 1
    set CN(sienna) 1
    set CN(peru) 1
    set CN(burlywood) 1
    set CN(beige) 1
    set CN(wheat) 1
    set CN(SandyBrown) 1
    set CN(tan) 1
    set CN(chocolate) 1
    set CN(firebrick) 1
    set CN(brown) 1
    set CN(DarkSalmon) 1
    set CN(salmon) 1
    set CN(LightSalmon) 1
    set CN(orange) 1
    set CN(DarkOrange) 1
    set CN(coral) 1
    set CN(LightCoral) 1
    set CN(tomato) 1
    set CN(OrangeRed) 1
    set CN(red) 1
    set CN(HotPink) 1
    set CN(DeepPink) 1
    set CN(pink) 1
    set CN(LightPink) 1
    set CN(PaleVioletRed) 1
    set CN(maroon) 1
    set CN(MediumVioletRed) 1
    set CN(VioletRed) 1
    set CN(magenta) 1
    set CN(violet) 1
    set CN(plum) 1
    set CN(orchid) 1
    set CN(MediumOrchid) 1
    set CN(DarkOrchid) 1
    set CN(DarkViolet) 1
    set CN(BlueViolet) 1
    set CN(purple) 1
    set CN(MediumPurple) 1
    set CN(thistle) 1
    set CN(snow1) 1
    set CN(snow2) 1
    set CN(snow3) 1
    set CN(snow4) 1
    set CN(seashell1) 1
    set CN(seashell2) 1
    set CN(seashell3) 1
    set CN(seashell4) 1
    set CN(AntiqueWhite1) 1
    set CN(AntiqueWhite2) 1
    set CN(AntiqueWhite3) 1
    set CN(AntiqueWhite4) 1
    set CN(bisque1) 1
    set CN(bisque2) 1
    set CN(bisque3) 1
    set CN(bisque4) 1
    set CN(PeachPuff1) 1
    set CN(PeachPuff2) 1
    set CN(PeachPuff3) 1
    set CN(PeachPuff4) 1
    set CN(NavajoWhite1) 1
    set CN(NavajoWhite2) 1
    set CN(NavajoWhite3) 1
    set CN(NavajoWhite4) 1
    set CN(LemonChiffon1) 1
    set CN(LemonChiffon2) 1
    set CN(LemonChiffon3) 1
    set CN(LemonChiffon4) 1
    set CN(cornsilk1) 1
    set CN(cornsilk2) 1
    set CN(cornsilk3) 1
    set CN(cornsilk4) 1
    set CN(ivory1) 1
    set CN(ivory2) 1
    set CN(ivory3) 1
    set CN(ivory4) 1
    set CN(honeydew1) 1
    set CN(honeydew2) 1
    set CN(honeydew3) 1
    set CN(honeydew4) 1
    set CN(LavenderBlush1) 1
    set CN(LavenderBlush2) 1
    set CN(LavenderBlush3) 1
    set CN(LavenderBlush4) 1
    set CN(MistyRose1) 1
    set CN(MistyRose2) 1
    set CN(MistyRose3) 1
    set CN(MistyRose4) 1
    set CN(azure1) 1
    set CN(azure2) 1
    set CN(azure3) 1
    set CN(azure4) 1
    set CN(SlateBlue1) 1
    set CN(SlateBlue2) 1
    set CN(SlateBlue3) 1
    set CN(SlateBlue4) 1
    set CN(RoyalBlue1) 1
    set CN(RoyalBlue2) 1
    set CN(RoyalBlue3) 1
    set CN(RoyalBlue4) 1
    set CN(blue1) 1
    set CN(blue2) 1
    set CN(blue3) 1
    set CN(blue4) 1
    set CN(DodgerBlue1) 1
    set CN(DodgerBlue2) 1
    set CN(DodgerBlue3) 1
    set CN(DodgerBlue4) 1
    set CN(SteelBlue1) 1
    set CN(SteelBlue2) 1
    set CN(SteelBlue3) 1
    set CN(SteelBlue4) 1
    set CN(DeepSkyBlue1) 1
    set CN(DeepSkyBlue2) 1
    set CN(DeepSkyBlue3) 1
    set CN(DeepSkyBlue4) 1
    set CN(SkyBlue1) 1
    set CN(SkyBlue2) 1
    set CN(SkyBlue3) 1
    set CN(SkyBlue4) 1
    set CN(LightSkyBlue1) 1
    set CN(LightSkyBlue2) 1
    set CN(LightSkyBlue3) 1
    set CN(LightSkyBlue4) 1
    set CN(SlateGray1) 1
    set CN(SlateGray2) 1
    set CN(SlateGray3) 1
    set CN(SlateGray4) 1
    set CN(LightSteelBlue1) 1
    set CN(LightSteelBlue2) 1
    set CN(LightSteelBlue3) 1
    set CN(LightSteelBlue4) 1
    set CN(LightBlue1) 1
    set CN(LightBlue2) 1
    set CN(LightBlue3) 1
    set CN(LightBlue4) 1
    set CN(LightCyan1) 1
    set CN(LightCyan2) 1
    set CN(LightCyan3) 1
    set CN(LightCyan4) 1
    set CN(PaleTurquoise1) 1
    set CN(PaleTurquoise2) 1
    set CN(PaleTurquoise3) 1
    set CN(PaleTurquoise4) 1
    set CN(CadetBlue1) 1
    set CN(CadetBlue2) 1
    set CN(CadetBlue3) 1
    set CN(CadetBlue4) 1
    set CN(turquoise1) 1
    set CN(turquoise2) 1
    set CN(turquoise3) 1
    set CN(turquoise4) 1
    set CN(cyan1) 1
    set CN(cyan2) 1
    set CN(cyan3) 1
    set CN(cyan4) 1
    set CN(DarkSlateGray1) 1
    set CN(DarkSlateGray2) 1
    set CN(DarkSlateGray3) 1
    set CN(DarkSlateGray4) 1
    set CN(aquamarine1) 1
    set CN(aquamarine2) 1
    set CN(aquamarine3) 1
    set CN(aquamarine4) 1
    set CN(DarkSeaGreen1) 1
    set CN(DarkSeaGreen2) 1
    set CN(DarkSeaGreen3) 1
    set CN(DarkSeaGreen4) 1
    set CN(SeaGreen1) 1
    set CN(SeaGreen2) 1
    set CN(SeaGreen3) 1
    set CN(SeaGreen4) 1
    set CN(PaleGreen1) 1
    set CN(PaleGreen2) 1
    set CN(PaleGreen3) 1
    set CN(PaleGreen4) 1
    set CN(SpringGreen1) 1
    set CN(SpringGreen2) 1
    set CN(SpringGreen3) 1
    set CN(SpringGreen4) 1
    set CN(green1) 1
    set CN(green2) 1
    set CN(green3) 1
    set CN(green4) 1
    set CN(chartreuse1) 1
    set CN(chartreuse2) 1
    set CN(chartreuse3) 1
    set CN(chartreuse4) 1
    set CN(OliveDrab1) 1
    set CN(OliveDrab2) 1
    set CN(OliveDrab3) 1
    set CN(OliveDrab4) 1
    set CN(DarkOliveGreen1) 1
    set CN(DarkOliveGreen2) 1
    set CN(DarkOliveGreen3) 1
    set CN(DarkOliveGreen4) 1
    set CN(khaki1) 1
    set CN(khaki2) 1
    set CN(khaki3) 1
    set CN(khaki4) 1
    set CN(LightGoldenrod1) 1
    set CN(LightGoldenrod2) 1
    set CN(LightGoldenrod3) 1
    set CN(LightGoldenrod4) 1
    set CN(LightYellow1) 1
    set CN(LightYellow2) 1
    set CN(LightYellow3) 1
    set CN(LightYellow4) 1
    set CN(yellow1) 1
    set CN(yellow2) 1
    set CN(yellow3) 1
    set CN(yellow4) 1
    set CN(gold1) 1
    set CN(gold2) 1
    set CN(gold3) 1
    set CN(gold4) 1
    set CN(goldenrod1) 1
    set CN(goldenrod2) 1
    set CN(goldenrod3) 1
    set CN(goldenrod4) 1
    set CN(DarkGoldenrod1) 1
    set CN(DarkGoldenrod2) 1
    set CN(DarkGoldenrod3) 1
    set CN(DarkGoldenrod4) 1
    set CN(RosyBrown1) 1
    set CN(RosyBrown2) 1
    set CN(RosyBrown3) 1
    set CN(RosyBrown4) 1
    set CN(IndianRed1) 1
    set CN(IndianRed2) 1
    set CN(IndianRed3) 1
    set CN(IndianRed4) 1
    set CN(sienna1) 1
    set CN(sienna2) 1
    set CN(sienna3) 1
    set CN(sienna4) 1
    set CN(burlywood1) 1
    set CN(burlywood2) 1
    set CN(burlywood3) 1
    set CN(burlywood4) 1
    set CN(wheat1) 1
    set CN(wheat2) 1
    set CN(wheat3) 1
    set CN(wheat4) 1
    set CN(tan1) 1
    set CN(tan2) 1
    set CN(tan3) 1
    set CN(tan4) 1
    set CN(chocolate1) 1
    set CN(chocolate2) 1
    set CN(chocolate3) 1
    set CN(chocolate4) 1
    set CN(firebrick1) 1
    set CN(firebrick2) 1
    set CN(firebrick3) 1
    set CN(firebrick4) 1
    set CN(brown1) 1
    set CN(brown2) 1
    set CN(brown3) 1
    set CN(brown4) 1
    set CN(salmon1) 1
    set CN(salmon2) 1
    set CN(salmon3) 1
    set CN(salmon4) 1
    set CN(LightSalmon1) 1
    set CN(LightSalmon2) 1
    set CN(LightSalmon3) 1
    set CN(LightSalmon4) 1
    set CN(orange1) 1
    set CN(orange2) 1
    set CN(orange3) 1
    set CN(orange4) 1
    set CN(DarkOrange1) 1
    set CN(DarkOrange2) 1
    set CN(DarkOrange3) 1
    set CN(DarkOrange4) 1
    set CN(coral1) 1
    set CN(coral2) 1
    set CN(coral3) 1
    set CN(coral4) 1
    set CN(tomato1) 1
    set CN(tomato2) 1
    set CN(tomato3) 1
    set CN(tomato4) 1
    set CN(OrangeRed1) 1
    set CN(OrangeRed2) 1
    set CN(OrangeRed3) 1
    set CN(OrangeRed4) 1
    set CN(red1) 1
    set CN(red2) 1
    set CN(red3) 1
    set CN(red4) 1
    set CN(DeepPink1) 1
    set CN(DeepPink2) 1
    set CN(DeepPink3) 1
    set CN(DeepPink4) 1
    set CN(HotPink1) 1
    set CN(HotPink2) 1
    set CN(HotPink3) 1
    set CN(HotPink4) 1
    set CN(pink1) 1
    set CN(pink2) 1
    set CN(pink3) 1
    set CN(pink4) 1
    set CN(LightPink1) 1
    set CN(LightPink2) 1
    set CN(LightPink3) 1
    set CN(LightPink4) 1
    set CN(PaleVioletRed1) 1
    set CN(PaleVioletRed2) 1
    set CN(PaleVioletRed3) 1
    set CN(PaleVioletRed4) 1
    set CN(maroon1) 1
    set CN(maroon2) 1
    set CN(maroon3) 1
    set CN(maroon4) 1
    set CN(VioletRed1) 1
    set CN(VioletRed2) 1
    set CN(VioletRed3) 1
    set CN(VioletRed4) 1
    set CN(magenta1) 1
    set CN(magenta2) 1
    set CN(magenta3) 1
    set CN(magenta4) 1
    set CN(orchid1) 1
    set CN(orchid2) 1
    set CN(orchid3) 1
    set CN(orchid4) 1
    set CN(plum1) 1
    set CN(plum2) 1
    set CN(plum3) 1
    set CN(plum4) 1
    set CN(MediumOrchid1) 1
    set CN(MediumOrchid2) 1
    set CN(MediumOrchid3) 1
    set CN(MediumOrchid4) 1
    set CN(DarkOrchid1) 1
    set CN(DarkOrchid2) 1
    set CN(DarkOrchid3) 1
    set CN(DarkOrchid4) 1
    set CN(purple1) 1
    set CN(purple2) 1
    set CN(purple3) 1
    set CN(purple4) 1
    set CN(MediumPurple1) 1
    set CN(MediumPurple2) 1
    set CN(MediumPurple3) 1
    set CN(MediumPurple4) 1
    set CN(thistle1) 1
    set CN(thistle2) 1
    set CN(thistle3) 1
    set CN(thistle4) 1
    set CN(gray0) 1
    set CN(grey0) 1
    set CN(gray1) 1
    set CN(grey1) 1
    set CN(gray2) 1
    set CN(grey2) 1
    set CN(gray3) 1
    set CN(grey3) 1
    set CN(gray4) 1
    set CN(grey4) 1
    set CN(gray5) 1
    set CN(grey5) 1
    set CN(gray6) 1
    set CN(grey6) 1
    set CN(gray7) 1
    set CN(grey7) 1
    set CN(gray8) 1
    set CN(grey8) 1
    set CN(gray9) 1
    set CN(grey9) 1
    set CN(gray10) 1
    set CN(grey10) 1
    set CN(gray11) 1
    set CN(grey11) 1
    set CN(gray12) 1
    set CN(grey12) 1
    set CN(gray13) 1
    set CN(grey13) 1
    set CN(gray14) 1
    set CN(grey14) 1
    set CN(gray15) 1
    set CN(grey15) 1
    set CN(gray16) 1
    set CN(grey16) 1
    set CN(gray17) 1
    set CN(grey17) 1
    set CN(gray18) 1
    set CN(grey18) 1
    set CN(gray19) 1
    set CN(grey19) 1
    set CN(gray20) 1
    set CN(grey20) 1
    set CN(gray21) 1
    set CN(grey21) 1
    set CN(gray22) 1
    set CN(grey22) 1
    set CN(gray23) 1
    set CN(grey23) 1
    set CN(gray24) 1
    set CN(grey24) 1
    set CN(gray25) 1
    set CN(grey25) 1
    set CN(gray26) 1
    set CN(grey26) 1
    set CN(gray27) 1
    set CN(grey27) 1
    set CN(gray28) 1
    set CN(grey28) 1
    set CN(gray29) 1
    set CN(grey29) 1
    set CN(gray30) 1
    set CN(grey30) 1
    set CN(gray31) 1
    set CN(grey31) 1
    set CN(gray32) 1
    set CN(grey32) 1
    set CN(gray33) 1
    set CN(grey33) 1
    set CN(gray34) 1
    set CN(grey34) 1
    set CN(gray35) 1
    set CN(grey35) 1
    set CN(gray36) 1
    set CN(grey36) 1
    set CN(gray37) 1
    set CN(grey37) 1
    set CN(gray38) 1
    set CN(grey38) 1
    set CN(gray39) 1
    set CN(grey39) 1
    set CN(gray40) 1
    set CN(grey40) 1
    set CN(gray41) 1
    set CN(grey41) 1
    set CN(gray42) 1
    set CN(grey42) 1
    set CN(gray43) 1
    set CN(grey43) 1
    set CN(gray44) 1
    set CN(grey44) 1
    set CN(gray45) 1
    set CN(grey45) 1
    set CN(gray46) 1
    set CN(grey46) 1
    set CN(gray47) 1
    set CN(grey47) 1
    set CN(gray48) 1
    set CN(grey48) 1
    set CN(gray49) 1
    set CN(grey49) 1
    set CN(gray50) 1
    set CN(grey50) 1
    set CN(gray51) 1
    set CN(grey51) 1
    set CN(gray52) 1
    set CN(grey52) 1
    set CN(gray53) 1
    set CN(grey53) 1
    set CN(gray54) 1
    set CN(grey54) 1
    set CN(gray55) 1
    set CN(grey55) 1
    set CN(gray56) 1
    set CN(grey56) 1
    set CN(gray57) 1
    set CN(grey57) 1
    set CN(gray58) 1
    set CN(grey58) 1
    set CN(gray59) 1
    set CN(grey59) 1
    set CN(gray60) 1
    set CN(grey60) 1
    set CN(gray61) 1
    set CN(grey61) 1
    set CN(gray62) 1
    set CN(grey62) 1
    set CN(gray63) 1
    set CN(grey63) 1
    set CN(gray64) 1
    set CN(grey64) 1
    set CN(gray65) 1
    set CN(grey65) 1
    set CN(gray66) 1
    set CN(grey66) 1
    set CN(gray67) 1
    set CN(grey67) 1
    set CN(gray68) 1
    set CN(grey68) 1
    set CN(gray69) 1
    set CN(grey69) 1
    set CN(gray70) 1
    set CN(grey70) 1
    set CN(gray71) 1
    set CN(grey71) 1
    set CN(gray72) 1
    set CN(grey72) 1
    set CN(gray73) 1
    set CN(grey73) 1
    set CN(gray74) 1
    set CN(grey74) 1
    set CN(gray75) 1
    set CN(grey75) 1
    set CN(gray76) 1
    set CN(grey76) 1
    set CN(gray77) 1
    set CN(grey77) 1
    set CN(gray78) 1
    set CN(grey78) 1
    set CN(gray79) 1
    set CN(grey79) 1
    set CN(gray80) 1
    set CN(grey80) 1
    set CN(gray81) 1
    set CN(grey81) 1
    set CN(gray82) 1
    set CN(grey82) 1
    set CN(gray83) 1
    set CN(grey83) 1
    set CN(gray84) 1
    set CN(grey84) 1
    set CN(gray85) 1
    set CN(grey85) 1
    set CN(gray86) 1
    set CN(grey86) 1
    set CN(gray87) 1
    set CN(grey87) 1
    set CN(gray88) 1
    set CN(grey88) 1
    set CN(gray89) 1
    set CN(grey89) 1
    set CN(gray90) 1
    set CN(grey90) 1
    set CN(gray91) 1
    set CN(grey91) 1
    set CN(gray92) 1
    set CN(grey92) 1
    set CN(gray93) 1
    set CN(grey93) 1
    set CN(gray94) 1
    set CN(grey94) 1
    set CN(gray95) 1
    set CN(grey95) 1
    set CN(gray96) 1
    set CN(grey96) 1
    set CN(gray97) 1
    set CN(grey97) 1
    set CN(gray98) 1
    set CN(grey98) 1
    set CN(gray99) 1
    set CN(grey99) 1
    set CN(gray100) 1
    set CN(grey100) 1

    proc GetColorNames {} {
	variable CN
	return [lsort -dictionary [array names CN]]
    }

    proc IsColorNameQ {s} {
	variable CN
	if {[info exists CN($s)]} {
	    return 1;
	} else {
	    return 0;
	}
    }

    proc IsColorNumericQ {s} {
	return [regexp \
		    {^\#([[:xdigit:]]{6}|[[:xdigit:]]{3}|[[:xdigit:]]{9}|[[:xdigit:]]{12})$} $s]
    }
		
    proc IsColorSpecQ {s} {
	if {[IsColorNameQ $s]} {
	    return 1;
	} elseif {[IsColorNumericQ $s]} {
	    return 1;
	} else {
	    return 0;
	}
    }
}
#End of namespace validcolor

proc PopupColorNameList {} {
    if {[PopupDown ColorNameList] ==1} {return}
    set po  [CreateTextDisplay [_ "Color Names"] 65 10];
    set ::PopupList(ColorNameList) $po;
    BindKeys $po;
    set n 0;
    foreach l [::validcolor::GetColorNames] {
	incr n;
	AppendToTextDisplay $po [format "\[%03d\] %s\n" $n $l];
    }
}

#Ths procedure takes as its sole argument the name
#of an existing procedure in the same interpreter
#and creates a new master level procedure that
#wraps the other procedure with a test for the
#correct argument count.

proc WrapMaster {pn} {
    regsub "^::fontsel::" $pn "" Stem
    set WrappedName Wrapped${Stem};
    set sp [format "proc $WrappedName \{args\} \{\n"];
    set ArgsNeeded [llength [info args $pn]];
    append sp [format "\tif \{\[llength \$args\] != %d\} \{\n" $ArgsNeeded]
    if {$ArgsNeeded == 1} {
	set emsg [format [_ "The command %s in the file %%s expects one argument"] \
	[SlaveName $WrappedName]]
	set cmd [format "\t\tputs \"$emsg\"\n" \$::InitFile]
	append sp $cmd
    } else {
	set emsg [format [_ "The command %s in the file %%s expects %d arguments\n"] \
	      [SlaveName $WrappedName] $ArgsNeeded]
	set cmd [format "\t\tputs \"$emsg\"\n" \$::InitFile]; 
	append sp $cmd;
    }
    append sp "\t\treturn;\n\t\}\n\t"
    append sp  $pn
    for {set i 0} {$i < $ArgsNeeded} {incr i} {
	append sp " \[lindex \$args $i\]"
    }
    append sp "\n\}"
    eval $sp;
    return $WrappedName;
}

proc ReadInitFile {name} {
    if { [catch {interp invoke init source $name} msg] } {
	puts [format [_  "Error on reading init file %s: %s"] $name $msg]
    } else {
	ShowMessage [format [_ "Executed init file %s"] $name]
    }
    interp delete init
}

proc SlavePuts {msg} {
    puts $msg;
}

proc GetLocale {} {
    package require msgcat
    return [::msgcat::mclocale]
}

proc SlaveMsgcat {} {
    package require msgcat
    ::msgcat::mcload [file join [file dirname [info script]] msgs];
}

proc SetCharacterName {c s} {
    set ::UName($c) $s;
}

#This is the list of the master interpreter commands
#other than those generated from data structures (currently
#color- and font-setting) that we wish to expose for use in
#the init file slave interpreter.
set MiscellaneousSlaveCommandList {
    AddUserPaletteEntry
    DefineCharacterClass
    DefineShortcut
    GetLocale
    ReadFeatureList
    SelectBrowser
    SelectProgramInitFile
    SetAccentedLetterColumns
    SetAgrepBestResultsP
    SetAgrepCaseInsensitiveP
    SetAgrepDeletionCost
    SetAgrepErrorLimit
    SetAgrepInsertionCost
    SetAgrepSubstitutionCost
    SetArenaCaseInsensitiveP
    SetArenaVerboseP
    SetAutoClearRegexpP
    SetBalloonHelpShowP
    SetBashExtendedP
    SetBusyBoxEgrepCaseInsensitiveP
    SetBusyBoxEgrepComplementP
    SetCgrepCaseInsensitiveP
    SetCgrepComplementP
    SetCgrepDeletionCost
    SetCgrepExtendedP
    SetCgrepInsertionCost
    SetCgrepSubstitutionCost
    SetCgrepTotalCost
    SetCharacterName
    SetComparisonDataEncoding
    SetDisplayConsonantChartColumnLabelsP
    SetDisplayConsonantChartRowLabelsP
    SetDisplayVowelChartColumnLabelsP
    SetDisplayVowelChartRowLabelsP
    SetEgrepCaseInsensitiveP
    SetEgrepComplementP
    SetEgrepEmitMatchOnlyP
    SetEmacsFoldCaseMatchP 
    SetEmacsFoldCaseReplaceP 
    SetFgrepCaseInsensitiveP
    SetFgrepComplementP
    SetFgrepEmitMatchOnlyP
    SetFocusFollowsMouseP
    SetGawkCaseInsensitiveP
    SetGawkIntervalExpressionsP
    SetGawkNotation
    SetGlarkCaseInsensitiveP
    SetGlarkComplementP
    SetGlarkEmitMatchOnlyP
    SetGlarkMatchEntireLineP
    SetGrepCaseInsensitiveP
    SetGrepComplementP
    SetGrepEmitMatchOnlyP
    SetGrepNotation
    SetHistoryCentralP
    SetHistoryIncludeProgramP
    SetIciCaseInsensitiveP
    SetIciVerboseP
    SetJavaCanonEQP
    SetJavaCaseInsensitiveP
    SetJavaUnicodeCaseP
    SetJgrepCaseInsensitiveP
    SetLeftUserClassIntersectionDelimiter
    SetMysqlRegexpP
    SetNrgrepCaseInsensitiveP
    SetNrgrepComplementP
    SetNrgrepDeletionsP
    SetNrgrepInsertionsP
    SetNrgrepSubstitutionsP
    SetNrgrepTotalCost
    SetNrgrepTranspositionsP
    SetNumgrepOutputNumberByNumberP
    SetOutputOnlyChangedLinesP
    SetPaletteHeightLimit
    SetPatmatchMismatchNumber
    SetPatmatchMismatchTypes
    SetPatmatchResidueType
    SetPcregrepCaseInsensitiveP
    SetPcregrepComplementP
    SetPcregrepEmitMatchOnlyP
    SetPerlUnicodeLocaleDependentP
    SetPythonRawStringP
    SetResultEncoding
    SetRightUserClassIntersectionDelimiter
    SetSedExtendedRegexpP
    SetSgrepCaseInsensitiveP
    SetShellItemLimit
    SetSsedPOSIXP
    SetSsedRegexpType
    SetStandardLayoutP
    SetTclCaseInsensitiveP
    SetTclEmitMatchOnlyP
    SetTclExpandedP
    SetTestDataEncoding
    SetTrComplementP
    SetTrSqueezeP
    SetTrTruncateP
    SetUseScrollbarsP
    SetUserClassesEnabledP
    SetVimCaseInsensitiveP
    SetVimSmartCaseP
    SetVimSubstitutionGlobalP
    SetZshExtendedGlobP
    SetZshKornQuantifiersP
    StoreCustomCharacterChartFileName
    StoreCustomCharacterChartInPlace
    SubstitutionModeInitFileP
}
#Add to above list when sgrep is ready:    SetSgrepCaseInsensitiveP

#This procedure creates the master procedures that will be exposed
#in the slave interpreter. It takes care of creating the base procedures
#where, as in the case of color and font setting, these are created
#programmatically, then wraps these as well as the manually
#written procedures that are to be exposed.
proc CreateInitProcs {} {
    set ::FontProcList "";
    fontsel::DefineFontSettingProcs
    DefineColorSettingProcs;
    #This is the complete list of commands that we want to expose 
    #in the slave init file interpreter. These are the raw, unwrapped, master
    #level commands.
    set ::MasterCommandsToBeExposedInInitList [concat \
	   [lsort $::ColorProcList] \
	   [lsort $::FontProcList]  \
	   [lsort $::MiscellaneousSlaveCommandList]];
    #Now we wrap them all so as to trap valence errors
    set ::WrappedMasterCommandList [list]
    foreach c $::MasterCommandsToBeExposedInInitList {
	lappend ::WrappedMasterCommandList [WrapMaster $c]
    }
}

#This procedure takes the list of wrapped master
#procedures and exposes them in a specified, already
#created, slave interpreter.
proc ExposeInitProcs {Interpreter} {
    foreach c $::WrappedMasterCommandList {
	set sl [SlaveName $c];
	$Interpreter alias $sl $c;
    }
}

set MasterToSlaveName(SetDisplayConsonantChartColumnLabelsP) ShowConsonantChartColumnLabelsP
set MasterToSlaveName(SetDisplayConsonantChartRowLabelsP) ShowConsonantChartRowLabelsP
set MasterToSlaveName(SetDisplayVowelChartColumnLabelsP) ShowVowelChartColumnLabelsP
set MasterToSlaveName(SetDisplayVowelChartRowLabelsP) ShowVowelChartRowLabelsP
set MasterToSlaveName(SelectProgramInitFile) Program;
set MasterToSlaveName(SelectBrowser) Browser;
set MasterToSlaveName(SlavePuts) Puts;
set MasterToSlaveName(StoreCustomCharacterChartInPlace) DefineCharacterChart 
set MasterToSlaveName(StoreCustomCharacterChartFileName) ReadCharacterChart 
set MasterToSlaveName(SubstitutionModeInitFileP) SubstitutionModeP

#Given the name of a wrapped command in the master interpreter,
#returns the name that the command is to have when
#exposed in the slave interpreter. In most cases the alias
#is computed from the master name, but in some cases
#the relationship is irregular. 
proc SlaveName {command} {
    regsub "^Wrapped" $command "" Unwrapped
    if {[info exists ::MasterToSlaveName($Unwrapped)]} {
	set EnglishSlaveName $::MasterToSlaveName($Unwrapped);
    } else {
	regsub "^Set" $Unwrapped "" EnglishSlaveName
    }
    return [_ $EnglishSlaveName]
}

proc InitFileSetup {} {
    interp create -safe -- init
    #We use slaveMsgcat rather than SlaveMsgcat so that the name does not
    #appear in the list that the user sees.
    init alias slaveMsgcat SlaveMsgcat
    init eval slaveMsgcat
    init alias mc _
    ExposeInitProcs init
    #This takes care of errors in the name of commands while still in the
    #slave interpreter, without aborting, and using the user-name in the error-message.
    init eval {
	proc unknown {args} {
	    set cmd [lindex $args 0]
	    Puts [format  [mc "Unknown command %s in script file %s."]  $cmd [info script]];
#	    Puts [format  [mc "Unknown command %1\$s in script file %2\$s."]  $cmd [info script]];
	    return ;
	}
    }
}

proc SlaveBoolean {s} {
    switch -regexp $s {
	1	{return 1}
	T.*	{return 1}
	t.*	{return 1}
	Y.*	{return 1}
	y.*	{return 1}
	ok	{return 1}
	on	{return 1}
	0 	{return 0}
	F.*	{return 0}
	f.*	{return 0}
	N.*	{return 0}
	n.*	{return 0}
	off	{return 0}
	default {
	    puts [format [_ "%s is not a Boolean argument."] $s]
	    return -1; 
	}
    }
}

#We can't just call SelectProgram from the init file
#because, for other reasons, we need to read the init
#file before enough of the infrastructure for SelectProgram
#is ready. We therefore just record the choice and execute
#SelectProgram later. 
proc SelectProgramInitFile {p} {
    set ::CommandLineProgram $p;
}

proc SubstitutionModeInitFileP {b} {
    set ::BeginInSubstitutionModeP [Boolean $b];
}


proc ReadFeatureList {args} {
    if {[llength $args]} {
	set fn [lindex $args 0]
    } else {
	set fn [tk_getOpenFile -title [_ "Read Feature List"]];
	if {[string equal $fn ""]} {
	    ShowMessage [_ "File selection cancelled."];
	    return ;
	}
    }
    if { [catch {open $fn "r"} fhd ] != 0} {
	ShowMessage [format [_ "Unable to open feature list %s."] [MinimizeFileName $fn]];
	return ;
    }
    set LineCnt 0
    while { [gets $fhd line] > 0} {
	if {$LineCnt == 0} {
	    set linep [split $line]
	    if {[llength $linep] != 2} {
		ShowMessage [_ "Header of file %s ill-formed."]
		close $fhd;
		return ;
	    }
	    set p [lindex $linep 0]
	    set l [lindex $linep 1]
	} else {
	    if {[scan $line "%s %s" Feature Value] != 2} {
		ShowMessage [format [_ "Ill-formed entry at line %d of file %s."] $LineCnt \
				 [MinimizeFileName $fn]]
		close $fhd;
		return
	    } else {
		set FTemp($Feature,$p,$l) $Value;
	    }
	}
	incr LineCnt;
    }
    close $fhd;
    if {$LineCnt < 1} {
	ShowMessage [_ "File %s is empty" [MinimizeFileName $fn]]
	return
    }
    foreach f [array names FTemp] {
	set ::Features($f) [Boolean $FTemp($f)]
    }
    SetCompoundFeatures;
    ShowMessage [format [_ "Read feature list for program %s in locale %s from %s."] $p $l \
		     [MinimizeFielName $fn]]
    if {[string equal $p $::program] && [string equal $l $::InterfaceLocale]} {
	ConstructPalette;
    }
}

#New structure for UserPalette
#	UserPalette(Program,Name) -> [list Body Etext]

proc AddUserPaletteEntry {Which Name Body {EText ""}} {
    global UserPalette;
    incr UserPalette($Which,0);
    set UserPalette($Which,$Name) [list $Body [list $EText]];
}

#If the filename passed as argument is a pathname
#leading to a file in the current working directory,
#return just the basename+extension. Otherwise
#return the argument.
proc MinimizeFileName {s} {
    set cwd [pwd];
    set sdir [file dirname $s]
    if {[string equal $cwd $sdir]} {
	return [file tail $s]
    } else {
	return $s;
    }
}


#This is where the main action begins
#Entrypoint.


proc PathToFileURL {p} {
    return [format "file://%s" $p];
}

set HomeDir [GetHomeDir];
set ColorFullPath [file join $HomeDir $ColorFile];
set ScriptPath [info script];
if {$DebugP} {
    set ManualDirectory [file join [file dir $ScriptPath] Manual];
} else {
    set ManualDirectory [file join $NonBinPath Manual];
}
set ManualPath [file join $ManualDirectory Manual.html];
set ManualURL [PathToFileURL $ManualPath];

set InterfaceLocale [::msgcat::mclocale];
LoadMessageCatalog;

# Find out whether we have GNU diff
if {$UseDiffP} {
    set GNUDiffP 0;
    if { [string length [auto_execok diff]]  != 0 } {
	if {[regexp "GNU diffutils" [lindex [split [exec diff -v] '\n'] 0]]}  {
	    set GNUDiffP 1;
	}
    }
}

#Open the journal file.
set JournalFullPath [file join $HomeDir $JournalFile];
if {[catch {open $JournalFullPath "a"} JournalHandle ] != 0} {
    puts [format [_ "Unable to open journal file %s."] $JournalFullPath];
    exit 2;
}
WriteJournal [format [_ "Session started: %s in directory %s"] [clock format [clock seconds]] [pwd]];

proc argshift {k} {
    set ::argv [lrange $::argv $k end];
}

set CommandLineUserClassFile "";
#Get command line arguments
while {[string match -* [lindex $argv 0]]} {
    switch -regexp -- [lindex $argv 0] {
	--?c.* {
	    set CommandLineUserClassFile [lindex $argv 1];
	    argshift 2;
	} 
	--?d.* {
	    set DebugP 1;
	    argshift 1;
	}
	--?F.* {
	    lappend FeatureFileList [lindex $argv 1]
	    argshift 2;
	} 
	--?f.* {
	    set PipeP 1;
	    argshift 1;
	}
	--?H.* {
	    set ReadHistoryFileP 0;
	    argshift 1;
	}
	--?h.* {
	    Usage;
	    exit 0;
	}
	--?I.* {
	    set InitFile [lindex $argv 1]
	    argshift 2;
	}
	--?i.* {
	    set ReadInitFileP 0;
	    argshift 1;
	}
	--?l.* {
	    set CommandLineInterfaceLocale [lindex $argv 1];
	    argshift 2;
	    set nl [SetInterfaceLocale $CommandLineInterfaceLocale]
	    if {[string equal $nl ""] == 0} {
		set InterfaceLocale $nl;
		LoadMessageCatalog;
	    }
	}
	--?n.* {
	    set FeatureTestP 0;
	    argshift 1;
	}
	--?P.* {
	    CheckProgramAvailability
	    ListSupportedPrograms stdout
	    exit 0
	}
	--?p.* {
	    set CommandLineProgram [lindex $argv 1];
	    argshift 2;
	}
	--?s.* {
	    set BeginInSubstitutionModeP 1;
	    argshift 1
	}
	--?t.* {
	    set FeatureTestDebugP 1;
	    argshift 1
	}
	--?v.* {
	    puts "Redet $Version";
	    exit 0;
	}
	default {
	    puts [format [_ "Command line option %s not recognized."] [lindex $argv 0]];
	    Usage;
	    exit 0;
	}
    }
};					# End of while



proc UnicodeStringToHex {s AsciiTooP} {
    set rv "";
    foreach c [split $s ""] {
	scan $c "%c" t
	if {($t <= 0xFF) && !$AsciiTooP} {
	    append rv $c;
	} else {
	    append rv [format " U+%04X" $t];
	}
	append rv " "
    }
    return $rv;
 }

proc NameUChars {s} {
    set ns ""
    foreach c [split $s ""] {
	if {[info exist ::UName($c)]} {
	    append ns [format "%9s" $::UName($c)]
	} else {
	    append ns "  ??  "
	}
	append ns " ";
    }
    return [string trimright $ns " "];
}

proc ShowCode {w x y} {
    $w tag delete match
    set c [format %s,%s $x $y]
    set s [$w get @$c]
    $w tag configure "match" -background $::ColorSpecs(Match,Background);
    $w tag add match @$c "@$c + 1chars"
    ShowMessage [format "%s: %s" [UnicodeStringToHex $s 1] [NameUChars $s]]
} 


dmsg "InterfaceLocale = $InterfaceLocale"
::msgcat::mcset ja "any single character" "foo"
SetCommandGlosses;
foreach fn $FeatureFileList {
    ReadFeatureList $fn
}

puts "Redet $Version";
puts "Copyright (C) 2003-2008 William J. Poser.";
puts [_ "This program is free software; you can redistribute it
and/or modify it under the terms of version 3 of the GNU General
Public License as published by the Free Software Foundation."];

#If there is still a command line argument, it is a file to load as input data.
#We just record the name here as we don't want actually to read it until the windows
#are set up.
if { [llength $argv]} {
    set InitialTestInputDataFile [lindex $argv 0];
}
dmsg "About to create windows";
set PixelHeight 300;
wm geometry . =650x300+100+200
SetTitle $::Version [ProgramTimeDateStamp] $::InterfaceLocale $::DoSubstitutionsP;
#wm title . [_ "Regular Expression Development and Execution Tool"];
set SideWidth [expr $MainWidth / 2];
wm withdraw [fontsel::CreateFontControlPanel]

CreateInitProcs;

dmsg "About to read init file";
if {$ReadInitFileP} {
    InitFileSetup;
    #Look first in current directory, then in home directory.
    if { [file exists $InitFile] } {
	ReadInitFile $InitFile;
    } else {
	set cwd [pwd];
	cd;
	if {[file exists $InitFile] } {
	    ReadInitFile $InitFile;
	}
	cd $cwd;
    }
}
fontsel::SetFontSelectionDefaults
fontsel::RecordDefaults;

option add *Menu.Background $ColorSpecs(Menu,Background) 100
option add *Menu.Foreground $ColorSpecs(Menu,Foreground) 100
option add *Menu*selectColor $ColorSpecs(Menu,Select) 100
option add *Menu.activeBackground $ColorSpecs(Menu,ActiveBackground) 100
option add *Menu.activeForeground  $ColorSpecs(Menu,ActiveForeground) 100

proc MacintoshNotes {} {
    global PopupList;
    if {[PopupDown Macintosh] ==1} {return}
    set po [CreateTextDisplay [_ "Notes for Macintosh Users"] 60 12]
    set PopupList(Macintosh) $po;
    AppendToTextDisplay $po [_ "This program works a bit differently on the Macintosh than on other platforms. One difference is in mouse usage. Several features of the program make use of right-clicks. Since the typical Macintosh uses a single-button mouse, if the program detects that it is running on a Macintosh, it interprets the combination Control-mouse click as equivalent to a right-click.\n\n"]
    AppendToTextDisplay $po [_ "The graphics/windowing system that Redet uses is Tk, for which two implementations are available under MacOSX. One implementation uses X11 as the underlying graphics and window system. This version of Tk is almost identical to the Unix version for which Redet was written. If you use this version of Tk, you should find that Redet looks and behaves just as described in the documentation, which is based in the first instance on the GNU/Linux version of Redet.\n\n"]
    AppendToTextDisplay $po [_ "The other implementation of Tk for MacOSX uses Aqua as the underlying graphics and window system. This version of Tk provides a more native Macintosh look and feel, at the expense of introducing differences between the look and behavior of programs under MacOSX and on other machines. In particular, the Macintosh user interface guidelines, which the Aqua implementation of Tk enforces, allow only menus, not commands, to be placed on the menu bar. As a result, if you are using Tk-Aqua, the File, Program, History, Tools, Configure and Help menus will appear on the Macintosh menu, while the Execute, Clear, and Palette buttons will appear in a row at the top of the Redet window.\n\n"]
    if {$::AquaP} {
	AppendToTextDisplay $po [_ "You are currently using the Aqua implementation of Tk. If you would prefer to have the standard interface for Redet, you will need to install the X11 implementation of Tk as well as X11 itself. As of the Tiger release of Mac OS X, X11 is provided on the distribution CD as an optional componenent."]
    } else {
	AppendToTextDisplay $po [_ "You are currently using the X11 implementation of Tk. This provides the standard interface to Redet. If you prefer a more native Macintosh look-and-feel you can switch to the Aqua implementation of Tk."]
    }
}

proc DescribePrograms {} {
    global Version;
    global tcl_platform;
    if {[PopupDown ProgramInfo] ==1} {return}
    set po [CreateTextDisplay [_ "Programs"] 50 21];
    set ::PopupList(ProgramInfo) $po;
    BindKeys $po;
    AppendToTextDisplay $po "Each program name is a link to information about the program\n\n\n";
    AppendLinkToTextDisplay $po [_ "agrep (Wu-Manber)"] \
	{ShowWebPage ftp://ftp.cs.arizona.edu/agrep};
    AppendToTextDisplay $po "\nWu-Manber agrep is a version of grep that provides for approximate matching, where matches deviating by no more than a specified amount from what the regular expression would otherwise have matched are accepted. The original version was developed by Sun Wu and Udi Manber at the University of Arizona around 1990. Several variants have arisen over the years and it has been ported to a wide range of platforms. TRE agrep provides some facilities that it does not, so if you are using Redet as a search tool TRE agrep is probably the better choice.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "agrep (TRE)"] \
	{ShowWebPage http://laurikari.net/tre};
    AppendToTextDisplay $po "\nTRE agrep is the 'approximate grep' program provided with the TRE regular expression library. This library uses a new, fast regular expression matching algorithm and provides a particularly rich set of regular expression features while at the same time exhibiting better conformance to the POSIX standard than most other implementations. In addition to the standard regular expression constructs, it supports approximate matching. This means that you can associate costs with deviations from what the regular expression would otherwise have matched and request all matches that deviate by no more than a specified cost. Costs may be assigned separately to insertions, deletions, and substitutions on a group-specific basis. TRE agrep is therefore a good choice if you are using Redet as a search tool and the optimal choice if you need approximate matching.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "arena"] \
	{ShowWebPage http://www.minimalinux.org/arena/index.html};
    AppendToTextDisplay $po "\nArena is a scripting language that closely resembles ANSI C in syntax and in its standard libraries. Unlike C, it is interpreted and has automatic memory management. It has runtime polymorphism, anonymous functions, and exceptions. The interpreter is very compact. Its regular expression support is based on PCRE.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "awk"] \
	{ShowWebPage http://cm.bell-labs.com/cm/cs/awkbook/};
    AppendToTextDisplay $po "\nAwk is the classic Unix text processing language. An Awk program consists of a set of patterns with associated actions. Whenever the input matches a pattern, the corresponding action is executed. Awk automatically parses the input into records (by default lines, but changeable) and records into fields (by default, on whitespace, but changeable). Regular expressions are used both in patterns and, by means of calls to builtin functions, in actions.\n\nThere are a number of versions of Awk. The original version was developed at Bell Laboratories by Al Aho, Peter Weinberger, and Brian Kernighan. The link here is to this original version of Awk. Bell Labs later produced a revised version of Awk that is frequently called nawk. The link below is to a free, somewhat modernized version of nawk. What is probably the most widely used version today is gawk, the GNU project Awk implementation. Gawk is roughly comparable to the revised version of ATT Awk.Mawk is another free implementation roughly equivalent to ATT nawk. Note that other versions of Awk,such as Gawk and Nawk, are not infrequently named Awk rather than, or in addition to, Gawk or Nawk  .";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "bash"] \
	{ShowWebPage http://www.gnu.org/software/bash/bash.html};
    AppendToTextDisplay $po "\nBash (the 'born again shell')is one of the two most widely used Unix command interpreters. On many systems it is known as sh rather than, or in addition to, bash, because it is considered to supersede the original Bourne shell.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "busybox egrep"] \
	{ShowWebPage http://www.busybox.net/};
    AppendToTextDisplay $po "\nBusyBox combines tiny versions of many common UNIX utilities into a single small executable. It is intended for embedded systems and other applications in which small file size and memory usage are important. This is is the version of egrep provided by BusyBox.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po "C" \
	{ShowWebPage http://www.gnu.org/software/libc/manual/html_node/Regular-Expressions.html\#Regular-Expressions};
    AppendToTextDisplay $po "\nThe C language does not have built-in regular expressions, but there is a standard regular expression library defined in the POSIX standard which is provided with virtually all C implementations. On systems using the GNU C library, the default regular expressions contain GNU extensions. The C programs generated by Redet define _POSIX_C_SOURCE, which restricts the GNU C library to the POSIX standard.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "cgrep"] \
	{ShowWebPage http://freshmeat.net/projects/cgrep};
    AppendToTextDisplay $po "\nCgrep is an improved and extended version of the original Unix grep program developed by Bill Tannenbaum at Lucent Technologies. Its regular expression matching capabilities are a superset of those of the original egrep (not of GNU egrep), to which it adds approximate matching. It is also reported to be considerably faster. It has an extensive set of options controlling how much of the context surrounding the match to display and some capabilities for multi-line matching.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "ed"] \
	{ShowWebPage http://www.gnu.org/software/ed/ed.html};
    AppendToTextDisplay $po "\nEd is the classic Unix line editor. Although few people use line editors interactively anymore, it remains in use via scripts. Vi and its derivative vim are screen-oriented descendants of ed.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "egrep"] \
	{ShowWebPage http://www.gnu.org/software/grep/};
    AppendToTextDisplay $po "\nGrep is the classic Unix string search program. Egrep is a variant of grep that provided a richer regular expression notation usually known as 'extended regular expression' notation as opposed to 'basic regular expression' notation. On many systems egrep, grep, and fgrep are different names for the same program, which behaves differently depending on the name it is called by and/or the command-line options it is given.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "emacs"] \
	{ShowWebPage http://www.gnu.org/software/emacs/emacs.html};
    AppendToTextDisplay $po "\nEmacs is an extremely powerful fully programmable and extensible text editor. It is really an interpreter for a dialect of LISP with a number of primitives useful for editing. Much of emacs' functionality is implemented indirectly by libraries of emacs lisp code. It is possible to run emacs non-interactively as a powerful text-processing engine.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "euphoria"] \
	{ShowWebPage http://www.rapideuphoria.com/};
    AppendToTextDisplay $po "\nEuphoria is a language with a simple Pascal-like syntax used primarily on the Microsoft Windows platform though it is also available for GNU/Linux and FreeBSD. By some benchmarks it is the fastest of the interpreted languages. Euphoria provides a simple wildcard matching facility but not true regular expression matching."
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "expr"] \
	{ShowWebPage http://www.gnu.org/software/coreutils/manual/html_mono/coreutils.html#Conditions};
    AppendToTextDisplay $po "\nExpr evaluates expressions for use in conditionals in shell scripts."
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "fgrep"] \
	{ShowWebPage http://www.gnu.org/software/grep/};
    AppendToTextDisplay $po "\nFgrep stands for 'fast grep'. It is a version of grep that is limited to searches for fixed strings. As such, it does not actually provide for regular expression matching at all. It is included here because fixed string searches are sometimes useful and because it is a member of the same family as grep and egrep, indeed often the same program.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "fish"] \
	{ShowWebPage http://roo.no-ip.org/fish/};
    AppendToTextDisplay $po "\nFish, the 'friendly interactive shell', is a shell that is focused on interactive use, discoverability, and user friendliness. The design goal of fish is to give the user a rich set of powerful features in a way that is easy to discover, remember, and use. Fish features a user-friendly and powerful tab-completion, including descriptions of every completion, tab-completion of strings with wildcards, and many completions for specific commands.\n";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "frink"] \
	{ShowWebPage http://futureboy.homeip.net/frinkdocs};
    AppendToTextDisplay $po "\nFrink is a language intended especially for numerical calculation. Its most unusual property is that all numerical values are associated with units, of which it has an extensive database. Frink therefore knows that the product of 2 furlongs and 3 feet is 367.9 square meters. It uses a modified version of the regular expression code from the Apache Java ORO project, which provides regular expression facilities compatible with those of Perl5.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "gawk"] \
	{ShowWebPage http://www.gnu.org/software/gawk/};
    AppendToTextDisplay $po "\nGawk is the GNU project implementation of Awk. It is roughly equivalent to ATT nawk but has some extensions. Note that on many systems this is the only version of Awk installed and may be named Awk rather than, or in addition to, Gawk.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "glark"] \
	{ShowWebPage http://www.incava.org/projects/glark/};
    AppendToTextDisplay $po "\nGlark is a text search program along the lines of grep implemented in Ruby. Additional features include Boolean combinations of patterns, highlighting of matches, and context around matches.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "grep"] \
	{ShowWebPage http://www.gnu.org/software/grep/};
    AppendToTextDisplay $po "\nGrep is the classic Unix string search program. The original version provided 'basic regular expression' notation, while egrep provided the richer 'extended regular expression' notation and fgrep could search only for fixed strings. Typically, when called as grep with no special command-line options basic regular expression notation will be used. In many cases, the same program if called by another name or with other command-line options will behave like fgrep or egrep.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "groovy"] \
	{ShowWebPage http://groovy.codehaus.org};
    AppendToTextDisplay $po "\nGroovy is a scripting language for the Java virtual machine.";
    AppendToTextDisplay $po "\n\n";
#    AppendLinkToTextDisplay $po [_ "gpp"] {ShowWebPage http://www.nothingisreal.com/gpp/};
#    AppendToTextDisplay $po "\nGPP is a general purpose preprocessor, similar to GNU m4.";
#    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "guile"] \
	{ShowWebPage http://www.gnu.org/software/guile/};
    AppendToTextDisplay $po "\nGuile is a dialect of Lisp developed by the GNU Project with the intention that it serve as the primary extension language for GNU software. It provides roughly the classic egrep regular expression facilities but uses notation that in some respects is unusual.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po "ici" \
	{ShowWebPage http://ici.sourceforge.net};
    AppendToTextDisplay $po "\n Ici is an interpreted language very similar to C."
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po "icon" \
	{ShowWebPage http://www.cs.arizona.edu/icon};
    AppendToTextDisplay $po "\nIcon is the modern descendant of Snobol, the classic pattern matching language. Unlike Snobol, Icon has the usual Algol-type control structures. Syntactically, it feels much like C. However, Icon has a richer run-time system that supports such unusual constructs as goal-directed evaluation and generator functions. Icon has a regular expression matching toolkit of the standard type, but it is not used as much as in many other languages since Icon is designed for pattern matching and parsing by direct methods.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "java"] \
	{ShowWebPage http://java.sun.com};
    AppendToTextDisplay $po "\nJava is a cross-platform object-oriented language with automatic storage allocation and garbage collection otherwise similar in syntax and level to C. Java has an enormous collection of library functions, including one of the most sophisticated regular expression toolkits.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "javascript"] \
	{ShowWebPage http://www.njs-javascript.org};
    AppendToTextDisplay $po "\nJavascript is the original webpage programning language introduced with the Netscape browser. It is used primarily on web pages.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "jgrep"] \
	{ShowWebPage http://ourworld.compuserve.com/homepages/John_Maddock/regexpp.htm};
    AppendToTextDisplay $po "\nJgrep is a text search utility that accompanies the Regex++ regular expression library for C++ and C. This library provides full POSIX regular expression syntax plus some Perl extensions and handles Unicode.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "judoscript"] \
	{ShowWebPage http://www.judoscript.com/judo.html};
    AppendToTextDisplay $po "\nJudoscript is a scripting language implemented in Java and intended to provide easier access to Java. It provides high-level facilities for a variety of functions such as HTTP and encryption while at the same time allowing Java code to be included.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "ksh"] \
	{ShowWebPage http://www.kornshell.com/};
    AppendToTextDisplay $po "\nKsh is a shell in the Bourne shell lineage created by David Korn at AT&T. It exists in several versions, the 1988 AT&T version, the 1993 AT&T version, several derivatives of the AT&T version, and a public domain clone known as ";
    AppendLinkToTextDisplay $po "pdksh" \
	{ShowWebPage http://www.cs.mun.ca/~michael/pdksh/}
    AppendToTextDisplay $po [_ ". Note that both pdksh and the original AT&T versions are normally installed under the name ksh so it may not be obvious which version you have. As far as I can tell file globbing is the same in all versions except for the fact that pdksh does not support the POSIX named character classes (\[\[:digit:\]\] etc.)."];
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "lua"] \
	{ShowWebPage http://www.lua.org};
    AppendToTextDisplay $po "\nLua is a scripting language aimed especially at games and other embedded applications. It is designed to be fast and to use a minimum of memory. Lua's pattern matching commands do not, strictly speaking, match regular expressions since the quantifiers apply either to the preceding symbol or the preceding builtin character class. It has capture groups but they do not serve as quantifier domains. In mathematical terms, Lua string matching lacks closure of subexpressions. If you need full regular expression matching Lua is not suitable.";
    AppendToTextDisplay $po "\n\n";
#    AppendLinkToTextDisplay $po [_ "m4"] {ShowWebPage http://www.gnu.org/software/m4};
#    AppendToTextDisplay $po "\nM4 is the standard Unix macro language.";
#    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "mawk"] \
	{ShowWebPage http://freshmeat.net/projects/mawk};
    AppendToTextDisplay $po "\nMike's Awk is a version of Awk that conforms to the POSIX 1003.2 standard and adds a few extensions. It is roughly equivalent to ATT nawk. Mawk is smaller and faster than Gawk.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "minised"] \
	{ShowWebPage http://www.exactcode.de/oss/minised/};
    AppendToTextDisplay $po "\nMinised is a version of sed originally used by the GNU project, before the GNU project created a new version of sed based on its new, expanded regular expression library.  It is the sed distributed with Minix. It is smaller and faster than GNU sed with fewer features. It was reverse-engineered by Eric S. Raymond from 4.1 BSD sed but has a few extensions.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "mysql"] \
	{ShowWebPage http://www.mysql.com/};
    AppendToTextDisplay $po "\nMysql is a widely used free relational database that supports the SQL query language. It provides both SQL wildcards and real regular expressions.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "nawk"] \
	{ShowWebPage http://heirloom.sourceforge.net};
    AppendToTextDisplay $po "\nThe Nawk to which the link is provided is the version provided as part of the Heirloom Toolchest, which contains updated versions of original Unix software released as open source by Caledera and Sun. Among the ways in which it has been updated is that it can handle UTF-8 Unicode.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "nrgrep"] \
	{ShowWebPage http://www.dcc.uchile.cl/~gnavarro/software/};
    AppendToTextDisplay $po "\nNrgrep is a text search utility that uses an algorithm developed by the author, Gonzalo Navarro. It supports approximate matching and has the unusual property of providing for transpositions. Costs may be set only globally, not for individual groups";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "numgrep"] \
	{ShowWebPage http://suso.suso.org/programs/num-utils/};
    AppendToTextDisplay $po "\nNumgrep is a program specialized for matching integers based on their values rather than their textual form. It can do matches that are difficult or impossible using regular expressions.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "patmatch"] \
	{ShowWebPage http://nar.oxfordjournals.org/cgi/content/abstract/33/suppl_2/W262};
    AppendToTextDisplay $po "\nPatmatch is a specialized matcher for nucleotide and peptide sequences. It consists of a Perl front-end to a modified version of nrgrep.";
    AppendToTextDisplay $po "The software can be obtained from:";
    AppendLinkToTextDisplay $po ftp://ftp.arabidopsis.org/home/tair/Software/Patmatch/\
    {ShowWebPage ftp://ftp.arabidopsis.org/home/tair/Software/Patmatch/}
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "pcregrep"] \
	{ShowWebPage http://www.pcre.org/};
    AppendToTextDisplay $po "\nPcregrep is a command-line regular expression matcher similar to grep whose matching engine is the Perl Compatible Regular Expression library, which provides regular expression matching similar, but not identical to, Perl 5.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "perl"] \
	{ShowWebPage http://www.perl.org/};
    AppendToTextDisplay $po "\nPerl is a widely used scripting language considered by many to be the Swiss Army knife of programming. Version 5 of Perl introduced a number of extensions to standard regular expression notation, many of which have been adopted by other regular expression engines.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "php-mb"] \
	{ShowWebPage http://www.php.net};
    AppendToTextDisplay $po "\nThis is the PHP scripting language using a regular expression library that supports multibyte characters.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "php-pcre"] \
	{ShowWebPage http://www.php.net};
    AppendToTextDisplay $po "\nThis is the PHP scripting language using the PCRE regular expression library, wich provides regular expressions along the lines of those of Perl 5.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "php-posix"] \
	{ShowWebPage http://www.php.net};
    AppendToTextDisplay $po "\nPHP is a scripting language used primarily for generating dynamic web pages. It has several regular expression toolkits. This one provides regular expressions conformant to the POSIX standard.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "pike"] \
	{ShowWebPage http://pike.ida.liu.se};
    AppendToTextDisplay $po "\nPike is a scripting language roughly comparable to Python, Perl, Tcl and Ruby. It is object-oriented and has a C-like syntax. It has a somewhat lower-level orientation than comparable scripting languages. It has a fairly rich regular expression facility and is one of the faster languages of its type.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "python"] \
	{ShowWebPage http://www.python.org};
    AppendToTextDisplay $po "\nPython is one of the popular new generation scripting languages. It is object-oriented, but not as as thoroughly as Ruby. It is possible for someone with little understanding of object-oriented programming to write in Python. Python has one of the richer regular expression toolkits.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "rc"] \
	{ShowWebPage http://www.star.le.ac.uk/~tjg/rc/};
    AppendToTextDisplay $po "\nRc is the standard shell for Plan 9, the successor to Unix developed by Lucent.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "rebol"] \
	{ShowWebPage http://www.rebol.com};
    AppendToTextDisplay $po "\nRebol is a cross-platform scripting language that is intended for use both as a programming language and as a data description language. Rebol's patternmatching facilities are an integral part of the language rather than a separate regular expression matching component, so Redet does not provide an optimal interface to them.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "rep"] \
	{ShowWebPage http://librep.sourceforge.net};
    AppendToTextDisplay $po "\nLibrep is a library that provides an interpreter for a dialect of Lisp. The same functionality is available via the command-line program Rep. This is the extension language for a number of programs, including the Sawfish window manager and the Jade text editor. Rep uses a slightly modified version of Henry Spencer's regular expression package.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "ruby"] \
	{ShowWebPage http://ruby-lang.org};
    AppendToTextDisplay $po "\nRuby is a relatively new addition to the group of scripting languages that includes Perl, Python, and Tcl. It is more thoroughly object-oriented than Python and uses a syntax reminiscent in some ways of that of Perl. Perl fans in search of a cleaner, strongly object-oriented language tend to like Ruby. Ruby has a fairly rich regular expression facility and executes quickly, so it is a reasonable choice if you are using Redet as a search tool as well as if you are developing regular expressions for Ruby.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "sed"] \
	{ShowWebPage http://www.gnu.org/software/sed};
    AppendToTextDisplay $po "\nSed is the classic Unix stream editor. It is much like the line editor ed but is oriented toward use as a filter.";
    AppendToTextDisplay $po "\n\n";
#    AppendLinkToTextDisplay $po [_ "sgrep"] {ShowWebPage http://www.cs.helsinki.fi/u/jjaakkol/sgrep.html};
#    AppendToTextDisplay $po "\nSgrep is...";
#    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "sleep"] \
	{ShowWebPage http://sleep.hick.org};
    AppendToTextDisplay $po "\nSleep is an embeddable scripting language implemented in Java. It is inspired by Perl with influence from Objective C. Sleep has both a full regular expression capability and a more limited wildcard matching facility.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "sleepwc"] \
	{ShowWebPage http://sleep.hick.org};
    AppendToTextDisplay $po "\nThis is the wildcard matching facility of the Sleep scripting language, which also has a full regular expression engine.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "ssed"] \
	{ShowWebPage http://sed.sourceforge.net/grabbag/ssed/};
    AppendToTextDisplay $po "\nSsed (super-sed) is an extension of GNU sed created by Paolo Bonzini. It uses Perl-style regular expressions and is reported to be much faster than GNU sed. Some of its extensions have been incorporated into GNU sed. It has some extensions not apparent in Redet, such as the ability to edit files in place.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "tcl"] \
	{ShowWebPage http://www.tcl.tk};
    AppendToTextDisplay $po "\nTcl is the language in which this program is written, so it is always available and is very fast since there is no overhead executing other programs as child processes. It has one of the richest regular expression facilities and so is a good choice if you are using Redet as a search tool.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "tclglob"] \
	{ShowWebPage http://www.tcl.tk};
    AppendToTextDisplay $po "\nTcl has a filename matching feature in addition to its richer regular expression facilities. If you are using Redet as a search tool, you had might as well use the full regular expression facilities. If you are constructing expressions for use with Tcl's file globbing commands you should select this program.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "tcsh"] \
	{ShowWebPage http://www.tcsh.org};
    AppendToTextDisplay $po "\nThis is one of the command line interpreters widely used on Unix systems. Tcsh is an extended version of csh, the shell developed at Berkeley. On many systems it is named csh instead of, or in addition to, tcsh. You should choose this program if you are developing regular expressions for use with tcsh. Otherwise you would be better advised to use a program with richer and faster regular expression facilities.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "tr"] \
	{ShowWebPage http://www.gnu.org/software/coreutils/manual/html_chapter/coreutils_9.html\#SEC44};
    AppendToTextDisplay $po "\nTr is one of the standard Unix utilities. It is used to map one set of characters to another. It can also delete selected characters or reduce sequences of adjacent identical characters to a single token. It is not really a regular expression matcher but is supported because users have asked for it and because it uses character classes similar to the named character classes used in POSIX regular expressions.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po "vim" \
	{ShowWebPage http://www.vim.org};
    AppendToTextDisplay $po "\nVim is a free reimplementation and extension of vi, the screen editor descended from the original Unix line editor ed.";
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po "Vim's approach to matching newline characters is different from that of most other matchers. Instead of using a separate flag to control this, Vim provides newline-matching variants of constructs that do not match newline. The notation for these constructs is consistent: the newline-matching variant adds the prefix \\_, or the infix _ if the construct already begins with a backslash. For example, . matches any character other than newline; \\_. matches any character, including newline. \\s matches a space or tab; \\_s matches space, tab, or newline. Redet does not include these constructs in the palette since Redet operates on units of single lines.";
    AppendToTextDisplay $po "\n\n";
    AppendToTextDisplay $po "Vim provides another set of character classes that Redet does not list in the palette. These are: \\f 'filename character',\\i 'identifier character', \\k 'keyword character',\\p 'printable character', and their complements \\F, \\I, \\K, and \\P. These classes are intended to describe properties of the programming language and operating system and so are variable. They are usually defined in configuration files for editing a particular language. Because they have no fixed definition, Redet cannot provide palette entries for them.";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "wmagrep"] \
	{ShowWebPage ftp://ftp.cs.arizona.edu/agrep};
    AppendToTextDisplay $po "\nSee agrep (Wu-Manber).";
    AppendToTextDisplay $po "\n\n";
    AppendLinkToTextDisplay $po [_ "zsh"] \
	{ShowWebPage http://www.zsh.org};
    AppendToTextDisplay $po "\nZsh is a command interpreter originally written by Paul Falstad in order to create a shell similar to the Korn shell (ksh) with features familiar to users of csh. It has what is probably the richest file globbing system of any of the shells.";
}

#This is a slightly modified version of the standard unknown procedure
#loaded from init.tcl on startup. 
proc unknown args {
    global auto_noexec auto_noload env unknown_pending tcl_interactive
    global errorCode errorInfo

    set cmd [lindex $args 0]

    #See if the command is a missing help popup.
    if {[string match Explain* $cmd]} {
	ShowMessage [format [_ "%s is not available. See Help:Bug Reports."] $cmd]
	return 0;
    }
 
    # If the command word has the form "namespace inscope ns cmd"
    # then concatenate its arguments onto the end and evaluate it.

    if {[regexp "^:*namespace\[ \t\n\]+inscope" $cmd] && [llength $cmd] == 4} {
        set arglist [lrange $args 1 end]
	set ret [catch {uplevel 1 ::$cmd $arglist} result]
        if {$ret == 0} {
            return $result
        } else {
	    return -code $ret -errorcode $errorCode $result
        }
    }

    # Save the values of errorCode and errorInfo variables, since they
    # may get modified if caught errors occur below.  The variables will
    # be restored just before re-executing the missing command.

    # Safety check in case something unsets the variables 
    # ::errorInfo or ::errorCode.  [Bug 1063707]
    if {![info exists errorCode]} {
	set errorCode ""
    }
    if {![info exists errorInfo]} {
	set errorInfo ""
    }
    set savedErrorCode $errorCode
    set savedErrorInfo $errorInfo
    set name [lindex $args 0]
    if {![info exists auto_noload]} {
	#
	# Make sure we're not trying to load the same proc twice.
	#
	if {[info exists unknown_pending($name)]} {
	    return -code error "self-referential recursion in \"unknown\" for command \"$name\"";
	}
	set unknown_pending($name) pending;
	set ret [catch {auto_load $name [uplevel 1 {::namespace current}]} msg]
	unset unknown_pending($name);
	if {$ret != 0} {
	    append errorInfo "\n    (autoloading \"$name\")"
	    return -code $ret -errorcode $errorCode -errorinfo $errorInfo $msg
	}
	if {![array size unknown_pending]} {
	    unset unknown_pending
	}
	if {$msg} {
	    set errorCode $savedErrorCode
	    set errorInfo $savedErrorInfo
	    set code [catch {uplevel 1 $args} msg]
	    if {$code ==  1} {
		#
		# Compute stack trace contribution from the [uplevel].
		# Note the dependence on how Tcl_AddErrorInfo, etc. 
		# construct the stack trace.
		#
		set cinfo $args
		set ellipsis ""
		while {[string bytelength $cinfo] > 150} {
		    set cinfo [string range $cinfo 0 end-1]
		    set ellipsis "..."
		}
		append cinfo $ellipsis "\"\n    (\"uplevel\" body line 1)"
		append cinfo "\n    invoked from within"
		append cinfo "\n\"uplevel 1 \$args\""
		#
		# Try each possible form of the stack trace
		# and trim the extra contribution from the matching case
		#
		set expect "$msg\n    while executing\n\"$cinfo"
		if {$errorInfo eq $expect} {
		    #
		    # The stack has only the eval from the expanded command
		    # Do not generate any stack trace here.
		    #
		    return -code error -errorcode $errorCode $msg
		}
		#
		# Stack trace is nested, trim off just the contribution
		# from the extra "eval" of $args due to the "catch" above.
		#
		set expect "\n    invoked from within\n\"$cinfo"
		set exlen [string length $expect]
		set eilen [string length $errorInfo]
		set i [expr {$eilen - $exlen - 1}]
		set einfo [string range $errorInfo 0 $i]
		#
		# For now verify that $errorInfo consists of what we are about
		# to return plus what we expected to trim off.
		#
		if {$errorInfo ne "$einfo$expect"} {
		    error "Tcl bug: unexpected stack trace in \"unknown\"" {} \
			[list CORE UNKNOWN BADTRACE $expect $errorInfo]
		}
		return -code error -errorcode $errorCode \
			-errorinfo $einfo $msg
	    } else {
		return -code $code $msg
	    }
	}
    }

    if {([info level] == 1) && [string equal [info script] ""] \
	    && [info exists tcl_interactive] && $tcl_interactive} {
	if {![info exists auto_noexec]} {
	    set new [auto_execok $name]
	    if {$new != ""} {
		set errorCode $savedErrorCode
		set errorInfo $savedErrorInfo
		set redir ""
		if {[string equal [info commands console] ""]} {
		    set redir ">&@stdout <@stdin"
		}
		return [uplevel 1 exec $redir $new [lrange $args 1 end]]
	    }
	}
	set errorCode $savedErrorCode
	set errorInfo $savedErrorInfo
	if {[string equal $name "!!"]} {
	    set newcmd [history event]
	} elseif {[regexp {^!(.+)$} $name dummy event]} {
	    set newcmd [history event $event]
	} elseif {[regexp {^\^([^^]*)\^([^^]*)\^?$} $name dummy old new]} {
	    set newcmd [history event -1]
	    catch {regsub -all -- $old $newcmd $new newcmd}
	}
	if {[info exists newcmd]} {
	    tclLog $newcmd
	    history change $newcmd 0
	    return [uplevel 1 $newcmd]
	}

	set ret [catch {set candidates [info commands $name*]} msg]
	if {[string equal $name "::"]} {
	    set name ""
	}
	if {$ret != 0} {
	    return -code $ret -errorcode $errorCode \
		"error in unknown while checking if \"$name\" is\
		a unique command abbreviation:\n$msg"
	}
	# Filter out bogus matches when $name contained
	# a glob-special char [Bug 946952]
	set cmds [list]
	foreach x $candidates {
	    if {[string range $x 0 [expr [string length $name]-1]] eq $name} {
		lappend cmds $x
	    }
	}
	if {[llength $cmds] == 1} {
	    return [uplevel 1 [lreplace $args 0 0 [lindex $cmds 0]]]
	}
	if {[llength $cmds]} {
	    if {[string equal $name ""]} {
		return -code error "empty command name \"\""
	    } else {
		return -code error \
			"ambiguous command name \"$name\": [lsort $cmds]"
	    }
	}
    }
    return -code error "invalid command name \"$name\""
}
proc PostFileMenu {} {
    .menubar.file invoke 0
}

proc PostRegularExpressionMenu {} {
    .menubar.file.regexp invoke 0
}

proc PostTestDataMenu {} {
    .menubar.file.tdata invoke 0
}

proc PostResultsMenu {} {
    .menubar.file.results invoke 0
}

proc PostComparisonDataMenu {} {
    .menubar.file.comp invoke 0
}

proc PostProgramMenu {} {
    .menubar.program invoke 0
}

proc PostHistoryMenu {} {
    .menubar.history invoke 0
}

proc PostToolsMenu {} {
    .menubar.tools invoke 0
}

proc PostConfigureMenu {} {
    .menubar.configure invoke 0
}

proc PostHelpMenu {} {
    .menubar.help invoke 0
}

proc PostCharacterEntryMenu {} {
    .menubar.tools.charentry invoke 0
}

proc PostUserClassMenu {} {
    .menubar.tools.classes invoke 0
}

proc PostFeatureTestingMenu {} {
    .menubar.configure.ft invoke 0
}

proc PostLayoutMenu {} {
    .menubar.configure.layout invoke 0
}

proc PostMiscellaneousMenu {} {
    .menubar.configure.misc invoke 0
}

proc PostProgramSpecificMenu {} {
    .menubar.configure.progspec invoke 0
}

#We need to use different menu entry numbers in Aqua
#because unlike the other Tk implementations, Aqua has no tearoffs.
#In non-Aqua Tk the tearoff counts as entry 0 when it is present.

proc mdo {elnum} {
    if {$::AquaP} {
	return [expr $elnum -1]
    } else {
	return $elnum
    }
}

# This procedure relabels the top level menu buttons and destroys and reconstructs
# the submenus. The latter is necessary because Tk does not allow the relabelling
# of submenus.
proc LabelMenus {} {
    global m;
    global program;
    global InterfaceLocale;
    global BalloonHelpP;
    global LeftImplicitStar;
    global RightImplicitStar;
    global ButtonName;
    global FeatureTestDebugP;
    global FocusFollowsMouseP;
    global SortUnicodeRangesByCodepointP;
    global MenuIndex;
    global UserClassPaletteIsDisplayedP;
    global CreateFontControlPanelIndex;
    global SelectInterfaceLocaleIndex;
    global SortUnicodeRangesIndex;
    global FocusFollowsMouseIndex;
    global PerlUnicodeLocaleDependentIndex;
    global BalloonHelpIndex;
    global ToggleActualRegexpIndex;
    global ShowActualRegexpP;
    global DisplayActualRegexpIndex;
    global DescribeDisplayActualRegexpIndex;
    global ToggleUserClassPaletteIndex;
    global DescribeToggleUserClassPaletteIndex;
    global ToggleUserClassesEnabledIndex;
    global DescribeToggleUserClassesEnabledIndex;
    global UserClassesEnabledP;
    global SubstitutionModeIndex;
    global DoSubstitutionsP;
    global OutputOnlyChangedLinesP;
    global ComparisonWindowDisplayedP;
    global SideBySideLayoutP;
    global RegSubSideBySideP;
    global UseScrollbarsP;

    balloonhelp_control 0;
    $m entryconfigure $MenuIndex(FileMenu) -label  [_ "File"];
    $m.file delete [mdo 1] [mdo 8]
    set ind 0;
    destroy $m.file.regexp
    $m.file add cascade -label  [_ "Regular Expression"] -menu [menu $m.file.regexp]
    if {$::WindowSystem eq "X11"} {
	$m.file.regexp add command -label  [_ "Load Regular Expression From Primary Selection"]  \
	    -command LoadRegularExpressionFromPrimarySelection
    } else {
	$m.file.regexp add command -label  [_ "Load Regular Expression From Clipboard"]  \
	    -command LoadRegularExpressionFromClipboard;
    }
    $m.file.regexp add command -label  [_ "Load Regular Expression From File"] \
	-command LoadRegularExpressionFromFile;
    $m.file.regexp add command -label  [_ "Save Expressions In History Format"] \
	-command SaveRegexpAsHistory;
    $m.file.regexp add command -label  [_ "Save Regexp As Plain Text"] \
	-command SaveRegexpPlain;
    $m.file.regexp add command -label  [_ "Save Subexp As Plain Text"]\
	-command SaveSubexpPlain;
    $m.file.regexp add command -label [_ "Save Regular Expression Actually Executed"]\
	-command SaveActualRegexp;
    destroy $m.file.tdata
    $m.file add cascade -label  [_ "Test Data"] -menu [menu $m.file.tdata] 
    $m.file.tdata add command -label  [_ "Clear Test Data"] -command ClearInput;
    $m.file.tdata add command -label  [_ "Edit Test Data"] -command EditTestInputData;
    $m.file.tdata add command -label  [_ "Load Test Data From Clipboard"] \
	-command LoadTestDataFromClipboard;
    $m.file.tdata add command -label  [_ "Load Test Data From File"] \
	-command LoadTestInputData;
    $m.file.tdata add command -label  [_ "Save Test Data To File"] \
	-command SaveTestInputData
    $m.file.tdata add command -label  [_ "Set Test Data Encoding"] \
	-command {PopupSelectEncoding TestDataEncoding}
    destroy $m.file.results;
    $m.file add cascade -label  [_ "Results"] -menu [menu $m.file.results] 
    $m.file.results add command -label  [_ "Edit Results"] -command EditOutput
    $m.file.results add command -label  [_ "Lock Results"] -command LockOutput;
    $m.file.results add command -label  [_ "Save Results"] -command SaveResults;
    $m.file.results add command -label  [_ "Set Result Encoding"] \
	-command {PopupSelectEncoding ResultEncoding}
    destroy $m.file.comp
    $m.file add cascade -label  [_ "Comparison Data"] -menu [menu $m.file.comp] 
    $m.file.comp add command -label  [_ "Display Comparison Window"] \
	-command ToggleComparisonWindow
    set MenuIndex(ToggleComparisonWindow) 1
    $m.file.comp add command -label  [_ "Clear Comparison Data"] \
	-command ClearOutputComparisonData;
    $m.file.comp add command -label  [_ "Edit Comparison Data"] \
	-command EditOutputComparisonData;
    $m.file.comp add command -label  [_ "Load Comparison Data From Clipboard"] \
	-command LoadOutputComparisonDataFromClipboard;
    $m.file.comp add command -label  [_ "Load Comparison Data From File"] \
	-command LoadOutputComparisonData;
    $m.file.comp add command -label  [_ "Set Comparison Data Encoding"] \
	-command {PopupSelectEncoding ComparisonDataEncoding}
    $m.file.comp add command -label  [_ "Save Comparison Data To File"] \
	-command SaveResultsComparisonData;
    $m.file.comp add command -label  [_ "Compare Output and Comparison Data"] \
	-command ShowDiffResult;
    $m.file add command -label  [_ "Move Results to Test Data"] -command MoveResultsToTestData;
    $m.file add separator
    $m.file add command -label  [_ "Quit"] -command ShutDown;
    incr ind;
    $m entryconfigure $MenuIndex(ProgramMenu) -label  [_ "Program"];
    set ProgramCnt [llength $::DetailedProgList]
    $m.program delete [mdo 1] [mdo $ProgramCnt]
    set ColumnHeight [expr int(ceil(double($ProgramCnt) / double(4)))]
    set k 0;
    foreach p $::DetailedProgList {
	if {$k % $ColumnHeight == 0} {
	    $m.program add command -label $p -command "SelectProgram $p"  -columnbreak 1
	} else {
	    $m.program add command -label $p -command "SelectProgram $p"
	}
	incr k
    }
    if {!$::AquaP} {
	$m entryconfigure $MenuIndex(ExecuteMenu) \
	    -label  [format [_ "Execute-%s%s%s"] $LeftImplicitStar $ButtonName $RightImplicitStar];
    }
    $m.history delete [mdo 1] [mdo 5];
    $m entryconfigure $MenuIndex(HistoryMenu) -label  [_ "History"];
    set ind 1;
    set hist::ToggleHistoryIndex $ind;
    if {$hist::HistoryIsDisplayedP} {
	set blabel [_ "Hide History"];
    } else {
	set blabel [_ "Popup History"];
    }
    $m.history add command -label $blabel -command {hist::ToggleHistory};
    incr ind;
    if {$hist::HistoryShowProgP} {
	set blabel [_ "Do Not Show Program"];
    } else {
	set blabel [_ "Show Program"];
    }
    set hist::HistoryShowProgIndex $ind;
    $m.history add command -label $blabel -command {hist::ToggleHistoryProgramDisplay};
    incr ind;
    $m.history add command -label [_ "Save History"] -command {hist::SaveHistoryList};
    incr ind;
    $m.history add command -label [_ "Prune History"] -command {hist::PruneHistoryList};
    incr ind;
    $m.history add command -label [_ "Clear History"] -command {hist::ClearHistoryList};
    incr ind;
    if {!$::AquaP} {
	$m entryconfigure $MenuIndex(ClearMenu) -label  [_ "Clear"];
	$m entryconfigure $MenuIndex(PaletteMenu) -label  [_ "Palette"];
    } else {
	.cmnds.clear configure -text [_ "Clear"];
	.cmnds.palette configure -text [_ "Palette"];
    }
    $m entryconfigure $MenuIndex(ToolsMenu) -label  [_ "Tools"];
    $m.tools delete [mdo 1] [mdo 7];

    destroy $m.tools.charentry;
    $m.tools add cascade -label [_ "Character Entry"] -menu [menu $m.tools.charentry];
    $m.tools.charentry delete [mdo 1] [mdo $::CharentryMenuItems];
    set ::CharacterEntryMenuItems 0; 

    incr ::CharacterEntryMenuItems;
    set ::CustomCharacterChartIndex $::CharacterEntryMenuItems;
    $m.tools.charentry add command -label [_ "Load Custom Character Chart Definition"] \
	-command ReadCustomCharacterChartPopup;

    incr ::CharacterEntryMenuItems;
    set ::ToggleIPAAIndex $::CharacterEntryMenuItems;
    $m.tools.charentry add command -label [_ "Display Accented Letter Chart"] -command ToggleIPAA;

    incr ::CharacterEntryMenuItems;
    set ::ToggleIPACIndex $::CharacterEntryMenuItems;
    $m.tools.charentry add command -label [_ "Display IPA Consonants"] -command ToggleIPAC;

    incr ::CharacterEntryMenuItems;
    set ::ToggleIPAVIndex $::CharacterEntryMenuItems;
    $m.tools.charentry add command -label [_ "Display IPA Vowel Chart"] -command ToggleIPAV;

    incr ::CharacterEntryMenuItems;
    set ::ToggleIPADIndex $::CharacterEntryMenuItems;
    $m.tools.charentry add command -label [_ "Display IPA Diacritics"] -command ToggleIPAD;

    incr ::CharacterEntryMenuItems;
    set ::ToggleCharEntryByCodeIndex $::CharacterEntryMenuItems;
    $m.tools.charentry add command -label \
	[_ "Display Widget for Entering Characters by Unicode Code"] \
	-command ToggleCharEntryByCode;

    foreach Title [lsort [array names ::SpecialCharacterPalette]] {
	if {[string match *WidgetName $Title]} {continue}
	$::CEM add command -label $Title -command "PopupSpecialPalette $Title";
	incr ::CharacterEntryMenuItems;
    }

    destroy $m.tools.classes
    $m.tools add cascade -label [_ "Classes"] -menu [menu $m.tools.classes];
    $m.tools.classes delete [mdo 1] [mdo 9];
    set ind 1;
    if {$ShowActualRegexpP} {
	set blabel [_ "Do Not Display Regular Expression Actually Executed"];
    } else {
	set blabel [_ "Display Regular Expression Actually Executed"];
    }
    set DisplayActualRegexpIndex $ind;
    $m.tools.classes add command -label  $blabel -command ToggleActualRegexp;
    incr ind;

    $m.tools.classes add command -label [_ "Save Regular Expression Actually Executed"] -command SaveActualRegexp;
    incr ind;

    if {$UserClassPaletteIsDisplayedP} {
	set blabel [_ "Do Not Display User-Defined Class Palette"];
    } else {
	set blabel [_ "Display User-Defined Class Palette"];
    }
    $m.tools.classes add command -label $blabel -command ToggleUserClassPalette;
    set ToggleUserClassPaletteIndex $ind;

    incr ind;
    if {$UserClassesEnabledP} {
	set blabel [_ "Disable User Classes"];
    } else {
	set blabel [_ "Enable User Classes"];
    }
    $m.tools.classes add command -label $blabel -command ToggleUserClassesEnabled;
    set ToggleUserClassesEnabledIndex $ind;

    incr ind;
    $m.tools.classes add command -label  [_ "Enter Character Class Definition"] \
	-command PopupUserClassEntry;
    set EnterCharacterClassDefinitionIndex $ind;

    incr ind;
    $m.tools.classes add command -label  [_ "Load Character Class Definitions"] \
	-command ReadUserClassesInteractively;
    set LoadCharacterClassDefinitionIndex $ind;

    incr ind;
    $m.tools.classes add command -label  [_ "Save Character Class Definitions to File"] \
	-command SaveUserClassDefinitions;
    set SaveCharacterClassDefinitionIndex $ind;

    incr ind;
    $m.tools.classes add separator

    incr ind;
    $m.tools.classes add command -label [_ "Clear User Classes"]  -command ClearUserClasses;

    destroy $m.tools.search
    $m.tools add cascade -label [_ "Search"] -menu [menu $m.tools.search];
    $m.tools.search delete [mdo 1] [mdo 4]
    $m.tools.search add command -label  [_ "Search Test Data"] \
	-command search::SearchTestData
    $m.tools.search add command -label  [_ "Search Results"] \
	-command search::SearchResults;
    $m.tools.search add command -label  [_ "Go to Character in Test Data"] \
	-command search::GotoCharTestData
    $m.tools.search add command -label  [_ "Go to Character in Results"] \
	-command search::GotoCharResults;
    $m.tools add command -label [_ "Result Cache"] -command {resc::PopupCachedEntries}
    $m.tools add command -label [_ "Save Command Information"] -command {SaveCommandInfo}
    $m.tools add command -label [_ "Show Command Line"] -command {ShowCommandLine}
    $m.tools add command -label [_ "Abort"] -command {AbortSearch}
    $m entryconfigure $MenuIndex(ConfigureMenu) -label  [_ "Configure"];
    $m.configure delete [mdo 1] [mdo 12];
    set ind 1;
    destroy $m.configure.charentry
    $m.configure add cascade -label [_ "Character Entry"] -menu [menu $m.configure.charentry]
    incr ind;
    $m.configure.charentry delete [mdo 1]  [mdo 4];
    $m.configure.charentry add checkbutton -label [_ "Display Consonant Chart Column Labels"] \
	-variable DisplayConsonantChartColumnLabelsP -onvalue 1 -offvalue 0 \
	-command ControlDisplayConsonantChartColumnLabels
    $m.configure.charentry add checkbutton -label [_ "Display Consonant Chart Row Labels"] \
	-variable DisplayConsonantChartRowLabelsP -onvalue 1 -offvalue 0 \
	-command ControlDisplayConsonantChartRowLabels
    $m.configure.charentry add checkbutton -label [_ "Display Vowel Chart Column Labels"] \
	-variable DisplayVowelChartColumnLabelsP -onvalue 1 -offvalue 0 \
	-command ControlDisplayVowelChartColumnLabels
    $m.configure.charentry add checkbutton -label [_ "Display Vowel Chart Row Labels"] \
	-variable DisplayVowelChartRowLabelsP -onvalue 1 -offvalue 0 \
	-command ControlDisplayVowelChartRowLabels

    destroy $m.configure.ft
    $m.configure add cascade -label [_ "Feature Testing"] -menu [menu $m.configure.ft];
    incr ind;
    $m.configure.ft delete [mdo 1]  [mdo 3];
    set ftind 1;

    $m.configure.ft add command -label  [_ "Test Features"] -command TestFeatures;
    incr ftind;
    $m.configure.ft add command -label  [_ "Read Feature List"] \
	-command ReadFeatureList;
    incr ftind;
    $m.configure.ft add command -label  [_ "Write Feature List to File"] \
	-command {DumpFeatures $program $InterfaceLocale};
    incr ftind;

    $m.configure.ft add checkbutton -label [_ "Feature Testing Enabled"] \
	-variable FeatureTestP -onvalue 1 -offvalue 0

    $m.configure.ft add checkbutton -label [_ "Feature Test Debugging Enabled"] \
	-variable FeatureTestDebugP -onvalue 1 -offvalue 0

    destroy $m.configure.layout
    $m.configure add cascade  -label [_ "Layout"] -menu [menu $m.configure.layout]
    incr ind;

    $m.configure.layout add checkbutton -label [_ "Link Mode and Layout"] \
	-variable StandardConfigurationP -onvalue 1 -offvalue 0 \
	-command {if {$::StandardConfigurationP} { GotoStandardLayout}}

    $m.configure.layout add checkbutton -label [_ "Text Windows Side-By-Side"] \
	-variable SideBySideLayoutP -onvalue 1 -offvalue 0 \
	-command LayoutWindows

    $m.configure.layout add checkbutton -label [_ "Regexp and Subexp Side-By-Side"]\
	-variable RegSubSideBySideP -onvalue 1 -offvalue 0 \
	-command LayoutWindows;

    $m.configure.layout add checkbutton -label [_ "Use Scrollbars"] \
	-variable UseScrollbarsP -onvalue 1 -offvalue 0 \
	-command UpdateScrollbars;

    destroy $m.configure.misc
    $m.configure add cascade -label [_ "Miscellaneous"] -menu [menu $m.configure.misc]
    incr ind;

    $m.configure.misc add checkbutton -label [_ "Autoclear Regular Expression"] \
	-variable AutoClearRegexpP -onvalue 1 -offvalue 0

    $m.configure.misc add checkbutton -label [_ "Focus Follows Mouse"] \
	-variable FocusFollowsMouseP -onvalue 1 -offvalue 0 \
	-command {if {$::FocusFollowsMouseP} {tk_focusFollowsMouse}}

    $m.configure.misc add checkbutton -label [_ "On Substitution Output Only Changed Lines"] \
	-variable OutputOnlyChangedLinesP -onvalue 1 -offvalue 0 \
	-command InOutScrollLinkage

    $m.configure.misc add checkbutton -label [_ "Order Unicode Ranges by Codepoint"] \
	-variable SortUnicodeRangesByCodepointP  -onvalue 1 -offvalue 0 \
	-command UpdateUnicodeRangeSort;

    $m.configure.misc add checkbutton -label [_ "Set Debug Flag"] \
	-variable DebugP -onvalue 1 -offvalue 0;
   
    $m.configure.misc add checkbutton -label [_ "Show Balloon Help"] \
	-variable BalloonHelpP -onvalue 1 -offvalue 0 \
	-command {balloonhelp_control $::BalloonHelpP}

    destroy $m.configure.progspec
    $m.configure add cascade -label [_ "Program Specific Features"] \
	-menu [menu $m.configure.progspec];
    incr ind;
    $m.configure.progspec add command -label  [_ "Agrep"] -command PopupAgrepControls
    $m.configure.progspec add command -label  [_ "Arena"] -command PopupArenaControls
    $m.configure.progspec add command -label  [_ "Bash"] -command PopupBashControls
    $m.configure.progspec add command -label  [_ "BusyBoxEgrep"] -command PopupBusyBoxEgrepControls
    $m.configure.progspec add command -label  [_ "Cgrep"] -command PopupCgrepControls
    $m.configure.progspec add command -label  [_ "Egrep"] -command PopupEgrepControls
    $m.configure.progspec add command -label  [_ "Emacs"] -command PopupEmacsControls
    $m.configure.progspec add command -label  [_ "Fgrep"] -command PopupFgrepControls
    $m.configure.progspec add command -label  [_ "Gawk"] -command PopupGawkControls
    $m.configure.progspec add command -label  [_ "Glark"] -command PopupGlarkControls
    $m.configure.progspec add command -label  [_ "Grep"] -command PopupGrepControls
    $m.configure.progspec add command -label  [_ "Ici"] -command PopupIciControls
    $m.configure.progspec add command -label  [_ "Java"] -command PopupJavaControls
    $m.configure.progspec add command -label  [_ "Jgrep"] -command PopupJgrepControls
    $m.configure.progspec add command -label  [_ "Mysql"] -command PopupMysqlControls \
	-columnbreak 1
    $m.configure.progspec add command -label  [_ "Nrgrep"] -command PopupNrgrepControls
    $m.configure.progspec add command -label  [_ "Numgrep"] -command PopupNumgrepControls
    $m.configure.progspec add command -label  [_ "Patmatch"] -command PopupPatmatchControls
    $m.configure.progspec add command -label  [_ "Perl"] -command PopupPerlControls
    $m.configure.progspec add command -label  [_ "Python"] -command PopupPythonControls
    $m.configure.progspec add command -label  [_ "Sed"] -command PopupSedControls
    $m.configure.progspec add command -label  [_ "Ssed"] -command PopupSsedControls
    $m.configure.progspec add command -label  [_ "Tcl"] -command PopupTclControls
    $m.configure.progspec add command -label  [_ "Tr"] -command PopupTrControls
    $m.configure.progspec add command -label  [_ "Vim"] -command PopupVimControls
    $m.configure.progspec add command -label  [_ "Zsh"] -command PopupZshControls
    $m.configure add separator
    incr ind;

    set SubstitutionModeIndex $ind;
    if {$DoSubstitutionsP == 0} {
	set blabel [_ "Change to Substitution Mode"];
    } else {
	set blabel [_ "Change to Match Mode"];
    }
    $m.configure add command -label $blabel  -command ToggleSubstitutionMode;
    incr ind;

    $m.configure add command -label [_ "Save Configuration"] -command {SaveState};
    incr ind;

    $m.configure add separator
    incr ind;

    set CreateFontControlPanelIndex $ind;
    $m.configure add command -label [_ "Select Font"] -command fontsel::CreateFontControlPanel;
    incr ind;

    set SelectInterfaceLocaleIndex $ind;
    $m.configure add command -label  [_ "Select Locale"] -command ChangeInterfaceLocale;

    $m entryconfigure 9 -label  [_ "Help"];
#Help Menu
    if {[string equal $::System MacOSX]} {
	$m.help delete [mdo 1] [mdo 15];
    } else {
	$m.help delete [mdo 1] [mdo 14];
    }
    set ind 1;
    $m.help add command -label [_ "About"] -command About;
    $m.help add command -label [_ "Bug Reports"] -command BugReports;
    $m.help add command -label [_ "Command Descriptions"] -command \
	{ShowWebPage [file join ${::ManualDirectory} comdesc.html]}
    $m.help add command -label [_ "Command Line Options"] -command CommandLineOptions;
    $m.help add command -label [_ "Description"] -command Description;
    $m.help add command -label [_ "Illustrated Web Manual"] -command WebManual;
    destroy $m.help.ifc
    $m.help add cascade -label [_ "Initialization File"] -menu [menu $m.help.ifc];
    $m.help.ifc add command -label [_ "Color Names"] -command PopupColorNameList;
    $m.help.ifc add command -label [_ "Commands for which Shortcuts may be Defined "] \
	-command PopupShortcutCommands
    $m.help.ifc add command -label [_ "Redet Commands - Popup"] -command PopupInitCommandList;
    $m.help.ifc add command -label [_ "Redet Commands - Save to File"] -command SaveInitCommands;
    $m.help.ifc add command -label [_ "Tcl Commands - Popup"] -command PopupInitTclCommandList;
    $m.help.ifc add command -label [_ "Tcl Commands - Save to File"] -command SaveInitTclCommands;
    $m.help add command -label [_ "Key Bindings"] -command DescribeKeyBindings;
    $m.help add command -label [_ "License"] -command ShowGPL;
    if {[string equal $::System MacOSX]} {
	$m.help add command -label [_ "Macintosh Notes"] -command MacintoshNotes;
    }
    $m.help add command -label [_ "Programs"] -command DescribePrograms;
    $m.help add command -label [_ "This Program"] -command PopupProgramInfo;
    $m.help add command -label [_ "Unicode General Character Properties"] -command ShowUnicodeGCP;
    $m.help add command -label [_ "Unicode Ranges"] -command ShowUnicodeRanges;
    $m.help add command -label [_ "Write Palette to File"] -command WritePaletteToFile

    if {[winfo exists .hl]} {
	if {[winfo exists $::HISTF.hlist]} {
	    if {[winfo exists $::HISTF.histtitle]} {
		$::HISTF.histtitle configure -text [_ "History List"];
	    }
	}
    }
    if {$BalloonHelpP} {balloonhelp_control 1}
}

#Create GUI
#Real frames
#Top one, for regular expression and substitution expression windows.  
frame .rsf  -width $MainWidth  -height 3 -borderwidth 0 -relief sunken;
#Lower one, for data windows, that is, test data, result, and comparison data.
frame .dwf  -width $MainWidth  -height 0 -borderwidth 0 -relief sunken;
#These are used in vertical mode for pairs of windows and scrollbars
frame .dwf.vwi  -width $MainWidth  -height 0 -borderwidth 0
frame .dwf.vwo  -width $MainWidth  -height 0 -borderwidth 0
frame .dwf.vwc  -width $MainWidth  -height 0 -borderwidth 0
#Separators
frame .sep1 -width $MainWidth -height 2 -borderwidth 1 -relief sunken
frame .sep2 -width $MainWidth -height 2 -borderwidth 1 -relief sunken
frame .sep3 -width $MainWidth -height 2 -borderwidth 1 -relief sunken
#The quasi-menu
if {$AquaP} {
    frame .cmnds
    button .cmnds.execute -text [format [_ "Execute-%s"] $Program] -command ExecuteRegexp \
	-bg $::ColorSpecs(Menubar,Background) -fg $::ColorSpecs(Menubar,Foreground)
    button .cmnds.clear -text [format [_ "Clear"] $Program] -command ClearRegexp \
	-bg $::ColorSpecs(Menubar,Background) -fg $::ColorSpecs(Menubar,Foreground)
    button .cmnds.palette -text [format [_ "Palette"] $Program] -command TogglePalette \
	-bg $::ColorSpecs(Menubar,Background) -fg $::ColorSpecs(Menubar,Foreground)
    pack .cmnds.execute -side left -expand 1 -fill both
    pack .cmnds.clear -side left -expand 1 -fill both
    pack .cmnds.palette -side left -expand 1 -fill both
    BindKeys .cmnds
    frame .sepcmnds -width $MainWidth -height 2 -borderwidth 1 -relief sunken
}
#The message window.
text .msg -width $MainWidth -bg $ColorSpecs(Messages,Background) -fg $ColorSpecs(Messages,Foreground) -height 1\
    -relief raised -font MainFont -exportselection 1
#The regular expression and substitution expression windows.
entry .rsf.re -width $MainWidth -bg $ColorSpecs(Regexp,Background) -fg $ColorSpecs(Regexp,Foreground)\
    -font RegexpFont -exportselection 1;
entry .rsf.sub -width $MainWidth -bg $ColorSpecs(Subexp,Background) -fg $ColorSpecs(Subexp,Foreground)\
    -font RegexpFont -exportselection 1;
#The three data windows.
text $::IND  -width $SideWidth -bg $ColorSpecs(TestData,Background) -fg $ColorSpecs(TestData,Foreground)\
    -height $MainHeight -font TextFont -exportselection 1  -yscrollcommand {$::INDSB set}
text $::OUT -width $SideWidth  -bg $ColorSpecs(Results,Background) -fg $ColorSpecs(Results,Foreground)\
    -height $MainHeight -font TextFont -exportselection 1 -yscrollcommand {$::OUTSB set}
text $::COM -width $MainWidth -bg $ColorSpecs(ComparisonData,Background) -fg $ColorSpecs(ComparisonData,Foreground)\
    -height $MainHeight -font TextFont -exportselection 1 -yscrollcommand {$::COMSB set};
#The scrollbars for the data windows.
scrollbar $::INDSB -bg $ColorSpecs(TestData,Background) -troughcolor $ColorSpecs(TestData,Background) -command {$::IND yview}
scrollbar $::OUTSB -bg $ColorSpecs(Results,Background) -troughcolor $ColorSpecs(Results,Background) -command {$::OUT yview}
scrollbar $::COMSB -bg $ColorSpecs(ComparisonData,Background) -troughcolor $ColorSpecs(ComparisonData,Background) -command {$::COMo yview}

LayoutWindows;
set InsertionTarget $::REG;
bind $::REG <FocusIn> "SetInsertionTargets $::REG"
bind $::SUB <FocusIn> "SetInsertionTargets $::SUB"
bind $::IND <FocusIn> "SetInsertionTargets $::IND"
bind $::OUT <FocusIn> "SetInsertionTargets $::OUT";
bind $::COM <FocusIn> "SetInsertionTargets $::COM"

bind $::INDSB <<B3>> {ScrollbarMoveBigIncrement $::INDSB 0.10 %x %y};
bind $::OUTSB <<B3>> {ScrollbarMoveBigIncrement $::OUTSB 0.10 %x %y};
bind $::COMSB <<B3>> {ScrollbarMoveBigIncrement $::COMSB 0.10 %x %y};

BindKeys .msg;
BindKeys $::REG;
BindKeys $::SUB;
BindKeys $::IND;
BindKeys $::OUT;
BindKeys $::COM;
bind $::SUB <Return> {ExecuteRegexp};
bind $::REG <Tab> {$::REG  insert insert "\t";break;}; #Allow entry of literal tab.
bind $::SUB <Tab> {$::SUB insert insert "\t";break;}; #Allow entry of literal tab.

.msg  configure -state disabled
$::COM configure -state disabled
$::OUT  configure -state disabled
$::IND   configure -state disabled

balloonhelp_for .msg  [_ "Messages from program appear here."]
balloonhelp_for $::REG  [_ "Assemble regular expression here."]
balloonhelp_for $::SUB  [_ "Assemble substitution expression here."]
balloonhelp_for $::IND  [_ "Data on which to run regexp"]
balloonhelp_for $::OUT  [_ "Result of execution of regexp"]
balloonhelp_for $::COM [_ "Data to be compared to result of execution of regexp"]

#Setup menubar

set m [menu .menubar -tearoff 0 -font MenuFont \
       -bg $ColorSpecs(Menubar,Background) \
       -fg $ColorSpecs(Menubar,Foreground) \
       -activebackground $ColorSpecs(Menubar,ActiveBackground)\
       -activeforeground $ColorSpecs(Menubar,ActiveForeground)]
BindKeys .menubar;
set MenuBarItemCnt -1;
$m add cascade -label [_ "File"]   -menu [menu $m.file]
incr MenuBarItemCnt;
set MenuIndex(FileMenu) $MenuBarItemCnt;
$m add cascade -label [_ "Program"] -menu [menu $m.program];
incr MenuBarItemCnt;
set MenuIndex(ProgramMenu) $MenuBarItemCnt;
if {!$AquaP} {
    $m add command -label [format [_ "Execute-%s"] $Program]  -command ExecuteRegexp;
    incr MenuBarItemCnt;
    set MenuIndex(ExecuteMenu) $MenuBarItemCnt;
}
$m add cascade -label [_ "History"] -menu [menu $m.history];
incr MenuBarItemCnt;
set MenuIndex(HistoryMenu) $MenuBarItemCnt;
if {!$AquaP} {
    $m add command -label [_ "Clear"] -command ClearRegexp;
    incr MenuBarItemCnt;
    set MenuIndex(ClearMenu) $MenuBarItemCnt;
    $m add command -label [_ "Palette"] -command TogglePalette;
    incr MenuBarItemCnt;
    set MenuIndex(PaletteMenu) $MenuBarItemCnt;
}
$m add cascade -label [_ "Tools"] -menu [menu $m.tools]
incr MenuBarItemCnt;
set MenuIndex(ToolsMenu) $MenuBarItemCnt;
$m add cascade -label [_ "Configure"] -menu [menu $m.configure]
incr MenuBarItemCnt;
set MenuIndex(ConfigureMenu) $MenuBarItemCnt;
$m add cascade -label [_ "Help"] -menu [menu $m.help]
incr MenuBarItemCnt;
set MenuIndex(HelpMenu) $MenuBarItemCnt;
LabelMenus;
. configure -menu .menubar
CheckProgramAvailability
MarkProgramAvailability;
trace add variable ProgramInfo(cgrep,ExtendedP) write {TestFeatures;ConstructPalette;nil}

#Its okay to use the toggle since we can be sure that we are
#starting out in match mode.
if {$BeginInSubstitutionModeP} {
    ToggleSubstitutionMode;
}

#Its easiest if we create the emacs command shell whether or not we're going to use emacs.
CreateEmacsWrapper;

dmsg "About to read history file";

#Read history file.
if {$ReadHistoryFileP} {
    if { [file exists $HistoryFile] } {
	hist::ReadHistoryFile $HistoryFile;
    } else {
	set HistoryFullPath [file join $HomeDir $HistoryFile];
	if { [file exists $HistoryFullPath] } {hist::ReadHistoryFile $HistoryFullPath}
    }
}

#If a file named "Regexp" exists, read its contents into the history list.
if { [file exists "Regexp"] } {
    hist::ReadHistoryFile Regexp;
}

#We want the default browser to be set before this code is executed.
#If the default browser is on the list, remove it.
set di [lsearch -exact $BrowserList $DefaultBrowser]
if {$di >= 0} {
    set BrowserList [lreplace $BrowserList $di $di]
}
#Add the default browser to the beginning of the list.
set BrowserList [linsert $BrowserList 0 $DefaultBrowser];

foreach fn $CustomCharacterChartFileNameList {
    wm withdraw [ReadCustomCharacterChartPopup $fn]
}
foreach dl $CustomCharacterChartDataList {
    wm withdraw [DefineCustomCharacterChartPopup $dl]
}

set InitialProgram $program;
hist::OpenHistoryFile; #For writing now;
SetRegReturnBinding;
search::SearchInitialize $::IND;
search::SearchInitialize $::OUT;
SetPalette;
trace add variable ProgramInfo(perl,UnicodeLocaleDependentP) write PerlUnicodeDepUpdate;
trace add variable ProgramInfo(ssed,RegexpType) write UpdateSsedPalette
trace add variable ProgramInfo(ssed,POSIX) write UpdateSsedPalette


dmsg "About to create UName array";
#Derived from Unicode 5.1.0 UnicodeData.txt.
array set UName {
\u0000 "NULL"
\u0001 "START OF HEADING"
\u0002 "START OF TEXT"
\u0003 "END OF TEXT"
\u0004 "END OF TRANSMISSION"
\u0005 "ENQUIRY"
\u0006 "ACKNOWLEDGE"
\u0007 "BELL"
\u0008 "BACKSPACE"
\u0009 "CHARACTER TABULATION"
\u000A "LINE FEED (LF)"
\u000B "LINE TABULATION"
\u000C "FORM FEED (FF)"
\u000D "CARRIAGE RETURN (CR)"
\u000E "SHIFT OUT"
\u000F "SHIFT IN"
\u0010 "DATA LINK ESCAPE"
\u0011 "DEVICE CONTROL ONE"
\u0012 "DEVICE CONTROL TWO"
\u0013 "DEVICE CONTROL THREE"
\u0014 "DEVICE CONTROL FOUR"
\u0015 "NEGATIVE ACKNOWLEDGE"
\u0016 "SYNCHRONOUS IDLE"
\u0017 "END OF TRANSMISSION BLOCK"
\u0018 "CANCEL"
\u0019 "END OF MEDIUM"
\u001A "SUBSTITUTE"
\u001B "ESCAPE"
\u001C "INFORMATION SEPARATOR FOUR"
\u001D "INFORMATION SEPARATOR THREE"
\u001E "INFORMATION SEPARATOR TWO"
\u001F "INFORMATION SEPARATOR ONE"
\u0020 "SPACE"
\u0021 "EXCLAMATION MARK"
\u0022 "QUOTATION MARK"
\u0023 "NUMBER SIGN"
\u0024 "DOLLAR SIGN"
\u0025 "PERCENT SIGN"
\u0026 "AMPERSAND"
\u0027 "APOSTROPHE"
\u0028 "LEFT PARENTHESIS"
\u0029 "RIGHT PARENTHESIS"
\u002A "ASTERISK"
\u002B "PLUS SIGN"
\u002C "COMMA"
\u002D "HYPHEN-MINUS"
\u002E "FULL STOP"
\u002F "SOLIDUS"
\u0030 "DIGIT ZERO"
\u0031 "DIGIT ONE"
\u0032 "DIGIT TWO"
\u0033 "DIGIT THREE"
\u0034 "DIGIT FOUR"
\u0035 "DIGIT FIVE"
\u0036 "DIGIT SIX"
\u0037 "DIGIT SEVEN"
\u0038 "DIGIT EIGHT"
\u0039 "DIGIT NINE"
\u003A "COLON"
\u003B "SEMICOLON"
\u003C "LESS-THAN SIGN"
\u003D "EQUALS SIGN"
\u003E "GREATER-THAN SIGN"
\u003F "QUESTION MARK"
\u0040 "COMMERCIAL AT"
\u0041 "LATIN CAPITAL LETTER A"
\u0042 "LATIN CAPITAL LETTER B"
\u0043 "LATIN CAPITAL LETTER C"
\u0044 "LATIN CAPITAL LETTER D"
\u0045 "LATIN CAPITAL LETTER E"
\u0046 "LATIN CAPITAL LETTER F"
\u0047 "LATIN CAPITAL LETTER G"
\u0048 "LATIN CAPITAL LETTER H"
\u0049 "LATIN CAPITAL LETTER I"
\u004A "LATIN CAPITAL LETTER J"
\u004B "LATIN CAPITAL LETTER K"
\u004C "LATIN CAPITAL LETTER L"
\u004D "LATIN CAPITAL LETTER M"
\u004E "LATIN CAPITAL LETTER N"
\u004F "LATIN CAPITAL LETTER O"
\u0050 "LATIN CAPITAL LETTER P"
\u0051 "LATIN CAPITAL LETTER Q"
\u0052 "LATIN CAPITAL LETTER R"
\u0053 "LATIN CAPITAL LETTER S"
\u0054 "LATIN CAPITAL LETTER T"
\u0055 "LATIN CAPITAL LETTER U"
\u0056 "LATIN CAPITAL LETTER V"
\u0057 "LATIN CAPITAL LETTER W"
\u0058 "LATIN CAPITAL LETTER X"
\u0059 "LATIN CAPITAL LETTER Y"
\u005A "LATIN CAPITAL LETTER Z"
\u005B "LEFT SQUARE BRACKET"
\u005C "REVERSE SOLIDUS"
\u005D "RIGHT SQUARE BRACKET"
\u005E "CIRCUMFLEX ACCENT"
\u005F "LOW LINE"
\u0060 "GRAVE ACCENT"
\u0061 "LATIN SMALL LETTER A"
\u0062 "LATIN SMALL LETTER B"
\u0063 "LATIN SMALL LETTER C"
\u0064 "LATIN SMALL LETTER D"
\u0065 "LATIN SMALL LETTER E"
\u0066 "LATIN SMALL LETTER F"
\u0067 "LATIN SMALL LETTER G"
\u0068 "LATIN SMALL LETTER H"
\u0069 "LATIN SMALL LETTER I"
\u006A "LATIN SMALL LETTER J"
\u006B "LATIN SMALL LETTER K"
\u006C "LATIN SMALL LETTER L"
\u006D "LATIN SMALL LETTER M"
\u006E "LATIN SMALL LETTER N"
\u006F "LATIN SMALL LETTER O"
\u0070 "LATIN SMALL LETTER P"
\u0071 "LATIN SMALL LETTER Q"
\u0072 "LATIN SMALL LETTER R"
\u0073 "LATIN SMALL LETTER S"
\u0074 "LATIN SMALL LETTER T"
\u0075 "LATIN SMALL LETTER U"
\u0076 "LATIN SMALL LETTER V"
\u0077 "LATIN SMALL LETTER W"
\u0078 "LATIN SMALL LETTER X"
\u0079 "LATIN SMALL LETTER Y"
\u007A "LATIN SMALL LETTER Z"
\u007B "LEFT CURLY BRACKET"
\u007C "VERTICAL LINE"
\u007D "RIGHT CURLY BRACKET"
\u007E "TILDE"
\u007F "DELETE"
\u0080 "unspecified control character"
\u0081 "unspecified control character"
\u0082 "BREAK PERMITTED HERE"
\u0083 "NO BREAK HERE"
\u0084 "unspecified control character"
\u0085 "NEXT LINE (NEL)"
\u0086 "START OF SELECTED AREA"
\u0087 "END OF SELECTED AREA"
\u0088 "CHARACTER TABULATION SET"
\u0089 "CHARACTER TABULATION WITH JUSTIFICATION"
\u008A "LINE TABULATION SET"
\u008B "PARTIAL LINE FORWARD"
\u008C "PARTIAL LINE BACKWARD"
\u008D "REVERSE LINE FEED"
\u008E "SINGLE SHIFT TWO"
\u008F "SINGLE SHIFT THREE"
\u0090 "DEVICE CONTROL STRING"
\u0091 "PRIVATE USE ONE"
\u0092 "PRIVATE USE TWO"
\u0093 "SET TRANSMIT STATE"
\u0094 "CANCEL CHARACTER"
\u0095 "MESSAGE WAITING"
\u0096 "START OF GUARDED AREA"
\u0097 "END OF GUARDED AREA"
\u0098 "START OF STRING"
\u0099 "unspecified control character"
\u009A "SINGLE CHARACTER INTRODUCER"
\u009B "CONTROL SEQUENCE INTRODUCER"
\u009C "STRING TERMINATOR"
\u009D "OPERATING SYSTEM COMMAND"
\u009E "PRIVACY MESSAGE"
\u009F "APPLICATION PROGRAM COMMAND"
\u00A0 "NO-BREAK SPACE"
\u00A1 "INVERTED EXCLAMATION MARK"
\u00A2 "CENT SIGN"
\u00A3 "POUND SIGN"
\u00A4 "CURRENCY SIGN"
\u00A5 "YEN SIGN"
\u00A6 "BROKEN BAR"
\u00A7 "SECTION SIGN"
\u00A8 "DIAERESIS"
\u00A9 "COPYRIGHT SIGN"
\u00AA "FEMININE ORDINAL INDICATOR"
\u00AB "LEFT-POINTING DOUBLE ANGLE QUOTATION MARK"
\u00AC "NOT SIGN"
\u00AD "SOFT HYPHEN"
\u00AE "REGISTERED SIGN"
\u00AF "MACRON"
\u00B0 "DEGREE SIGN"
\u00B1 "PLUS-MINUS SIGN"
\u00B2 "SUPERSCRIPT TWO"
\u00B3 "SUPERSCRIPT THREE"
\u00B4 "ACUTE ACCENT"
\u00B5 "MICRO SIGN"
\u00B6 "PILCROW SIGN"
\u00B7 "MIDDLE DOT"
\u00B8 "CEDILLA"
\u00B9 "SUPERSCRIPT ONE"
\u00BA "MASCULINE ORDINAL INDICATOR"
\u00BB "RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK"
\u00BC "VULGAR FRACTION ONE QUARTER"
\u00BD "VULGAR FRACTION ONE HALF"
\u00BE "VULGAR FRACTION THREE QUARTERS"
\u00BF "INVERTED QUESTION MARK"
\u00C0 "LATIN CAPITAL LETTER A WITH GRAVE"
\u00C1 "LATIN CAPITAL LETTER A WITH ACUTE"
\u00C2 "LATIN CAPITAL LETTER A WITH CIRCUMFLEX"
\u00C3 "LATIN CAPITAL LETTER A WITH TILDE"
\u00C4 "LATIN CAPITAL LETTER A WITH DIAERESIS"
\u00C5 "LATIN CAPITAL LETTER A WITH RING ABOVE"
\u00C6 "LATIN CAPITAL LETTER AE"
\u00C7 "LATIN CAPITAL LETTER C WITH CEDILLA"
\u00C8 "LATIN CAPITAL LETTER E WITH GRAVE"
\u00C9 "LATIN CAPITAL LETTER E WITH ACUTE"
\u00CA "LATIN CAPITAL LETTER E WITH CIRCUMFLEX"
\u00CB "LATIN CAPITAL LETTER E WITH DIAERESIS"
\u00CC "LATIN CAPITAL LETTER I WITH GRAVE"
\u00CD "LATIN CAPITAL LETTER I WITH ACUTE"
\u00CE "LATIN CAPITAL LETTER I WITH CIRCUMFLEX"
\u00CF "LATIN CAPITAL LETTER I WITH DIAERESIS"
\u00D0 "LATIN CAPITAL LETTER ETH"
\u00D1 "LATIN CAPITAL LETTER N WITH TILDE"
\u00D2 "LATIN CAPITAL LETTER O WITH GRAVE"
\u00D3 "LATIN CAPITAL LETTER O WITH ACUTE"
\u00D4 "LATIN CAPITAL LETTER O WITH CIRCUMFLEX"
\u00D5 "LATIN CAPITAL LETTER O WITH TILDE"
\u00D6 "LATIN CAPITAL LETTER O WITH DIAERESIS"
\u00D7 "MULTIPLICATION SIGN"
\u00D8 "LATIN CAPITAL LETTER O WITH STROKE"
\u00D9 "LATIN CAPITAL LETTER U WITH GRAVE"
\u00DA "LATIN CAPITAL LETTER U WITH ACUTE"
\u00DB "LATIN CAPITAL LETTER U WITH CIRCUMFLEX"
\u00DC "LATIN CAPITAL LETTER U WITH DIAERESIS"
\u00DD "LATIN CAPITAL LETTER Y WITH ACUTE"
\u00DE "LATIN CAPITAL LETTER THORN"
\u00DF "LATIN SMALL LETTER SHARP S"
\u00E0 "LATIN SMALL LETTER A WITH GRAVE"
\u00E1 "LATIN SMALL LETTER A WITH ACUTE"
\u00E2 "LATIN SMALL LETTER A WITH CIRCUMFLEX"
\u00E3 "LATIN SMALL LETTER A WITH TILDE"
\u00E4 "LATIN SMALL LETTER A WITH DIAERESIS"
\u00E5 "LATIN SMALL LETTER A WITH RING ABOVE"
\u00E6 "LATIN SMALL LETTER AE"
\u00E7 "LATIN SMALL LETTER C WITH CEDILLA"
\u00E8 "LATIN SMALL LETTER E WITH GRAVE"
\u00E9 "LATIN SMALL LETTER E WITH ACUTE"
\u00EA "LATIN SMALL LETTER E WITH CIRCUMFLEX"
\u00EB "LATIN SMALL LETTER E WITH DIAERESIS"
\u00EC "LATIN SMALL LETTER I WITH GRAVE"
\u00ED "LATIN SMALL LETTER I WITH ACUTE"
\u00EE "LATIN SMALL LETTER I WITH CIRCUMFLEX"
\u00EF "LATIN SMALL LETTER I WITH DIAERESIS"
\u00F0 "LATIN SMALL LETTER ETH"
\u00F1 "LATIN SMALL LETTER N WITH TILDE"
\u00F2 "LATIN SMALL LETTER O WITH GRAVE"
\u00F3 "LATIN SMALL LETTER O WITH ACUTE"
\u00F4 "LATIN SMALL LETTER O WITH CIRCUMFLEX"
\u00F5 "LATIN SMALL LETTER O WITH TILDE"
\u00F6 "LATIN SMALL LETTER O WITH DIAERESIS"
\u00F7 "DIVISION SIGN"
\u00F8 "LATIN SMALL LETTER O WITH STROKE"
\u00F9 "LATIN SMALL LETTER U WITH GRAVE"
\u00FA "LATIN SMALL LETTER U WITH ACUTE"
\u00FB "LATIN SMALL LETTER U WITH CIRCUMFLEX"
\u00FC "LATIN SMALL LETTER U WITH DIAERESIS"
\u00FD "LATIN SMALL LETTER Y WITH ACUTE"
\u00FE "LATIN SMALL LETTER THORN"
\u00FF "LATIN SMALL LETTER Y WITH DIAERESIS"
\u0100 "LATIN CAPITAL LETTER A WITH MACRON"
\u0101 "LATIN SMALL LETTER A WITH MACRON"
\u0102 "LATIN CAPITAL LETTER A WITH BREVE"
\u0103 "LATIN SMALL LETTER A WITH BREVE"
\u0104 "LATIN CAPITAL LETTER A WITH OGONEK"
\u0105 "LATIN SMALL LETTER A WITH OGONEK"
\u0106 "LATIN CAPITAL LETTER C WITH ACUTE"
\u0107 "LATIN SMALL LETTER C WITH ACUTE"
\u0108 "LATIN CAPITAL LETTER C WITH CIRCUMFLEX"
\u0109 "LATIN SMALL LETTER C WITH CIRCUMFLEX"
\u010A "LATIN CAPITAL LETTER C WITH DOT ABOVE"
\u010B "LATIN SMALL LETTER C WITH DOT ABOVE"
\u010C "LATIN CAPITAL LETTER C WITH CARON"
\u010D "LATIN SMALL LETTER C WITH CARON"
\u010E "LATIN CAPITAL LETTER D WITH CARON"
\u010F "LATIN SMALL LETTER D WITH CARON"
\u0110 "LATIN CAPITAL LETTER D WITH STROKE"
\u0111 "LATIN SMALL LETTER D WITH STROKE"
\u0112 "LATIN CAPITAL LETTER E WITH MACRON"
\u0113 "LATIN SMALL LETTER E WITH MACRON"
\u0114 "LATIN CAPITAL LETTER E WITH BREVE"
\u0115 "LATIN SMALL LETTER E WITH BREVE"
\u0116 "LATIN CAPITAL LETTER E WITH DOT ABOVE"
\u0117 "LATIN SMALL LETTER E WITH DOT ABOVE"
\u0118 "LATIN CAPITAL LETTER E WITH OGONEK"
\u0119 "LATIN SMALL LETTER E WITH OGONEK"
\u011A "LATIN CAPITAL LETTER E WITH CARON"
\u011B "LATIN SMALL LETTER E WITH CARON"
\u011C "LATIN CAPITAL LETTER G WITH CIRCUMFLEX"
\u011D "LATIN SMALL LETTER G WITH CIRCUMFLEX"
\u011E "LATIN CAPITAL LETTER G WITH BREVE"
\u011F "LATIN SMALL LETTER G WITH BREVE"
\u0120 "LATIN CAPITAL LETTER G WITH DOT ABOVE"
\u0121 "LATIN SMALL LETTER G WITH DOT ABOVE"
\u0122 "LATIN CAPITAL LETTER G WITH CEDILLA"
\u0123 "LATIN SMALL LETTER G WITH CEDILLA"
\u0124 "LATIN CAPITAL LETTER H WITH CIRCUMFLEX"
\u0125 "LATIN SMALL LETTER H WITH CIRCUMFLEX"
\u0126 "LATIN CAPITAL LETTER H WITH STROKE"
\u0127 "LATIN SMALL LETTER H WITH STROKE"
\u0128 "LATIN CAPITAL LETTER I WITH TILDE"
\u0129 "LATIN SMALL LETTER I WITH TILDE"
\u012A "LATIN CAPITAL LETTER I WITH MACRON"
\u012B "LATIN SMALL LETTER I WITH MACRON"
\u012C "LATIN CAPITAL LETTER I WITH BREVE"
\u012D "LATIN SMALL LETTER I WITH BREVE"
\u012E "LATIN CAPITAL LETTER I WITH OGONEK"
\u012F "LATIN SMALL LETTER I WITH OGONEK"
\u0130 "LATIN CAPITAL LETTER I WITH DOT ABOVE"
\u0131 "LATIN SMALL LETTER DOTLESS I"
\u0132 "LATIN CAPITAL LIGATURE IJ"
\u0133 "LATIN SMALL LIGATURE IJ"
\u0134 "LATIN CAPITAL LETTER J WITH CIRCUMFLEX"
\u0135 "LATIN SMALL LETTER J WITH CIRCUMFLEX"
\u0136 "LATIN CAPITAL LETTER K WITH CEDILLA"
\u0137 "LATIN SMALL LETTER K WITH CEDILLA"
\u0138 "LATIN SMALL LETTER KRA"
\u0139 "LATIN CAPITAL LETTER L WITH ACUTE"
\u013A "LATIN SMALL LETTER L WITH ACUTE"
\u013B "LATIN CAPITAL LETTER L WITH CEDILLA"
\u013C "LATIN SMALL LETTER L WITH CEDILLA"
\u013D "LATIN CAPITAL LETTER L WITH CARON"
\u013E "LATIN SMALL LETTER L WITH CARON"
\u013F "LATIN CAPITAL LETTER L WITH MIDDLE DOT"
\u0140 "LATIN SMALL LETTER L WITH MIDDLE DOT"
\u0141 "LATIN CAPITAL LETTER L WITH STROKE"
\u0142 "LATIN SMALL LETTER L WITH STROKE"
\u0143 "LATIN CAPITAL LETTER N WITH ACUTE"
\u0144 "LATIN SMALL LETTER N WITH ACUTE"
\u0145 "LATIN CAPITAL LETTER N WITH CEDILLA"
\u0146 "LATIN SMALL LETTER N WITH CEDILLA"
\u0147 "LATIN CAPITAL LETTER N WITH CARON"
\u0148 "LATIN SMALL LETTER N WITH CARON"
\u0149 "LATIN SMALL LETTER N PRECEDED BY APOSTROPHE"
\u014A "LATIN CAPITAL LETTER ENG"
\u014B "LATIN SMALL LETTER ENG"
\u014C "LATIN CAPITAL LETTER O WITH MACRON"
\u014D "LATIN SMALL LETTER O WITH MACRON"
\u014E "LATIN CAPITAL LETTER O WITH BREVE"
\u014F "LATIN SMALL LETTER O WITH BREVE"
\u0150 "LATIN CAPITAL LETTER O WITH DOUBLE ACUTE"
\u0151 "LATIN SMALL LETTER O WITH DOUBLE ACUTE"
\u0152 "LATIN CAPITAL LIGATURE OE"
\u0153 "LATIN SMALL LIGATURE OE"
\u0154 "LATIN CAPITAL LETTER R WITH ACUTE"
\u0155 "LATIN SMALL LETTER R WITH ACUTE"
\u0156 "LATIN CAPITAL LETTER R WITH CEDILLA"
\u0157 "LATIN SMALL LETTER R WITH CEDILLA"
\u0158 "LATIN CAPITAL LETTER R WITH CARON"
\u0159 "LATIN SMALL LETTER R WITH CARON"
\u015A "LATIN CAPITAL LETTER S WITH ACUTE"
\u015B "LATIN SMALL LETTER S WITH ACUTE"
\u015C "LATIN CAPITAL LETTER S WITH CIRCUMFLEX"
\u015D "LATIN SMALL LETTER S WITH CIRCUMFLEX"
\u015E "LATIN CAPITAL LETTER S WITH CEDILLA"
\u015F "LATIN SMALL LETTER S WITH CEDILLA"
\u0160 "LATIN CAPITAL LETTER S WITH CARON"
\u0161 "LATIN SMALL LETTER S WITH CARON"
\u0162 "LATIN CAPITAL LETTER T WITH CEDILLA"
\u0163 "LATIN SMALL LETTER T WITH CEDILLA"
\u0164 "LATIN CAPITAL LETTER T WITH CARON"
\u0165 "LATIN SMALL LETTER T WITH CARON"
\u0166 "LATIN CAPITAL LETTER T WITH STROKE"
\u0167 "LATIN SMALL LETTER T WITH STROKE"
\u0168 "LATIN CAPITAL LETTER U WITH TILDE"
\u0169 "LATIN SMALL LETTER U WITH TILDE"
\u016A "LATIN CAPITAL LETTER U WITH MACRON"
\u016B "LATIN SMALL LETTER U WITH MACRON"
\u016C "LATIN CAPITAL LETTER U WITH BREVE"
\u016D "LATIN SMALL LETTER U WITH BREVE"
\u016E "LATIN CAPITAL LETTER U WITH RING ABOVE"
\u016F "LATIN SMALL LETTER U WITH RING ABOVE"
\u0170 "LATIN CAPITAL LETTER U WITH DOUBLE ACUTE"
\u0171 "LATIN SMALL LETTER U WITH DOUBLE ACUTE"
\u0172 "LATIN CAPITAL LETTER U WITH OGONEK"
\u0173 "LATIN SMALL LETTER U WITH OGONEK"
\u0174 "LATIN CAPITAL LETTER W WITH CIRCUMFLEX"
\u0175 "LATIN SMALL LETTER W WITH CIRCUMFLEX"
\u0176 "LATIN CAPITAL LETTER Y WITH CIRCUMFLEX"
\u0177 "LATIN SMALL LETTER Y WITH CIRCUMFLEX"
\u0178 "LATIN CAPITAL LETTER Y WITH DIAERESIS"
\u0179 "LATIN CAPITAL LETTER Z WITH ACUTE"
\u017A "LATIN SMALL LETTER Z WITH ACUTE"
\u017B "LATIN CAPITAL LETTER Z WITH DOT ABOVE"
\u017C "LATIN SMALL LETTER Z WITH DOT ABOVE"
\u017D "LATIN CAPITAL LETTER Z WITH CARON"
\u017E "LATIN SMALL LETTER Z WITH CARON"
\u017F "LATIN SMALL LETTER LONG S"
\u0180 "LATIN SMALL LETTER B WITH STROKE"
\u0181 "LATIN CAPITAL LETTER B WITH HOOK"
\u0182 "LATIN CAPITAL LETTER B WITH TOPBAR"
\u0183 "LATIN SMALL LETTER B WITH TOPBAR"
\u0184 "LATIN CAPITAL LETTER TONE SIX"
\u0185 "LATIN SMALL LETTER TONE SIX"
\u0186 "LATIN CAPITAL LETTER OPEN O"
\u0187 "LATIN CAPITAL LETTER C WITH HOOK"
\u0188 "LATIN SMALL LETTER C WITH HOOK"
\u0189 "LATIN CAPITAL LETTER AFRICAN D"
\u018A "LATIN CAPITAL LETTER D WITH HOOK"
\u018B "LATIN CAPITAL LETTER D WITH TOPBAR"
\u018C "LATIN SMALL LETTER D WITH TOPBAR"
\u018D "LATIN SMALL LETTER TURNED DELTA"
\u018E "LATIN CAPITAL LETTER REVERSED E"
\u018F "LATIN CAPITAL LETTER SCHWA"
\u0190 "LATIN CAPITAL LETTER OPEN E"
\u0191 "LATIN CAPITAL LETTER F WITH HOOK"
\u0192 "LATIN SMALL LETTER F WITH HOOK"
\u0193 "LATIN CAPITAL LETTER G WITH HOOK"
\u0194 "LATIN CAPITAL LETTER GAMMA"
\u0195 "LATIN SMALL LETTER HV"
\u0196 "LATIN CAPITAL LETTER IOTA"
\u0197 "LATIN CAPITAL LETTER I WITH STROKE"
\u0198 "LATIN CAPITAL LETTER K WITH HOOK"
\u0199 "LATIN SMALL LETTER K WITH HOOK"
\u019A "LATIN SMALL LETTER L WITH BAR"
\u019B "LATIN SMALL LETTER LAMBDA WITH STROKE"
\u019C "LATIN CAPITAL LETTER TURNED M"
\u019D "LATIN CAPITAL LETTER N WITH LEFT HOOK"
\u019E "LATIN SMALL LETTER N WITH LONG RIGHT LEG"
\u019F "LATIN CAPITAL LETTER O WITH MIDDLE TILDE"
\u01A0 "LATIN CAPITAL LETTER O WITH HORN"
\u01A1 "LATIN SMALL LETTER O WITH HORN"
\u01A2 "LATIN CAPITAL LETTER OI"
\u01A3 "LATIN SMALL LETTER OI"
\u01A4 "LATIN CAPITAL LETTER P WITH HOOK"
\u01A5 "LATIN SMALL LETTER P WITH HOOK"
\u01A6 "LATIN LETTER YR"
\u01A7 "LATIN CAPITAL LETTER TONE TWO"
\u01A8 "LATIN SMALL LETTER TONE TWO"
\u01A9 "LATIN CAPITAL LETTER ESH"
\u01AA "LATIN LETTER REVERSED ESH LOOP"
\u01AB "LATIN SMALL LETTER T WITH PALATAL HOOK"
\u01AC "LATIN CAPITAL LETTER T WITH HOOK"
\u01AD "LATIN SMALL LETTER T WITH HOOK"
\u01AE "LATIN CAPITAL LETTER T WITH RETROFLEX HOOK"
\u01AF "LATIN CAPITAL LETTER U WITH HORN"
\u01B0 "LATIN SMALL LETTER U WITH HORN"
\u01B1 "LATIN CAPITAL LETTER UPSILON"
\u01B2 "LATIN CAPITAL LETTER V WITH HOOK"
\u01B3 "LATIN CAPITAL LETTER Y WITH HOOK"
\u01B4 "LATIN SMALL LETTER Y WITH HOOK"
\u01B5 "LATIN CAPITAL LETTER Z WITH STROKE"
\u01B6 "LATIN SMALL LETTER Z WITH STROKE"
\u01B7 "LATIN CAPITAL LETTER EZH"
\u01B8 "LATIN CAPITAL LETTER EZH REVERSED"
\u01B9 "LATIN SMALL LETTER EZH REVERSED"
\u01BA "LATIN SMALL LETTER EZH WITH TAIL"
\u01BB "LATIN LETTER TWO WITH STROKE"
\u01BC "LATIN CAPITAL LETTER TONE FIVE"
\u01BD "LATIN SMALL LETTER TONE FIVE"
\u01BE "LATIN LETTER INVERTED GLOTTAL STOP WITH STROKE"
\u01BF "LATIN LETTER WYNN"
\u01C0 "LATIN LETTER DENTAL CLICK"
\u01C1 "LATIN LETTER LATERAL CLICK"
\u01C2 "LATIN LETTER ALVEOLAR CLICK"
\u01C3 "LATIN LETTER RETROFLEX CLICK"
\u01C4 "LATIN CAPITAL LETTER DZ WITH CARON"
\u01C5 "LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON"
\u01C6 "LATIN SMALL LETTER DZ WITH CARON"
\u01C7 "LATIN CAPITAL LETTER LJ"
\u01C8 "LATIN CAPITAL LETTER L WITH SMALL LETTER J"
\u01C9 "LATIN SMALL LETTER LJ"
\u01CA "LATIN CAPITAL LETTER NJ"
\u01CB "LATIN CAPITAL LETTER N WITH SMALL LETTER J"
\u01CC "LATIN SMALL LETTER NJ"
\u01CD "LATIN CAPITAL LETTER A WITH CARON"
\u01CE "LATIN SMALL LETTER A WITH CARON"
\u01CF "LATIN CAPITAL LETTER I WITH CARON"
\u01D0 "LATIN SMALL LETTER I WITH CARON"
\u01D1 "LATIN CAPITAL LETTER O WITH CARON"
\u01D2 "LATIN SMALL LETTER O WITH CARON"
\u01D3 "LATIN CAPITAL LETTER U WITH CARON"
\u01D4 "LATIN SMALL LETTER U WITH CARON"
\u01D5 "LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON"
\u01D6 "LATIN SMALL LETTER U WITH DIAERESIS AND MACRON"
\u01D7 "LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE"
\u01D8 "LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE"
\u01D9 "LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON"
\u01DA "LATIN SMALL LETTER U WITH DIAERESIS AND CARON"
\u01DB "LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE"
\u01DC "LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE"
\u01DD "LATIN SMALL LETTER TURNED E"
\u01DE "LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON"
\u01DF "LATIN SMALL LETTER A WITH DIAERESIS AND MACRON"
\u01E0 "LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON"
\u01E1 "LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON"
\u01E2 "LATIN CAPITAL LETTER AE WITH MACRON"
\u01E3 "LATIN SMALL LETTER AE WITH MACRON"
\u01E4 "LATIN CAPITAL LETTER G WITH STROKE"
\u01E5 "LATIN SMALL LETTER G WITH STROKE"
\u01E6 "LATIN CAPITAL LETTER G WITH CARON"
\u01E7 "LATIN SMALL LETTER G WITH CARON"
\u01E8 "LATIN CAPITAL LETTER K WITH CARON"
\u01E9 "LATIN SMALL LETTER K WITH CARON"
\u01EA "LATIN CAPITAL LETTER O WITH OGONEK"
\u01EB "LATIN SMALL LETTER O WITH OGONEK"
\u01EC "LATIN CAPITAL LETTER O WITH OGONEK AND MACRON"
\u01ED "LATIN SMALL LETTER O WITH OGONEK AND MACRON"
\u01EE "LATIN CAPITAL LETTER EZH WITH CARON"
\u01EF "LATIN SMALL LETTER EZH WITH CARON"
\u01F0 "LATIN SMALL LETTER J WITH CARON"
\u01F1 "LATIN CAPITAL LETTER DZ"
\u01F2 "LATIN CAPITAL LETTER D WITH SMALL LETTER Z"
\u01F3 "LATIN SMALL LETTER DZ"
\u01F4 "LATIN CAPITAL LETTER G WITH ACUTE"
\u01F5 "LATIN SMALL LETTER G WITH ACUTE"
\u01F6 "LATIN CAPITAL LETTER HWAIR"
\u01F7 "LATIN CAPITAL LETTER WYNN"
\u01F8 "LATIN CAPITAL LETTER N WITH GRAVE"
\u01F9 "LATIN SMALL LETTER N WITH GRAVE"
\u01FA "LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE"
\u01FB "LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE"
\u01FC "LATIN CAPITAL LETTER AE WITH ACUTE"
\u01FD "LATIN SMALL LETTER AE WITH ACUTE"
\u01FE "LATIN CAPITAL LETTER O WITH STROKE AND ACUTE"
\u01FF "LATIN SMALL LETTER O WITH STROKE AND ACUTE"
\u0200 "LATIN CAPITAL LETTER A WITH DOUBLE GRAVE"
\u0201 "LATIN SMALL LETTER A WITH DOUBLE GRAVE"
\u0202 "LATIN CAPITAL LETTER A WITH INVERTED BREVE"
\u0203 "LATIN SMALL LETTER A WITH INVERTED BREVE"
\u0204 "LATIN CAPITAL LETTER E WITH DOUBLE GRAVE"
\u0205 "LATIN SMALL LETTER E WITH DOUBLE GRAVE"
\u0206 "LATIN CAPITAL LETTER E WITH INVERTED BREVE"
\u0207 "LATIN SMALL LETTER E WITH INVERTED BREVE"
\u0208 "LATIN CAPITAL LETTER I WITH DOUBLE GRAVE"
\u0209 "LATIN SMALL LETTER I WITH DOUBLE GRAVE"
\u020A "LATIN CAPITAL LETTER I WITH INVERTED BREVE"
\u020B "LATIN SMALL LETTER I WITH INVERTED BREVE"
\u020C "LATIN CAPITAL LETTER O WITH DOUBLE GRAVE"
\u020D "LATIN SMALL LETTER O WITH DOUBLE GRAVE"
\u020E "LATIN CAPITAL LETTER O WITH INVERTED BREVE"
\u020F "LATIN SMALL LETTER O WITH INVERTED BREVE"
\u0210 "LATIN CAPITAL LETTER R WITH DOUBLE GRAVE"
\u0211 "LATIN SMALL LETTER R WITH DOUBLE GRAVE"
\u0212 "LATIN CAPITAL LETTER R WITH INVERTED BREVE"
\u0213 "LATIN SMALL LETTER R WITH INVERTED BREVE"
\u0214 "LATIN CAPITAL LETTER U WITH DOUBLE GRAVE"
\u0215 "LATIN SMALL LETTER U WITH DOUBLE GRAVE"
\u0216 "LATIN CAPITAL LETTER U WITH INVERTED BREVE"
\u0217 "LATIN SMALL LETTER U WITH INVERTED BREVE"
\u0218 "LATIN CAPITAL LETTER S WITH COMMA BELOW"
\u0219 "LATIN SMALL LETTER S WITH COMMA BELOW"
\u021A "LATIN CAPITAL LETTER T WITH COMMA BELOW"
\u021B "LATIN SMALL LETTER T WITH COMMA BELOW"
\u021C "LATIN CAPITAL LETTER YOGH"
\u021D "LATIN SMALL LETTER YOGH"
\u021E "LATIN CAPITAL LETTER H WITH CARON"
\u021F "LATIN SMALL LETTER H WITH CARON"
\u0220 "LATIN CAPITAL LETTER N WITH LONG RIGHT LEG"
\u0221 "LATIN SMALL LETTER D WITH CURL"
\u0222 "LATIN CAPITAL LETTER OU"
\u0223 "LATIN SMALL LETTER OU"
\u0224 "LATIN CAPITAL LETTER Z WITH HOOK"
\u0225 "LATIN SMALL LETTER Z WITH HOOK"
\u0226 "LATIN CAPITAL LETTER A WITH DOT ABOVE"
\u0227 "LATIN SMALL LETTER A WITH DOT ABOVE"
\u0228 "LATIN CAPITAL LETTER E WITH CEDILLA"
\u0229 "LATIN SMALL LETTER E WITH CEDILLA"
\u022A "LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON"
\u022B "LATIN SMALL LETTER O WITH DIAERESIS AND MACRON"
\u022C "LATIN CAPITAL LETTER O WITH TILDE AND MACRON"
\u022D "LATIN SMALL LETTER O WITH TILDE AND MACRON"
\u022E "LATIN CAPITAL LETTER O WITH DOT ABOVE"
\u022F "LATIN SMALL LETTER O WITH DOT ABOVE"
\u0230 "LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON"
\u0231 "LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON"
\u0232 "LATIN CAPITAL LETTER Y WITH MACRON"
\u0233 "LATIN SMALL LETTER Y WITH MACRON"
\u0234 "LATIN SMALL LETTER L WITH CURL"
\u0235 "LATIN SMALL LETTER N WITH CURL"
\u0236 "LATIN SMALL LETTER T WITH CURL"
\u0237 "LATIN SMALL LETTER DOTLESS J"
\u0238 "LATIN SMALL LETTER DB DIGRAPH"
\u0239 "LATIN SMALL LETTER QP DIGRAPH"
\u023A "LATIN CAPITAL LETTER A WITH STROKE"
\u023B "LATIN CAPITAL LETTER C WITH STROKE"
\u023C "LATIN SMALL LETTER C WITH STROKE"
\u023D "LATIN CAPITAL LETTER L WITH BAR"
\u023E "LATIN CAPITAL LETTER T WITH DIAGONAL STROKE"
\u023F "LATIN SMALL LETTER S WITH SWASH TAIL"
\u0240 "LATIN SMALL LETTER Z WITH SWASH TAIL"
\u0241 "LATIN CAPITAL LETTER GLOTTAL STOP"
\u0242 "LATIN SMALL LETTER GLOTTAL STOP"
\u0243 "LATIN CAPITAL LETTER B WITH STROKE"
\u0244 "LATIN CAPITAL LETTER U BAR"
\u0245 "LATIN CAPITAL LETTER TURNED V"
\u0246 "LATIN CAPITAL LETTER E WITH STROKE"
\u0247 "LATIN SMALL LETTER E WITH STROKE"
\u0248 "LATIN CAPITAL LETTER J WITH STROKE"
\u0249 "LATIN SMALL LETTER J WITH STROKE"
\u024A "LATIN CAPITAL LETTER SMALL Q WITH HOOK TAIL"
\u024B "LATIN SMALL LETTER Q WITH HOOK TAIL"
\u024C "LATIN CAPITAL LETTER R WITH STROKE"
\u024D "LATIN SMALL LETTER R WITH STROKE"
\u024E "LATIN CAPITAL LETTER Y WITH STROKE"
\u024F "LATIN SMALL LETTER Y WITH STROKE"
\u0250 "LATIN SMALL LETTER TURNED A"
\u0251 "LATIN SMALL LETTER ALPHA"
\u0252 "LATIN SMALL LETTER TURNED ALPHA"
\u0253 "LATIN SMALL LETTER B WITH HOOK"
\u0254 "LATIN SMALL LETTER OPEN O"
\u0255 "LATIN SMALL LETTER C WITH CURL"
\u0256 "LATIN SMALL LETTER D WITH TAIL"
\u0257 "LATIN SMALL LETTER D WITH HOOK"
\u0258 "LATIN SMALL LETTER REVERSED E"
\u0259 "LATIN SMALL LETTER SCHWA"
\u025A "LATIN SMALL LETTER SCHWA WITH HOOK"
\u025B "LATIN SMALL LETTER OPEN E"
\u025C "LATIN SMALL LETTER REVERSED OPEN E"
\u025D "LATIN SMALL LETTER REVERSED OPEN E WITH HOOK"
\u025E "LATIN SMALL LETTER CLOSED REVERSED OPEN E"
\u025F "LATIN SMALL LETTER DOTLESS J WITH STROKE"
\u0260 "LATIN SMALL LETTER G WITH HOOK"
\u0261 "LATIN SMALL LETTER SCRIPT G"
\u0262 "LATIN LETTER SMALL CAPITAL G"
\u0263 "LATIN SMALL LETTER GAMMA"
\u0264 "LATIN SMALL LETTER RAMS HORN"
\u0265 "LATIN SMALL LETTER TURNED H"
\u0266 "LATIN SMALL LETTER H WITH HOOK"
\u0267 "LATIN SMALL LETTER HENG WITH HOOK"
\u0268 "LATIN SMALL LETTER I WITH STROKE"
\u0269 "LATIN SMALL LETTER IOTA"
\u026A "LATIN LETTER SMALL CAPITAL I"
\u026B "LATIN SMALL LETTER L WITH MIDDLE TILDE"
\u026C "LATIN SMALL LETTER L WITH BELT"
\u026D "LATIN SMALL LETTER L WITH RETROFLEX HOOK"
\u026E "LATIN SMALL LETTER LEZH"
\u026F "LATIN SMALL LETTER TURNED M"
\u0270 "LATIN SMALL LETTER TURNED M WITH LONG LEG"
\u0271 "LATIN SMALL LETTER M WITH HOOK"
\u0272 "LATIN SMALL LETTER N WITH LEFT HOOK"
\u0273 "LATIN SMALL LETTER N WITH RETROFLEX HOOK"
\u0274 "LATIN LETTER SMALL CAPITAL N"
\u0275 "LATIN SMALL LETTER BARRED O"
\u0276 "LATIN LETTER SMALL CAPITAL OE"
\u0277 "LATIN SMALL LETTER CLOSED OMEGA"
\u0278 "LATIN SMALL LETTER PHI"
\u0279 "LATIN SMALL LETTER TURNED R"
\u027A "LATIN SMALL LETTER TURNED R WITH LONG LEG"
\u027B "LATIN SMALL LETTER TURNED R WITH HOOK"
\u027C "LATIN SMALL LETTER R WITH LONG LEG"
\u027D "LATIN SMALL LETTER R WITH TAIL"
\u027E "LATIN SMALL LETTER R WITH FISHHOOK"
\u027F "LATIN SMALL LETTER REVERSED R WITH FISHHOOK"
\u0280 "LATIN LETTER SMALL CAPITAL R"
\u0281 "LATIN LETTER SMALL CAPITAL INVERTED R"
\u0282 "LATIN SMALL LETTER S WITH HOOK"
\u0283 "LATIN SMALL LETTER ESH"
\u0284 "LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK"
\u0285 "LATIN SMALL LETTER SQUAT REVERSED ESH"
\u0286 "LATIN SMALL LETTER ESH WITH CURL"
\u0287 "LATIN SMALL LETTER TURNED T"
\u0288 "LATIN SMALL LETTER T WITH RETROFLEX HOOK"
\u0289 "LATIN SMALL LETTER U BAR"
\u028A "LATIN SMALL LETTER UPSILON"
\u028B "LATIN SMALL LETTER V WITH HOOK"
\u028C "LATIN SMALL LETTER TURNED V"
\u028D "LATIN SMALL LETTER TURNED W"
\u028E "LATIN SMALL LETTER TURNED Y"
\u028F "LATIN LETTER SMALL CAPITAL Y"
\u0290 "LATIN SMALL LETTER Z WITH RETROFLEX HOOK"
\u0291 "LATIN SMALL LETTER Z WITH CURL"
\u0292 "LATIN SMALL LETTER EZH"
\u0293 "LATIN SMALL LETTER EZH WITH CURL"
\u0294 "LATIN LETTER GLOTTAL STOP"
\u0295 "LATIN LETTER PHARYNGEAL VOICED FRICATIVE"
\u0296 "LATIN LETTER INVERTED GLOTTAL STOP"
\u0297 "LATIN LETTER STRETCHED C"
\u0298 "LATIN LETTER BILABIAL CLICK"
\u0299 "LATIN LETTER SMALL CAPITAL B"
\u029A "LATIN SMALL LETTER CLOSED OPEN E"
\u029B "LATIN LETTER SMALL CAPITAL G WITH HOOK"
\u029C "LATIN LETTER SMALL CAPITAL H"
\u029D "LATIN SMALL LETTER J WITH CROSSED-TAIL"
\u029E "LATIN SMALL LETTER TURNED K"
\u029F "LATIN LETTER SMALL CAPITAL L"
\u02A0 "LATIN SMALL LETTER Q WITH HOOK"
\u02A1 "LATIN LETTER GLOTTAL STOP WITH STROKE"
\u02A2 "LATIN LETTER REVERSED GLOTTAL STOP WITH STROKE"
\u02A3 "LATIN SMALL LETTER DZ DIGRAPH"
\u02A4 "LATIN SMALL LETTER DEZH DIGRAPH"
\u02A5 "LATIN SMALL LETTER DZ DIGRAPH WITH CURL"
\u02A6 "LATIN SMALL LETTER TS DIGRAPH"
\u02A7 "LATIN SMALL LETTER TESH DIGRAPH"
\u02A8 "LATIN SMALL LETTER TC DIGRAPH WITH CURL"
\u02A9 "LATIN SMALL LETTER FENG DIGRAPH"
\u02AA "LATIN SMALL LETTER LS DIGRAPH"
\u02AB "LATIN SMALL LETTER LZ DIGRAPH"
\u02AC "LATIN LETTER BILABIAL PERCUSSIVE"
\u02AD "LATIN LETTER BIDENTAL PERCUSSIVE"
\u02AE "LATIN SMALL LETTER TURNED H WITH FISHHOOK"
\u02AF "LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL"
\u02B0 "MODIFIER LETTER SMALL H"
\u02B1 "MODIFIER LETTER SMALL H WITH HOOK"
\u02B2 "MODIFIER LETTER SMALL J"
\u02B3 "MODIFIER LETTER SMALL R"
\u02B4 "MODIFIER LETTER SMALL TURNED R"
\u02B5 "MODIFIER LETTER SMALL TURNED R WITH HOOK"
\u02B6 "MODIFIER LETTER SMALL CAPITAL INVERTED R"
\u02B7 "MODIFIER LETTER SMALL W"
\u02B8 "MODIFIER LETTER SMALL Y"
\u02B9 "MODIFIER LETTER PRIME"
\u02BA "MODIFIER LETTER DOUBLE PRIME"
\u02BB "MODIFIER LETTER TURNED COMMA"
\u02BC "MODIFIER LETTER APOSTROPHE"
\u02BD "MODIFIER LETTER REVERSED COMMA"
\u02BE "MODIFIER LETTER RIGHT HALF RING"
\u02BF "MODIFIER LETTER LEFT HALF RING"
\u02C0 "MODIFIER LETTER GLOTTAL STOP"
\u02C1 "MODIFIER LETTER REVERSED GLOTTAL STOP"
\u02C2 "MODIFIER LETTER LEFT ARROWHEAD"
\u02C3 "MODIFIER LETTER RIGHT ARROWHEAD"
\u02C4 "MODIFIER LETTER UP ARROWHEAD"
\u02C5 "MODIFIER LETTER DOWN ARROWHEAD"
\u02C6 "MODIFIER LETTER CIRCUMFLEX ACCENT"
\u02C7 "CARON"
\u02C8 "MODIFIER LETTER VERTICAL LINE"
\u02C9 "MODIFIER LETTER MACRON"
\u02CA "MODIFIER LETTER ACUTE ACCENT"
\u02CB "MODIFIER LETTER GRAVE ACCENT"
\u02CC "MODIFIER LETTER LOW VERTICAL LINE"
\u02CD "MODIFIER LETTER LOW MACRON"
\u02CE "MODIFIER LETTER LOW GRAVE ACCENT"
\u02CF "MODIFIER LETTER LOW ACUTE ACCENT"
\u02D0 "MODIFIER LETTER TRIANGULAR COLON"
\u02D1 "MODIFIER LETTER HALF TRIANGULAR COLON"
\u02D2 "MODIFIER LETTER CENTRED RIGHT HALF RING"
\u02D3 "MODIFIER LETTER CENTRED LEFT HALF RING"
\u02D4 "MODIFIER LETTER UP TACK"
\u02D5 "MODIFIER LETTER DOWN TACK"
\u02D6 "MODIFIER LETTER PLUS SIGN"
\u02D7 "MODIFIER LETTER MINUS SIGN"
\u02D8 "BREVE"
\u02D9 "DOT ABOVE"
\u02DA "RING ABOVE"
\u02DB "OGONEK"
\u02DC "SMALL TILDE"
\u02DD "DOUBLE ACUTE ACCENT"
\u02DE "MODIFIER LETTER RHOTIC HOOK"
\u02DF "MODIFIER LETTER CROSS ACCENT"
\u02E0 "MODIFIER LETTER SMALL GAMMA"
\u02E1 "MODIFIER LETTER SMALL L"
\u02E2 "MODIFIER LETTER SMALL S"
\u02E3 "MODIFIER LETTER SMALL X"
\u02E4 "MODIFIER LETTER SMALL REVERSED GLOTTAL STOP"
\u02E5 "MODIFIER LETTER EXTRA-HIGH TONE BAR"
\u02E6 "MODIFIER LETTER HIGH TONE BAR"
\u02E7 "MODIFIER LETTER MID TONE BAR"
\u02E8 "MODIFIER LETTER LOW TONE BAR"
\u02E9 "MODIFIER LETTER EXTRA-LOW TONE BAR"
\u02EA "MODIFIER LETTER YIN DEPARTING TONE MARK"
\u02EB "MODIFIER LETTER YANG DEPARTING TONE MARK"
\u02EC "MODIFIER LETTER VOICING"
\u02ED "MODIFIER LETTER UNASPIRATED"
\u02EE "MODIFIER LETTER DOUBLE APOSTROPHE"
\u02EF "MODIFIER LETTER LOW DOWN ARROWHEAD"
\u02F0 "MODIFIER LETTER LOW UP ARROWHEAD"
\u02F1 "MODIFIER LETTER LOW LEFT ARROWHEAD"
\u02F2 "MODIFIER LETTER LOW RIGHT ARROWHEAD"
\u02F3 "MODIFIER LETTER LOW RING"
\u02F4 "MODIFIER LETTER MIDDLE GRAVE ACCENT"
\u02F5 "MODIFIER LETTER MIDDLE DOUBLE GRAVE ACCENT"
\u02F6 "MODIFIER LETTER MIDDLE DOUBLE ACUTE ACCENT"
\u02F7 "MODIFIER LETTER LOW TILDE"
\u02F8 "MODIFIER LETTER RAISED COLON"
\u02F9 "MODIFIER LETTER BEGIN HIGH TONE"
\u02FA "MODIFIER LETTER END HIGH TONE"
\u02FB "MODIFIER LETTER BEGIN LOW TONE"
\u02FC "MODIFIER LETTER END LOW TONE"
\u02FD "MODIFIER LETTER SHELF"
\u02FE "MODIFIER LETTER OPEN SHELF"
\u02FF "MODIFIER LETTER LOW LEFT ARROW"
\u0300 "COMBINING GRAVE ACCENT"
\u0301 "COMBINING ACUTE ACCENT"
\u0302 "COMBINING CIRCUMFLEX ACCENT"
\u0303 "COMBINING TILDE"
\u0304 "COMBINING MACRON"
\u0305 "COMBINING OVERLINE"
\u0306 "COMBINING BREVE"
\u0307 "COMBINING DOT ABOVE"
\u0308 "COMBINING DIAERESIS"
\u0309 "COMBINING HOOK ABOVE"
\u030A "COMBINING RING ABOVE"
\u030B "COMBINING DOUBLE ACUTE ACCENT"
\u030C "COMBINING CARON"
\u030D "COMBINING VERTICAL LINE ABOVE"
\u030E "COMBINING DOUBLE VERTICAL LINE ABOVE"
\u030F "COMBINING DOUBLE GRAVE ACCENT"
\u0310 "COMBINING CANDRABINDU"
\u0311 "COMBINING INVERTED BREVE"
\u0312 "COMBINING TURNED COMMA ABOVE"
\u0313 "COMBINING COMMA ABOVE"
\u0314 "COMBINING REVERSED COMMA ABOVE"
\u0315 "COMBINING COMMA ABOVE RIGHT"
\u0316 "COMBINING GRAVE ACCENT BELOW"
\u0317 "COMBINING ACUTE ACCENT BELOW"
\u0318 "COMBINING LEFT TACK BELOW"
\u0319 "COMBINING RIGHT TACK BELOW"
\u031A "COMBINING LEFT ANGLE ABOVE"
\u031B "COMBINING HORN"
\u031C "COMBINING LEFT HALF RING BELOW"
\u031D "COMBINING UP TACK BELOW"
\u031E "COMBINING DOWN TACK BELOW"
\u031F "COMBINING PLUS SIGN BELOW"
\u0320 "COMBINING MINUS SIGN BELOW"
\u0321 "COMBINING PALATALIZED HOOK BELOW"
\u0322 "COMBINING RETROFLEX HOOK BELOW"
\u0323 "COMBINING DOT BELOW"
\u0324 "COMBINING DIAERESIS BELOW"
\u0325 "COMBINING RING BELOW"
\u0326 "COMBINING COMMA BELOW"
\u0327 "COMBINING CEDILLA"
\u0328 "COMBINING OGONEK"
\u0329 "COMBINING VERTICAL LINE BELOW"
\u032A "COMBINING BRIDGE BELOW"
\u032B "COMBINING INVERTED DOUBLE ARCH BELOW"
\u032C "COMBINING CARON BELOW"
\u032D "COMBINING CIRCUMFLEX ACCENT BELOW"
\u032E "COMBINING BREVE BELOW"
\u032F "COMBINING INVERTED BREVE BELOW"
\u0330 "COMBINING TILDE BELOW"
\u0331 "COMBINING MACRON BELOW"
\u0332 "COMBINING LOW LINE"
\u0333 "COMBINING DOUBLE LOW LINE"
\u0334 "COMBINING TILDE OVERLAY"
\u0335 "COMBINING SHORT STROKE OVERLAY"
\u0336 "COMBINING LONG STROKE OVERLAY"
\u0337 "COMBINING SHORT SOLIDUS OVERLAY"
\u0338 "COMBINING LONG SOLIDUS OVERLAY"
\u0339 "COMBINING RIGHT HALF RING BELOW"
\u033A "COMBINING INVERTED BRIDGE BELOW"
\u033B "COMBINING SQUARE BELOW"
\u033C "COMBINING SEAGULL BELOW"
\u033D "COMBINING X ABOVE"
\u033E "COMBINING VERTICAL TILDE"
\u033F "COMBINING DOUBLE OVERLINE"
\u0340 "COMBINING GRAVE TONE MARK"
\u0341 "COMBINING ACUTE TONE MARK"
\u0342 "COMBINING GREEK PERISPOMENI"
\u0343 "COMBINING GREEK KORONIS"
\u0344 "COMBINING GREEK DIALYTIKA TONOS"
\u0345 "COMBINING GREEK YPOGEGRAMMENI"
\u0346 "COMBINING BRIDGE ABOVE"
\u0347 "COMBINING EQUALS SIGN BELOW"
\u0348 "COMBINING DOUBLE VERTICAL LINE BELOW"
\u0349 "COMBINING LEFT ANGLE BELOW"
\u034A "COMBINING NOT TILDE ABOVE"
\u034B "COMBINING HOMOTHETIC ABOVE"
\u034C "COMBINING ALMOST EQUAL TO ABOVE"
\u034D "COMBINING LEFT RIGHT ARROW BELOW"
\u034E "COMBINING UPWARDS ARROW BELOW"
\u034F "COMBINING GRAPHEME JOINER"
\u0350 "COMBINING RIGHT ARROWHEAD ABOVE"
\u0351 "COMBINING LEFT HALF RING ABOVE"
\u0352 "COMBINING FERMATA"
\u0353 "COMBINING X BELOW"
\u0354 "COMBINING LEFT ARROWHEAD BELOW"
\u0355 "COMBINING RIGHT ARROWHEAD BELOW"
\u0356 "COMBINING RIGHT ARROWHEAD AND UP ARROWHEAD BELOW"
\u0357 "COMBINING RIGHT HALF RING ABOVE"
\u0358 "COMBINING DOT ABOVE RIGHT"
\u0359 "COMBINING ASTERISK BELOW"
\u035A "COMBINING DOUBLE RING BELOW"
\u035B "COMBINING ZIGZAG ABOVE"
\u035C "COMBINING DOUBLE BREVE BELOW"
\u035D "COMBINING DOUBLE BREVE"
\u035E "COMBINING DOUBLE MACRON"
\u035F "COMBINING DOUBLE MACRON BELOW"
\u0360 "COMBINING DOUBLE TILDE"
\u0361 "COMBINING DOUBLE INVERTED BREVE"
\u0362 "COMBINING DOUBLE RIGHTWARDS ARROW BELOW"
\u0363 "COMBINING LATIN SMALL LETTER A"
\u0364 "COMBINING LATIN SMALL LETTER E"
\u0365 "COMBINING LATIN SMALL LETTER I"
\u0366 "COMBINING LATIN SMALL LETTER O"
\u0367 "COMBINING LATIN SMALL LETTER U"
\u0368 "COMBINING LATIN SMALL LETTER C"
\u0369 "COMBINING LATIN SMALL LETTER D"
\u036A "COMBINING LATIN SMALL LETTER H"
\u036B "COMBINING LATIN SMALL LETTER M"
\u036C "COMBINING LATIN SMALL LETTER R"
\u036D "COMBINING LATIN SMALL LETTER T"
\u036E "COMBINING LATIN SMALL LETTER V"
\u036F "COMBINING LATIN SMALL LETTER X"
\u0370 "GREEK CAPITAL LETTER HETA"
\u0371 "GREEK SMALL LETTER HETA"
\u0372 "GREEK CAPITAL LETTER ARCHAIC SAMPI"
\u0373 "GREEK SMALL LETTER ARCHAIC SAMPI"
\u0374 "GREEK NUMERAL SIGN"
\u0375 "GREEK LOWER NUMERAL SIGN"
\u0376 "GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA"
\u0377 "GREEK SMALL LETTER PAMPHYLIAN DIGAMMA"
\u037A "GREEK YPOGEGRAMMENI"
\u037B "GREEK SMALL REVERSED LUNATE SIGMA SYMBOL"
\u037C "GREEK SMALL DOTTED LUNATE SIGMA SYMBOL"
\u037D "GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL"
\u037E "GREEK QUESTION MARK"
\u0384 "GREEK TONOS"
\u0385 "GREEK DIALYTIKA TONOS"
\u0386 "GREEK CAPITAL LETTER ALPHA WITH TONOS"
\u0387 "GREEK ANO TELEIA"
\u0388 "GREEK CAPITAL LETTER EPSILON WITH TONOS"
\u0389 "GREEK CAPITAL LETTER ETA WITH TONOS"
\u038A "GREEK CAPITAL LETTER IOTA WITH TONOS"
\u038C "GREEK CAPITAL LETTER OMICRON WITH TONOS"
\u038E "GREEK CAPITAL LETTER UPSILON WITH TONOS"
\u038F "GREEK CAPITAL LETTER OMEGA WITH TONOS"
\u0390 "GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS"
\u0391 "GREEK CAPITAL LETTER ALPHA"
\u0392 "GREEK CAPITAL LETTER BETA"
\u0393 "GREEK CAPITAL LETTER GAMMA"
\u0394 "GREEK CAPITAL LETTER DELTA"
\u0395 "GREEK CAPITAL LETTER EPSILON"
\u0396 "GREEK CAPITAL LETTER ZETA"
\u0397 "GREEK CAPITAL LETTER ETA"
\u0398 "GREEK CAPITAL LETTER THETA"
\u0399 "GREEK CAPITAL LETTER IOTA"
\u039A "GREEK CAPITAL LETTER KAPPA"
\u039B "GREEK CAPITAL LETTER LAMDA"
\u039C "GREEK CAPITAL LETTER MU"
\u039D "GREEK CAPITAL LETTER NU"
\u039E "GREEK CAPITAL LETTER XI"
\u039F "GREEK CAPITAL LETTER OMICRON"
\u03A0 "GREEK CAPITAL LETTER PI"
\u03A1 "GREEK CAPITAL LETTER RHO"
\u03A3 "GREEK CAPITAL LETTER SIGMA"
\u03A4 "GREEK CAPITAL LETTER TAU"
\u03A5 "GREEK CAPITAL LETTER UPSILON"
\u03A6 "GREEK CAPITAL LETTER PHI"
\u03A7 "GREEK CAPITAL LETTER CHI"
\u03A8 "GREEK CAPITAL LETTER PSI"
\u03A9 "GREEK CAPITAL LETTER OMEGA"
\u03AA "GREEK CAPITAL LETTER IOTA WITH DIALYTIKA"
\u03AB "GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA"
\u03AC "GREEK SMALL LETTER ALPHA WITH TONOS"
\u03AD "GREEK SMALL LETTER EPSILON WITH TONOS"
\u03AE "GREEK SMALL LETTER ETA WITH TONOS"
\u03AF "GREEK SMALL LETTER IOTA WITH TONOS"
\u03B0 "GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS"
\u03B1 "GREEK SMALL LETTER ALPHA"
\u03B2 "GREEK SMALL LETTER BETA"
\u03B3 "GREEK SMALL LETTER GAMMA"
\u03B4 "GREEK SMALL LETTER DELTA"
\u03B5 "GREEK SMALL LETTER EPSILON"
\u03B6 "GREEK SMALL LETTER ZETA"
\u03B7 "GREEK SMALL LETTER ETA"
\u03B8 "GREEK SMALL LETTER THETA"
\u03B9 "GREEK SMALL LETTER IOTA"
\u03BA "GREEK SMALL LETTER KAPPA"
\u03BB "GREEK SMALL LETTER LAMDA"
\u03BC "GREEK SMALL LETTER MU"
\u03BD "GREEK SMALL LETTER NU"
\u03BE "GREEK SMALL LETTER XI"
\u03BF "GREEK SMALL LETTER OMICRON"
\u03C0 "GREEK SMALL LETTER PI"
\u03C1 "GREEK SMALL LETTER RHO"
\u03C2 "GREEK SMALL LETTER FINAL SIGMA"
\u03C3 "GREEK SMALL LETTER SIGMA"
\u03C4 "GREEK SMALL LETTER TAU"
\u03C5 "GREEK SMALL LETTER UPSILON"
\u03C6 "GREEK SMALL LETTER PHI"
\u03C7 "GREEK SMALL LETTER CHI"
\u03C8 "GREEK SMALL LETTER PSI"
\u03C9 "GREEK SMALL LETTER OMEGA"
\u03CA "GREEK SMALL LETTER IOTA WITH DIALYTIKA"
\u03CB "GREEK SMALL LETTER UPSILON WITH DIALYTIKA"
\u03CC "GREEK SMALL LETTER OMICRON WITH TONOS"
\u03CD "GREEK SMALL LETTER UPSILON WITH TONOS"
\u03CE "GREEK SMALL LETTER OMEGA WITH TONOS"
\u03CF "GREEK CAPITAL KAI SYMBOL"
\u03D0 "GREEK BETA SYMBOL"
\u03D1 "GREEK THETA SYMBOL"
\u03D2 "GREEK UPSILON WITH HOOK SYMBOL"
\u03D3 "GREEK UPSILON WITH ACUTE AND HOOK SYMBOL"
\u03D4 "GREEK UPSILON WITH DIAERESIS AND HOOK SYMBOL"
\u03D5 "GREEK PHI SYMBOL"
\u03D6 "GREEK PI SYMBOL"
\u03D7 "GREEK KAI SYMBOL"
\u03D8 "GREEK LETTER ARCHAIC KOPPA"
\u03D9 "GREEK SMALL LETTER ARCHAIC KOPPA"
\u03DA "GREEK LETTER STIGMA"
\u03DB "GREEK SMALL LETTER STIGMA"
\u03DC "GREEK LETTER DIGAMMA"
\u03DD "GREEK SMALL LETTER DIGAMMA"
\u03DE "GREEK LETTER KOPPA"
\u03DF "GREEK SMALL LETTER KOPPA"
\u03E0 "GREEK LETTER SAMPI"
\u03E1 "GREEK SMALL LETTER SAMPI"
\u03E2 "COPTIC CAPITAL LETTER SHEI"
\u03E3 "COPTIC SMALL LETTER SHEI"
\u03E4 "COPTIC CAPITAL LETTER FEI"
\u03E5 "COPTIC SMALL LETTER FEI"
\u03E6 "COPTIC CAPITAL LETTER KHEI"
\u03E7 "COPTIC SMALL LETTER KHEI"
\u03E8 "COPTIC CAPITAL LETTER HORI"
\u03E9 "COPTIC SMALL LETTER HORI"
\u03EA "COPTIC CAPITAL LETTER GANGIA"
\u03EB "COPTIC SMALL LETTER GANGIA"
\u03EC "COPTIC CAPITAL LETTER SHIMA"
\u03ED "COPTIC SMALL LETTER SHIMA"
\u03EE "COPTIC CAPITAL LETTER DEI"
\u03EF "COPTIC SMALL LETTER DEI"
\u03F0 "GREEK KAPPA SYMBOL"
\u03F1 "GREEK RHO SYMBOL"
\u03F2 "GREEK LUNATE SIGMA SYMBOL"
\u03F3 "GREEK LETTER YOT"
\u03F4 "GREEK CAPITAL THETA SYMBOL"
\u03F5 "GREEK LUNATE EPSILON SYMBOL"
\u03F6 "GREEK REVERSED LUNATE EPSILON SYMBOL"
\u03F7 "GREEK CAPITAL LETTER SHO"
\u03F8 "GREEK SMALL LETTER SHO"
\u03F9 "GREEK CAPITAL LUNATE SIGMA SYMBOL"
\u03FA "GREEK CAPITAL LETTER SAN"
\u03FB "GREEK SMALL LETTER SAN"
\u03FC "GREEK RHO WITH STROKE SYMBOL"
\u03FD "GREEK CAPITAL REVERSED LUNATE SIGMA SYMBOL"
\u03FE "GREEK CAPITAL DOTTED LUNATE SIGMA SYMBOL"
\u03FF "GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL"
\u0400 "CYRILLIC CAPITAL LETTER IE WITH GRAVE"
\u0401 "CYRILLIC CAPITAL LETTER IO"
\u0402 "CYRILLIC CAPITAL LETTER DJE"
\u0403 "CYRILLIC CAPITAL LETTER GJE"
\u0404 "CYRILLIC CAPITAL LETTER UKRAINIAN IE"
\u0405 "CYRILLIC CAPITAL LETTER DZE"
\u0406 "CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I"
\u0407 "CYRILLIC CAPITAL LETTER YI"
\u0408 "CYRILLIC CAPITAL LETTER JE"
\u0409 "CYRILLIC CAPITAL LETTER LJE"
\u040A "CYRILLIC CAPITAL LETTER NJE"
\u040B "CYRILLIC CAPITAL LETTER TSHE"
\u040C "CYRILLIC CAPITAL LETTER KJE"
\u040D "CYRILLIC CAPITAL LETTER I WITH GRAVE"
\u040E "CYRILLIC CAPITAL LETTER SHORT U"
\u040F "CYRILLIC CAPITAL LETTER DZHE"
\u0410 "CYRILLIC CAPITAL LETTER A"
\u0411 "CYRILLIC CAPITAL LETTER BE"
\u0412 "CYRILLIC CAPITAL LETTER VE"
\u0413 "CYRILLIC CAPITAL LETTER GHE"
\u0414 "CYRILLIC CAPITAL LETTER DE"
\u0415 "CYRILLIC CAPITAL LETTER IE"
\u0416 "CYRILLIC CAPITAL LETTER ZHE"
\u0417 "CYRILLIC CAPITAL LETTER ZE"
\u0418 "CYRILLIC CAPITAL LETTER I"
\u0419 "CYRILLIC CAPITAL LETTER SHORT I"
\u041A "CYRILLIC CAPITAL LETTER KA"
\u041B "CYRILLIC CAPITAL LETTER EL"
\u041C "CYRILLIC CAPITAL LETTER EM"
\u041D "CYRILLIC CAPITAL LETTER EN"
\u041E "CYRILLIC CAPITAL LETTER O"
\u041F "CYRILLIC CAPITAL LETTER PE"
\u0420 "CYRILLIC CAPITAL LETTER ER"
\u0421 "CYRILLIC CAPITAL LETTER ES"
\u0422 "CYRILLIC CAPITAL LETTER TE"
\u0423 "CYRILLIC CAPITAL LETTER U"
\u0424 "CYRILLIC CAPITAL LETTER EF"
\u0425 "CYRILLIC CAPITAL LETTER HA"
\u0426 "CYRILLIC CAPITAL LETTER TSE"
\u0427 "CYRILLIC CAPITAL LETTER CHE"
\u0428 "CYRILLIC CAPITAL LETTER SHA"
\u0429 "CYRILLIC CAPITAL LETTER SHCHA"
\u042A "CYRILLIC CAPITAL LETTER HARD SIGN"
\u042B "CYRILLIC CAPITAL LETTER YERU"
\u042C "CYRILLIC CAPITAL LETTER SOFT SIGN"
\u042D "CYRILLIC CAPITAL LETTER E"
\u042E "CYRILLIC CAPITAL LETTER YU"
\u042F "CYRILLIC CAPITAL LETTER YA"
\u0430 "CYRILLIC SMALL LETTER A"
\u0431 "CYRILLIC SMALL LETTER BE"
\u0432 "CYRILLIC SMALL LETTER VE"
\u0433 "CYRILLIC SMALL LETTER GHE"
\u0434 "CYRILLIC SMALL LETTER DE"
\u0435 "CYRILLIC SMALL LETTER IE"
\u0436 "CYRILLIC SMALL LETTER ZHE"
\u0437 "CYRILLIC SMALL LETTER ZE"
\u0438 "CYRILLIC SMALL LETTER I"
\u0439 "CYRILLIC SMALL LETTER SHORT I"
\u043A "CYRILLIC SMALL LETTER KA"
\u043B "CYRILLIC SMALL LETTER EL"
\u043C "CYRILLIC SMALL LETTER EM"
\u043D "CYRILLIC SMALL LETTER EN"
\u043E "CYRILLIC SMALL LETTER O"
\u043F "CYRILLIC SMALL LETTER PE"
\u0440 "CYRILLIC SMALL LETTER ER"
\u0441 "CYRILLIC SMALL LETTER ES"
\u0442 "CYRILLIC SMALL LETTER TE"
\u0443 "CYRILLIC SMALL LETTER U"
\u0444 "CYRILLIC SMALL LETTER EF"
\u0445 "CYRILLIC SMALL LETTER HA"
\u0446 "CYRILLIC SMALL LETTER TSE"
\u0447 "CYRILLIC SMALL LETTER CHE"
\u0448 "CYRILLIC SMALL LETTER SHA"
\u0449 "CYRILLIC SMALL LETTER SHCHA"
\u044A "CYRILLIC SMALL LETTER HARD SIGN"
\u044B "CYRILLIC SMALL LETTER YERU"
\u044C "CYRILLIC SMALL LETTER SOFT SIGN"
\u044D "CYRILLIC SMALL LETTER E"
\u044E "CYRILLIC SMALL LETTER YU"
\u044F "CYRILLIC SMALL LETTER YA"
\u0450 "CYRILLIC SMALL LETTER IE WITH GRAVE"
\u0451 "CYRILLIC SMALL LETTER IO"
\u0452 "CYRILLIC SMALL LETTER DJE"
\u0453 "CYRILLIC SMALL LETTER GJE"
\u0454 "CYRILLIC SMALL LETTER UKRAINIAN IE"
\u0455 "CYRILLIC SMALL LETTER DZE"
\u0456 "CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I"
\u0457 "CYRILLIC SMALL LETTER YI"
\u0458 "CYRILLIC SMALL LETTER JE"
\u0459 "CYRILLIC SMALL LETTER LJE"
\u045A "CYRILLIC SMALL LETTER NJE"
\u045B "CYRILLIC SMALL LETTER TSHE"
\u045C "CYRILLIC SMALL LETTER KJE"
\u045D "CYRILLIC SMALL LETTER I WITH GRAVE"
\u045E "CYRILLIC SMALL LETTER SHORT U"
\u045F "CYRILLIC SMALL LETTER DZHE"
\u0460 "CYRILLIC CAPITAL LETTER OMEGA"
\u0461 "CYRILLIC SMALL LETTER OMEGA"
\u0462 "CYRILLIC CAPITAL LETTER YAT"
\u0463 "CYRILLIC SMALL LETTER YAT"
\u0464 "CYRILLIC CAPITAL LETTER IOTIFIED E"
\u0465 "CYRILLIC SMALL LETTER IOTIFIED E"
\u0466 "CYRILLIC CAPITAL LETTER LITTLE YUS"
\u0467 "CYRILLIC SMALL LETTER LITTLE YUS"
\u0468 "CYRILLIC CAPITAL LETTER IOTIFIED LITTLE YUS"
\u0469 "CYRILLIC SMALL LETTER IOTIFIED LITTLE YUS"
\u046A "CYRILLIC CAPITAL LETTER BIG YUS"
\u046B "CYRILLIC SMALL LETTER BIG YUS"
\u046C "CYRILLIC CAPITAL LETTER IOTIFIED BIG YUS"
\u046D "CYRILLIC SMALL LETTER IOTIFIED BIG YUS"
\u046E "CYRILLIC CAPITAL LETTER KSI"
\u046F "CYRILLIC SMALL LETTER KSI"
\u0470 "CYRILLIC CAPITAL LETTER PSI"
\u0471 "CYRILLIC SMALL LETTER PSI"
\u0472 "CYRILLIC CAPITAL LETTER FITA"
\u0473 "CYRILLIC SMALL LETTER FITA"
\u0474 "CYRILLIC CAPITAL LETTER IZHITSA"
\u0475 "CYRILLIC SMALL LETTER IZHITSA"
\u0476 "CYRILLIC CAPITAL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT"
\u0477 "CYRILLIC SMALL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT"
\u0478 "CYRILLIC CAPITAL LETTER UK"
\u0479 "CYRILLIC SMALL LETTER UK"
\u047A "CYRILLIC CAPITAL LETTER ROUND OMEGA"
\u047B "CYRILLIC SMALL LETTER ROUND OMEGA"
\u047C "CYRILLIC CAPITAL LETTER OMEGA WITH TITLO"
\u047D "CYRILLIC SMALL LETTER OMEGA WITH TITLO"
\u047E "CYRILLIC CAPITAL LETTER OT"
\u047F "CYRILLIC SMALL LETTER OT"
\u0480 "CYRILLIC CAPITAL LETTER KOPPA"
\u0481 "CYRILLIC SMALL LETTER KOPPA"
\u0482 "CYRILLIC THOUSANDS SIGN"
\u0483 "COMBINING CYRILLIC TITLO"
\u0484 "COMBINING CYRILLIC PALATALIZATION"
\u0485 "COMBINING CYRILLIC DASIA PNEUMATA"
\u0486 "COMBINING CYRILLIC PSILI PNEUMATA"
\u0487 "COMBINING CYRILLIC POKRYTIE"
\u0488 "COMBINING CYRILLIC HUNDRED THOUSANDS SIGN"
\u0489 "COMBINING CYRILLIC MILLIONS SIGN"
\u048A "CYRILLIC CAPITAL LETTER SHORT I WITH TAIL"
\u048B "CYRILLIC SMALL LETTER SHORT I WITH TAIL"
\u048C "CYRILLIC CAPITAL LETTER SEMISOFT SIGN"
\u048D "CYRILLIC SMALL LETTER SEMISOFT SIGN"
\u048E "CYRILLIC CAPITAL LETTER ER WITH TICK"
\u048F "CYRILLIC SMALL LETTER ER WITH TICK"
\u0490 "CYRILLIC CAPITAL LETTER GHE WITH UPTURN"
\u0491 "CYRILLIC SMALL LETTER GHE WITH UPTURN"
\u0492 "CYRILLIC CAPITAL LETTER GHE WITH STROKE"
\u0493 "CYRILLIC SMALL LETTER GHE WITH STROKE"
\u0494 "CYRILLIC CAPITAL LETTER GHE WITH MIDDLE HOOK"
\u0495 "CYRILLIC SMALL LETTER GHE WITH MIDDLE HOOK"
\u0496 "CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER"
\u0497 "CYRILLIC SMALL LETTER ZHE WITH DESCENDER"
\u0498 "CYRILLIC CAPITAL LETTER ZE WITH DESCENDER"
\u0499 "CYRILLIC SMALL LETTER ZE WITH DESCENDER"
\u049A "CYRILLIC CAPITAL LETTER KA WITH DESCENDER"
\u049B "CYRILLIC SMALL LETTER KA WITH DESCENDER"
\u049C "CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE"
\u049D "CYRILLIC SMALL LETTER KA WITH VERTICAL STROKE"
\u049E "CYRILLIC CAPITAL LETTER KA WITH STROKE"
\u049F "CYRILLIC SMALL LETTER KA WITH STROKE"
\u04A0 "CYRILLIC CAPITAL LETTER BASHKIR KA"
\u04A1 "CYRILLIC SMALL LETTER BASHKIR KA"
\u04A2 "CYRILLIC CAPITAL LETTER EN WITH DESCENDER"
\u04A3 "CYRILLIC SMALL LETTER EN WITH DESCENDER"
\u04A4 "CYRILLIC CAPITAL LIGATURE EN GHE"
\u04A5 "CYRILLIC SMALL LIGATURE EN GHE"
\u04A6 "CYRILLIC CAPITAL LETTER PE WITH MIDDLE HOOK"
\u04A7 "CYRILLIC SMALL LETTER PE WITH MIDDLE HOOK"
\u04A8 "CYRILLIC CAPITAL LETTER ABKHASIAN HA"
\u04A9 "CYRILLIC SMALL LETTER ABKHASIAN HA"
\u04AA "CYRILLIC CAPITAL LETTER ES WITH DESCENDER"
\u04AB "CYRILLIC SMALL LETTER ES WITH DESCENDER"
\u04AC "CYRILLIC CAPITAL LETTER TE WITH DESCENDER"
\u04AD "CYRILLIC SMALL LETTER TE WITH DESCENDER"
\u04AE "CYRILLIC CAPITAL LETTER STRAIGHT U"
\u04AF "CYRILLIC SMALL LETTER STRAIGHT U"
\u04B0 "CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE"
\u04B1 "CYRILLIC SMALL LETTER STRAIGHT U WITH STROKE"
\u04B2 "CYRILLIC CAPITAL LETTER HA WITH DESCENDER"
\u04B3 "CYRILLIC SMALL LETTER HA WITH DESCENDER"
\u04B4 "CYRILLIC CAPITAL LIGATURE TE TSE"
\u04B5 "CYRILLIC SMALL LIGATURE TE TSE"
\u04B6 "CYRILLIC CAPITAL LETTER CHE WITH DESCENDER"
\u04B7 "CYRILLIC SMALL LETTER CHE WITH DESCENDER"
\u04B8 "CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE"
\u04B9 "CYRILLIC SMALL LETTER CHE WITH VERTICAL STROKE"
\u04BA "CYRILLIC CAPITAL LETTER SHHA"
\u04BB "CYRILLIC SMALL LETTER SHHA"
\u04BC "CYRILLIC CAPITAL LETTER ABKHASIAN CHE"
\u04BD "CYRILLIC SMALL LETTER ABKHASIAN CHE"
\u04BE "CYRILLIC CAPITAL LETTER ABKHASIAN CHE WITH DESCENDER"
\u04BF "CYRILLIC SMALL LETTER ABKHASIAN CHE WITH DESCENDER"
\u04C0 "CYRILLIC LETTER PALOCHKA"
\u04C1 "CYRILLIC CAPITAL LETTER ZHE WITH BREVE"
\u04C2 "CYRILLIC SMALL LETTER ZHE WITH BREVE"
\u04C3 "CYRILLIC CAPITAL LETTER KA WITH HOOK"
\u04C4 "CYRILLIC SMALL LETTER KA WITH HOOK"
\u04C5 "CYRILLIC CAPITAL LETTER EL WITH TAIL"
\u04C6 "CYRILLIC SMALL LETTER EL WITH TAIL"
\u04C7 "CYRILLIC CAPITAL LETTER EN WITH HOOK"
\u04C8 "CYRILLIC SMALL LETTER EN WITH HOOK"
\u04C9 "CYRILLIC CAPITAL LETTER EN WITH TAIL"
\u04CA "CYRILLIC SMALL LETTER EN WITH TAIL"
\u04CB "CYRILLIC CAPITAL LETTER KHAKASSIAN CHE"
\u04CC "CYRILLIC SMALL LETTER KHAKASSIAN CHE"
\u04CD "CYRILLIC CAPITAL LETTER EM WITH TAIL"
\u04CE "CYRILLIC SMALL LETTER EM WITH TAIL"
\u04CF "CYRILLIC SMALL LETTER PALOCHKA"
\u04D0 "CYRILLIC CAPITAL LETTER A WITH BREVE"
\u04D1 "CYRILLIC SMALL LETTER A WITH BREVE"
\u04D2 "CYRILLIC CAPITAL LETTER A WITH DIAERESIS"
\u04D3 "CYRILLIC SMALL LETTER A WITH DIAERESIS"
\u04D4 "CYRILLIC CAPITAL LIGATURE A IE"
\u04D5 "CYRILLIC SMALL LIGATURE A IE"
\u04D6 "CYRILLIC CAPITAL LETTER IE WITH BREVE"
\u04D7 "CYRILLIC SMALL LETTER IE WITH BREVE"
\u04D8 "CYRILLIC CAPITAL LETTER SCHWA"
\u04D9 "CYRILLIC SMALL LETTER SCHWA"
\u04DA "CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS"
\u04DB "CYRILLIC SMALL LETTER SCHWA WITH DIAERESIS"
\u04DC "CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS"
\u04DD "CYRILLIC SMALL LETTER ZHE WITH DIAERESIS"
\u04DE "CYRILLIC CAPITAL LETTER ZE WITH DIAERESIS"
\u04DF "CYRILLIC SMALL LETTER ZE WITH DIAERESIS"
\u04E0 "CYRILLIC CAPITAL LETTER ABKHASIAN DZE"
\u04E1 "CYRILLIC SMALL LETTER ABKHASIAN DZE"
\u04E2 "CYRILLIC CAPITAL LETTER I WITH MACRON"
\u04E3 "CYRILLIC SMALL LETTER I WITH MACRON"
\u04E4 "CYRILLIC CAPITAL LETTER I WITH DIAERESIS"
\u04E5 "CYRILLIC SMALL LETTER I WITH DIAERESIS"
\u04E6 "CYRILLIC CAPITAL LETTER O WITH DIAERESIS"
\u04E7 "CYRILLIC SMALL LETTER O WITH DIAERESIS"
\u04E8 "CYRILLIC CAPITAL LETTER BARRED O"
\u04E9 "CYRILLIC SMALL LETTER BARRED O"
\u04EA "CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS"
\u04EB "CYRILLIC SMALL LETTER BARRED O WITH DIAERESIS"
\u04EC "CYRILLIC CAPITAL LETTER E WITH DIAERESIS"
\u04ED "CYRILLIC SMALL LETTER E WITH DIAERESIS"
\u04EE "CYRILLIC CAPITAL LETTER U WITH MACRON"
\u04EF "CYRILLIC SMALL LETTER U WITH MACRON"
\u04F0 "CYRILLIC CAPITAL LETTER U WITH DIAERESIS"
\u04F1 "CYRILLIC SMALL LETTER U WITH DIAERESIS"
\u04F2 "CYRILLIC CAPITAL LETTER U WITH DOUBLE ACUTE"
\u04F3 "CYRILLIC SMALL LETTER U WITH DOUBLE ACUTE"
\u04F4 "CYRILLIC CAPITAL LETTER CHE WITH DIAERESIS"
\u04F5 "CYRILLIC SMALL LETTER CHE WITH DIAERESIS"
\u04F6 "CYRILLIC CAPITAL LETTER GHE WITH DESCENDER"
\u04F7 "CYRILLIC SMALL LETTER GHE WITH DESCENDER"
\u04F8 "CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS"
\u04F9 "CYRILLIC SMALL LETTER YERU WITH DIAERESIS"
\u04FA "CYRILLIC CAPITAL LETTER GHE WITH STROKE AND HOOK"
\u04FB "CYRILLIC SMALL LETTER GHE WITH STROKE AND HOOK"
\u04FC "CYRILLIC CAPITAL LETTER HA WITH HOOK"
\u04FD "CYRILLIC SMALL LETTER HA WITH HOOK"
\u04FE "CYRILLIC CAPITAL LETTER HA WITH STROKE"
\u04FF "CYRILLIC SMALL LETTER HA WITH STROKE"
\u0500 "CYRILLIC CAPITAL LETTER KOMI DE"
\u0501 "CYRILLIC SMALL LETTER KOMI DE"
\u0502 "CYRILLIC CAPITAL LETTER KOMI DJE"
\u0503 "CYRILLIC SMALL LETTER KOMI DJE"
\u0504 "CYRILLIC CAPITAL LETTER KOMI ZJE"
\u0505 "CYRILLIC SMALL LETTER KOMI ZJE"
\u0506 "CYRILLIC CAPITAL LETTER KOMI DZJE"
\u0507 "CYRILLIC SMALL LETTER KOMI DZJE"
\u0508 "CYRILLIC CAPITAL LETTER KOMI LJE"
\u0509 "CYRILLIC SMALL LETTER KOMI LJE"
\u050A "CYRILLIC CAPITAL LETTER KOMI NJE"
\u050B "CYRILLIC SMALL LETTER KOMI NJE"
\u050C "CYRILLIC CAPITAL LETTER KOMI SJE"
\u050D "CYRILLIC SMALL LETTER KOMI SJE"
\u050E "CYRILLIC CAPITAL LETTER KOMI TJE"
\u050F "CYRILLIC SMALL LETTER KOMI TJE"
\u0510 "CYRILLIC CAPITAL LETTER REVERSED ZE"
\u0511 "CYRILLIC SMALL LETTER REVERSED ZE"
\u0512 "CYRILLIC CAPITAL LETTER EL WITH HOOK"
\u0513 "CYRILLIC SMALL LETTER EL WITH HOOK"
\u0514 "CYRILLIC CAPITAL LETTER LHA"
\u0515 "CYRILLIC SMALL LETTER LHA"
\u0516 "CYRILLIC CAPITAL LETTER RHA"
\u0517 "CYRILLIC SMALL LETTER RHA"
\u0518 "CYRILLIC CAPITAL LETTER YAE"
\u0519 "CYRILLIC SMALL LETTER YAE"
\u051A "CYRILLIC CAPITAL LETTER QA"
\u051B "CYRILLIC SMALL LETTER QA"
\u051C "CYRILLIC CAPITAL LETTER WE"
\u051D "CYRILLIC SMALL LETTER WE"
\u051E "CYRILLIC CAPITAL LETTER ALEUT KA"
\u051F "CYRILLIC SMALL LETTER ALEUT KA"
\u0520 "CYRILLIC CAPITAL LETTER EL WITH MIDDLE HOOK"
\u0521 "CYRILLIC SMALL LETTER EL WITH MIDDLE HOOK"
\u0522 "CYRILLIC CAPITAL LETTER EN WITH MIDDLE HOOK"
\u0523 "CYRILLIC SMALL LETTER EN WITH MIDDLE HOOK"
\u0531 "ARMENIAN CAPITAL LETTER AYB"
\u0532 "ARMENIAN CAPITAL LETTER BEN"
\u0533 "ARMENIAN CAPITAL LETTER GIM"
\u0534 "ARMENIAN CAPITAL LETTER DA"
\u0535 "ARMENIAN CAPITAL LETTER ECH"
\u0536 "ARMENIAN CAPITAL LETTER ZA"
\u0537 "ARMENIAN CAPITAL LETTER EH"
\u0538 "ARMENIAN CAPITAL LETTER ET"
\u0539 "ARMENIAN CAPITAL LETTER TO"
\u053A "ARMENIAN CAPITAL LETTER ZHE"
\u053B "ARMENIAN CAPITAL LETTER INI"
\u053C "ARMENIAN CAPITAL LETTER LIWN"
\u053D "ARMENIAN CAPITAL LETTER XEH"
\u053E "ARMENIAN CAPITAL LETTER CA"
\u053F "ARMENIAN CAPITAL LETTER KEN"
\u0540 "ARMENIAN CAPITAL LETTER HO"
\u0541 "ARMENIAN CAPITAL LETTER JA"
\u0542 "ARMENIAN CAPITAL LETTER GHAD"
\u0543 "ARMENIAN CAPITAL LETTER CHEH"
\u0544 "ARMENIAN CAPITAL LETTER MEN"
\u0545 "ARMENIAN CAPITAL LETTER YI"
\u0546 "ARMENIAN CAPITAL LETTER NOW"
\u0547 "ARMENIAN CAPITAL LETTER SHA"
\u0548 "ARMENIAN CAPITAL LETTER VO"
\u0549 "ARMENIAN CAPITAL LETTER CHA"
\u054A "ARMENIAN CAPITAL LETTER PEH"
\u054B "ARMENIAN CAPITAL LETTER JHEH"
\u054C "ARMENIAN CAPITAL LETTER RA"
\u054D "ARMENIAN CAPITAL LETTER SEH"
\u054E "ARMENIAN CAPITAL LETTER VEW"
\u054F "ARMENIAN CAPITAL LETTER TIWN"
\u0550 "ARMENIAN CAPITAL LETTER REH"
\u0551 "ARMENIAN CAPITAL LETTER CO"
\u0552 "ARMENIAN CAPITAL LETTER YIWN"
\u0553 "ARMENIAN CAPITAL LETTER PIWR"
\u0554 "ARMENIAN CAPITAL LETTER KEH"
\u0555 "ARMENIAN CAPITAL LETTER OH"
\u0556 "ARMENIAN CAPITAL LETTER FEH"
\u0559 "ARMENIAN MODIFIER LETTER LEFT HALF RING"
\u055A "ARMENIAN APOSTROPHE"
\u055B "ARMENIAN EMPHASIS MARK"
\u055C "ARMENIAN EXCLAMATION MARK"
\u055D "ARMENIAN COMMA"
\u055E "ARMENIAN QUESTION MARK"
\u055F "ARMENIAN ABBREVIATION MARK"
\u0561 "ARMENIAN SMALL LETTER AYB"
\u0562 "ARMENIAN SMALL LETTER BEN"
\u0563 "ARMENIAN SMALL LETTER GIM"
\u0564 "ARMENIAN SMALL LETTER DA"
\u0565 "ARMENIAN SMALL LETTER ECH"
\u0566 "ARMENIAN SMALL LETTER ZA"
\u0567 "ARMENIAN SMALL LETTER EH"
\u0568 "ARMENIAN SMALL LETTER ET"
\u0569 "ARMENIAN SMALL LETTER TO"
\u056A "ARMENIAN SMALL LETTER ZHE"
\u056B "ARMENIAN SMALL LETTER INI"
\u056C "ARMENIAN SMALL LETTER LIWN"
\u056D "ARMENIAN SMALL LETTER XEH"
\u056E "ARMENIAN SMALL LETTER CA"
\u056F "ARMENIAN SMALL LETTER KEN"
\u0570 "ARMENIAN SMALL LETTER HO"
\u0571 "ARMENIAN SMALL LETTER JA"
\u0572 "ARMENIAN SMALL LETTER GHAD"
\u0573 "ARMENIAN SMALL LETTER CHEH"
\u0574 "ARMENIAN SMALL LETTER MEN"
\u0575 "ARMENIAN SMALL LETTER YI"
\u0576 "ARMENIAN SMALL LETTER NOW"
\u0577 "ARMENIAN SMALL LETTER SHA"
\u0578 "ARMENIAN SMALL LETTER VO"
\u0579 "ARMENIAN SMALL LETTER CHA"
\u057A "ARMENIAN SMALL LETTER PEH"
\u057B "ARMENIAN SMALL LETTER JHEH"
\u057C "ARMENIAN SMALL LETTER RA"
\u057D "ARMENIAN SMALL LETTER SEH"
\u057E "ARMENIAN SMALL LETTER VEW"
\u057F "ARMENIAN SMALL LETTER TIWN"
\u0580 "ARMENIAN SMALL LETTER REH"
\u0581 "ARMENIAN SMALL LETTER CO"
\u0582 "ARMENIAN SMALL LETTER YIWN"
\u0583 "ARMENIAN SMALL LETTER PIWR"
\u0584 "ARMENIAN SMALL LETTER KEH"
\u0585 "ARMENIAN SMALL LETTER OH"
\u0586 "ARMENIAN SMALL LETTER FEH"
\u0587 "ARMENIAN SMALL LIGATURE ECH YIWN"
\u0589 "ARMENIAN FULL STOP"
\u058A "ARMENIAN HYPHEN"
\u0591 "HEBREW ACCENT ETNAHTA"
\u0592 "HEBREW ACCENT SEGOL"
\u0593 "HEBREW ACCENT SHALSHELET"
\u0594 "HEBREW ACCENT ZAQEF QATAN"
\u0595 "HEBREW ACCENT ZAQEF GADOL"
\u0596 "HEBREW ACCENT TIPEHA"
\u0597 "HEBREW ACCENT REVIA"
\u0598 "HEBREW ACCENT ZARQA"
\u0599 "HEBREW ACCENT PASHTA"
\u059A "HEBREW ACCENT YETIV"
\u059B "HEBREW ACCENT TEVIR"
\u059C "HEBREW ACCENT GERESH"
\u059D "HEBREW ACCENT GERESH MUQDAM"
\u059E "HEBREW ACCENT GERSHAYIM"
\u059F "HEBREW ACCENT QARNEY PARA"
\u05A0 "HEBREW ACCENT TELISHA GEDOLA"
\u05A1 "HEBREW ACCENT PAZER"
\u05A2 "HEBREW ACCENT ATNAH HAFUKH"
\u05A3 "HEBREW ACCENT MUNAH"
\u05A4 "HEBREW ACCENT MAHAPAKH"
\u05A5 "HEBREW ACCENT MERKHA"
\u05A6 "HEBREW ACCENT MERKHA KEFULA"
\u05A7 "HEBREW ACCENT DARGA"
\u05A8 "HEBREW ACCENT QADMA"
\u05A9 "HEBREW ACCENT TELISHA QETANA"
\u05AA "HEBREW ACCENT YERAH BEN YOMO"
\u05AB "HEBREW ACCENT OLE"
\u05AC "HEBREW ACCENT ILUY"
\u05AD "HEBREW ACCENT DEHI"
\u05AE "HEBREW ACCENT ZINOR"
\u05AF "HEBREW MARK MASORA CIRCLE"
\u05B0 "HEBREW POINT SHEVA"
\u05B1 "HEBREW POINT HATAF SEGOL"
\u05B2 "HEBREW POINT HATAF PATAH"
\u05B3 "HEBREW POINT HATAF QAMATS"
\u05B4 "HEBREW POINT HIRIQ"
\u05B5 "HEBREW POINT TSERE"
\u05B6 "HEBREW POINT SEGOL"
\u05B7 "HEBREW POINT PATAH"
\u05B8 "HEBREW POINT QAMATS"
\u05B9 "HEBREW POINT HOLAM"
\u05BA "HEBREW POINT HOLAM HASER FOR VAV"
\u05BB "HEBREW POINT QUBUTS"
\u05BC "HEBREW POINT DAGESH OR MAPIQ"
\u05BD "HEBREW POINT METEG"
\u05BE "HEBREW PUNCTUATION MAQAF"
\u05BF "HEBREW POINT RAFE"
\u05C0 "HEBREW PUNCTUATION PASEQ"
\u05C1 "HEBREW POINT SHIN DOT"
\u05C2 "HEBREW POINT SIN DOT"
\u05C3 "HEBREW PUNCTUATION SOF PASUQ"
\u05C4 "HEBREW MARK UPPER DOT"
\u05C5 "HEBREW MARK LOWER DOT"
\u05C6 "HEBREW PUNCTUATION NUN HAFUKHA"
\u05C7 "HEBREW POINT QAMATS QATAN"
\u05D0 "HEBREW LETTER ALEF"
\u05D1 "HEBREW LETTER BET"
\u05D2 "HEBREW LETTER GIMEL"
\u05D3 "HEBREW LETTER DALET"
\u05D4 "HEBREW LETTER HE"
\u05D5 "HEBREW LETTER VAV"
\u05D6 "HEBREW LETTER ZAYIN"
\u05D7 "HEBREW LETTER HET"
\u05D8 "HEBREW LETTER TET"
\u05D9 "HEBREW LETTER YOD"
\u05DA "HEBREW LETTER FINAL KAF"
\u05DB "HEBREW LETTER KAF"
\u05DC "HEBREW LETTER LAMED"
\u05DD "HEBREW LETTER FINAL MEM"
\u05DE "HEBREW LETTER MEM"
\u05DF "HEBREW LETTER FINAL NUN"
\u05E0 "HEBREW LETTER NUN"
\u05E1 "HEBREW LETTER SAMEKH"
\u05E2 "HEBREW LETTER AYIN"
\u05E3 "HEBREW LETTER FINAL PE"
\u05E4 "HEBREW LETTER PE"
\u05E5 "HEBREW LETTER FINAL TSADI"
\u05E6 "HEBREW LETTER TSADI"
\u05E7 "HEBREW LETTER QOF"
\u05E8 "HEBREW LETTER RESH"
\u05E9 "HEBREW LETTER SHIN"
\u05EA "HEBREW LETTER TAV"
\u05F0 "HEBREW LIGATURE YIDDISH DOUBLE VAV"
\u05F1 "HEBREW LIGATURE YIDDISH VAV YOD"
\u05F2 "HEBREW LIGATURE YIDDISH DOUBLE YOD"
\u05F3 "HEBREW PUNCTUATION GERESH"
\u05F4 "HEBREW PUNCTUATION GERSHAYIM"
\u0600 "ARABIC NUMBER SIGN"
\u0601 "ARABIC SIGN SANAH"
\u0602 "ARABIC FOOTNOTE MARKER"
\u0603 "ARABIC SIGN SAFHA"
\u0606 "ARABIC-INDIC CUBE ROOT"
\u0607 "ARABIC-INDIC FOURTH ROOT"
\u0608 "ARABIC RAY"
\u0609 "ARABIC-INDIC PER MILLE SIGN"
\u060A "ARABIC-INDIC PER TEN THOUSAND SIGN"
\u060B "AFGHANI SIGN"
\u060C "ARABIC COMMA"
\u060D "ARABIC DATE SEPARATOR"
\u060E "ARABIC POETIC VERSE SIGN"
\u060F "ARABIC SIGN MISRA"
\u0610 "ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM"
\u0611 "ARABIC SIGN ALAYHE ASSALLAM"
\u0612 "ARABIC SIGN RAHMATULLAH ALAYHE"
\u0613 "ARABIC SIGN RADI ALLAHOU ANHU"
\u0614 "ARABIC SIGN TAKHALLUS"
\u0615 "ARABIC SMALL HIGH TAH"
\u0616 "ARABIC SMALL HIGH LIGATURE ALEF WITH LAM WITH YEH"
\u0617 "ARABIC SMALL HIGH ZAIN"
\u0618 "ARABIC SMALL FATHA"
\u0619 "ARABIC SMALL DAMMA"
\u061A "ARABIC SMALL KASRA"
\u061B "ARABIC SEMICOLON"
\u061E "ARABIC TRIPLE DOT PUNCTUATION MARK"
\u061F "ARABIC QUESTION MARK"
\u0621 "ARABIC LETTER HAMZA"
\u0622 "ARABIC LETTER ALEF WITH MADDA ABOVE"
\u0623 "ARABIC LETTER ALEF WITH HAMZA ABOVE"
\u0624 "ARABIC LETTER WAW WITH HAMZA ABOVE"
\u0625 "ARABIC LETTER ALEF WITH HAMZA BELOW"
\u0626 "ARABIC LETTER YEH WITH HAMZA ABOVE"
\u0627 "ARABIC LETTER ALEF"
\u0628 "ARABIC LETTER BEH"
\u0629 "ARABIC LETTER TEH MARBUTA"
\u062A "ARABIC LETTER TEH"
\u062B "ARABIC LETTER THEH"
\u062C "ARABIC LETTER JEEM"
\u062D "ARABIC LETTER HAH"
\u062E "ARABIC LETTER KHAH"
\u062F "ARABIC LETTER DAL"
\u0630 "ARABIC LETTER THAL"
\u0631 "ARABIC LETTER REH"
\u0632 "ARABIC LETTER ZAIN"
\u0633 "ARABIC LETTER SEEN"
\u0634 "ARABIC LETTER SHEEN"
\u0635 "ARABIC LETTER SAD"
\u0636 "ARABIC LETTER DAD"
\u0637 "ARABIC LETTER TAH"
\u0638 "ARABIC LETTER ZAH"
\u0639 "ARABIC LETTER AIN"
\u063A "ARABIC LETTER GHAIN"
\u063B "ARABIC LETTER KEHEH WITH TWO DOTS ABOVE"
\u063C "ARABIC LETTER KEHEH WITH THREE DOTS BELOW"
\u063D "ARABIC LETTER FARSI YEH WITH INVERTED V"
\u063E "ARABIC LETTER FARSI YEH WITH TWO DOTS ABOVE"
\u063F "ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE"
\u0640 "ARABIC TATWEEL"
\u0641 "ARABIC LETTER FEH"
\u0642 "ARABIC LETTER QAF"
\u0643 "ARABIC LETTER KAF"
\u0644 "ARABIC LETTER LAM"
\u0645 "ARABIC LETTER MEEM"
\u0646 "ARABIC LETTER NOON"
\u0647 "ARABIC LETTER HEH"
\u0648 "ARABIC LETTER WAW"
\u0649 "ARABIC LETTER ALEF MAKSURA"
\u064A "ARABIC LETTER YEH"
\u064B "ARABIC FATHATAN"
\u064C "ARABIC DAMMATAN"
\u064D "ARABIC KASRATAN"
\u064E "ARABIC FATHA"
\u064F "ARABIC DAMMA"
\u0650 "ARABIC KASRA"
\u0651 "ARABIC SHADDA"
\u0652 "ARABIC SUKUN"
\u0653 "ARABIC MADDAH ABOVE"
\u0654 "ARABIC HAMZA ABOVE"
\u0655 "ARABIC HAMZA BELOW"
\u0656 "ARABIC SUBSCRIPT ALEF"
\u0657 "ARABIC INVERTED DAMMA"
\u0658 "ARABIC MARK NOON GHUNNA"
\u0659 "ARABIC ZWARAKAY"
\u065A "ARABIC VOWEL SIGN SMALL V ABOVE"
\u065B "ARABIC VOWEL SIGN INVERTED SMALL V ABOVE"
\u065C "ARABIC VOWEL SIGN DOT BELOW"
\u065D "ARABIC REVERSED DAMMA"
\u065E "ARABIC FATHA WITH TWO DOTS"
\u0660 "ARABIC-INDIC DIGIT ZERO"
\u0661 "ARABIC-INDIC DIGIT ONE"
\u0662 "ARABIC-INDIC DIGIT TWO"
\u0663 "ARABIC-INDIC DIGIT THREE"
\u0664 "ARABIC-INDIC DIGIT FOUR"
\u0665 "ARABIC-INDIC DIGIT FIVE"
\u0666 "ARABIC-INDIC DIGIT SIX"
\u0667 "ARABIC-INDIC DIGIT SEVEN"
\u0668 "ARABIC-INDIC DIGIT EIGHT"
\u0669 "ARABIC-INDIC DIGIT NINE"
\u066A "ARABIC PERCENT SIGN"
\u066B "ARABIC DECIMAL SEPARATOR"
\u066C "ARABIC THOUSANDS SEPARATOR"
\u066D "ARABIC FIVE POINTED STAR"
\u066E "ARABIC LETTER DOTLESS BEH"
\u066F "ARABIC LETTER DOTLESS QAF"
\u0670 "ARABIC LETTER SUPERSCRIPT ALEF"
\u0671 "ARABIC LETTER ALEF WASLA"
\u0672 "ARABIC LETTER ALEF WITH WAVY HAMZA ABOVE"
\u0673 "ARABIC LETTER ALEF WITH WAVY HAMZA BELOW"
\u0674 "ARABIC LETTER HIGH HAMZA"
\u0675 "ARABIC LETTER HIGH HAMZA ALEF"
\u0676 "ARABIC LETTER HIGH HAMZA WAW"
\u0677 "ARABIC LETTER U WITH HAMZA ABOVE"
\u0678 "ARABIC LETTER HIGH HAMZA YEH"
\u0679 "ARABIC LETTER TTEH"
\u067A "ARABIC LETTER TTEHEH"
\u067B "ARABIC LETTER BEEH"
\u067C "ARABIC LETTER TEH WITH RING"
\u067D "ARABIC LETTER TEH WITH THREE DOTS ABOVE DOWNWARDS"
\u067E "ARABIC LETTER PEH"
\u067F "ARABIC LETTER TEHEH"
\u0680 "ARABIC LETTER BEHEH"
\u0681 "ARABIC LETTER HAH WITH HAMZA ABOVE"
\u0682 "ARABIC LETTER HAH WITH TWO DOTS VERTICAL ABOVE"
\u0683 "ARABIC LETTER NYEH"
\u0684 "ARABIC LETTER DYEH"
\u0685 "ARABIC LETTER HAH WITH THREE DOTS ABOVE"
\u0686 "ARABIC LETTER TCHEH"
\u0687 "ARABIC LETTER TCHEHEH"
\u0688 "ARABIC LETTER DDAL"
\u0689 "ARABIC LETTER DAL WITH RING"
\u068A "ARABIC LETTER DAL WITH DOT BELOW"
\u068B "ARABIC LETTER DAL WITH DOT BELOW AND SMALL TAH"
\u068C "ARABIC LETTER DAHAL"
\u068D "ARABIC LETTER DDAHAL"
\u068E "ARABIC LETTER DUL"
\u068F "ARABIC LETTER DAL WITH THREE DOTS ABOVE DOWNWARDS"
\u0690 "ARABIC LETTER DAL WITH FOUR DOTS ABOVE"
\u0691 "ARABIC LETTER RREH"
\u0692 "ARABIC LETTER REH WITH SMALL V"
\u0693 "ARABIC LETTER REH WITH RING"
\u0694 "ARABIC LETTER REH WITH DOT BELOW"
\u0695 "ARABIC LETTER REH WITH SMALL V BELOW"
\u0696 "ARABIC LETTER REH WITH DOT BELOW AND DOT ABOVE"
\u0697 "ARABIC LETTER REH WITH TWO DOTS ABOVE"
\u0698 "ARABIC LETTER JEH"
\u0699 "ARABIC LETTER REH WITH FOUR DOTS ABOVE"
\u069A "ARABIC LETTER SEEN WITH DOT BELOW AND DOT ABOVE"
\u069B "ARABIC LETTER SEEN WITH THREE DOTS BELOW"
\u069C "ARABIC LETTER SEEN WITH THREE DOTS BELOW AND THREE DOTS ABOVE"
\u069D "ARABIC LETTER SAD WITH TWO DOTS BELOW"
\u069E "ARABIC LETTER SAD WITH THREE DOTS ABOVE"
\u069F "ARABIC LETTER TAH WITH THREE DOTS ABOVE"
\u06A0 "ARABIC LETTER AIN WITH THREE DOTS ABOVE"
\u06A1 "ARABIC LETTER DOTLESS FEH"
\u06A2 "ARABIC LETTER FEH WITH DOT MOVED BELOW"
\u06A3 "ARABIC LETTER FEH WITH DOT BELOW"
\u06A4 "ARABIC LETTER VEH"
\u06A5 "ARABIC LETTER FEH WITH THREE DOTS BELOW"
\u06A6 "ARABIC LETTER PEHEH"
\u06A7 "ARABIC LETTER QAF WITH DOT ABOVE"
\u06A8 "ARABIC LETTER QAF WITH THREE DOTS ABOVE"
\u06A9 "ARABIC LETTER KEHEH"
\u06AA "ARABIC LETTER SWASH KAF"
\u06AB "ARABIC LETTER KAF WITH RING"
\u06AC "ARABIC LETTER KAF WITH DOT ABOVE"
\u06AD "ARABIC LETTER NG"
\u06AE "ARABIC LETTER KAF WITH THREE DOTS BELOW"
\u06AF "ARABIC LETTER GAF"
\u06B0 "ARABIC LETTER GAF WITH RING"
\u06B1 "ARABIC LETTER NGOEH"
\u06B2 "ARABIC LETTER GAF WITH TWO DOTS BELOW"
\u06B3 "ARABIC LETTER GUEH"
\u06B4 "ARABIC LETTER GAF WITH THREE DOTS ABOVE"
\u06B5 "ARABIC LETTER LAM WITH SMALL V"
\u06B6 "ARABIC LETTER LAM WITH DOT ABOVE"
\u06B7 "ARABIC LETTER LAM WITH THREE DOTS ABOVE"
\u06B8 "ARABIC LETTER LAM WITH THREE DOTS BELOW"
\u06B9 "ARABIC LETTER NOON WITH DOT BELOW"
\u06BA "ARABIC LETTER NOON GHUNNA"
\u06BB "ARABIC LETTER RNOON"
\u06BC "ARABIC LETTER NOON WITH RING"
\u06BD "ARABIC LETTER NOON WITH THREE DOTS ABOVE"
\u06BE "ARABIC LETTER HEH DOACHASHMEE"
\u06BF "ARABIC LETTER TCHEH WITH DOT ABOVE"
\u06C0 "ARABIC LETTER HEH WITH YEH ABOVE"
\u06C1 "ARABIC LETTER HEH GOAL"
\u06C2 "ARABIC LETTER HEH GOAL WITH HAMZA ABOVE"
\u06C3 "ARABIC LETTER TEH MARBUTA GOAL"
\u06C4 "ARABIC LETTER WAW WITH RING"
\u06C5 "ARABIC LETTER KIRGHIZ OE"
\u06C6 "ARABIC LETTER OE"
\u06C7 "ARABIC LETTER U"
\u06C8 "ARABIC LETTER YU"
\u06C9 "ARABIC LETTER KIRGHIZ YU"
\u06CA "ARABIC LETTER WAW WITH TWO DOTS ABOVE"
\u06CB "ARABIC LETTER VE"
\u06CC "ARABIC LETTER FARSI YEH"
\u06CD "ARABIC LETTER YEH WITH TAIL"
\u06CE "ARABIC LETTER YEH WITH SMALL V"
\u06CF "ARABIC LETTER WAW WITH DOT ABOVE"
\u06D0 "ARABIC LETTER E"
\u06D1 "ARABIC LETTER YEH WITH THREE DOTS BELOW"
\u06D2 "ARABIC LETTER YEH BARREE"
\u06D3 "ARABIC LETTER YEH BARREE WITH HAMZA ABOVE"
\u06D4 "ARABIC FULL STOP"
\u06D5 "ARABIC LETTER AE"
\u06D6 "ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA"
\u06D7 "ARABIC SMALL HIGH LIGATURE QAF WITH LAM WITH ALEF MAKSURA"
\u06D8 "ARABIC SMALL HIGH MEEM INITIAL FORM"
\u06D9 "ARABIC SMALL HIGH LAM ALEF"
\u06DA "ARABIC SMALL HIGH JEEM"
\u06DB "ARABIC SMALL HIGH THREE DOTS"
\u06DC "ARABIC SMALL HIGH SEEN"
\u06DD "ARABIC END OF AYAH"
\u06DE "ARABIC START OF RUB EL HIZB"
\u06DF "ARABIC SMALL HIGH ROUNDED ZERO"
\u06E0 "ARABIC SMALL HIGH UPRIGHT RECTANGULAR ZERO"
\u06E1 "ARABIC SMALL HIGH DOTLESS HEAD OF KHAH"
\u06E2 "ARABIC SMALL HIGH MEEM ISOLATED FORM"
\u06E3 "ARABIC SMALL LOW SEEN"
\u06E4 "ARABIC SMALL HIGH MADDA"
\u06E5 "ARABIC SMALL WAW"
\u06E6 "ARABIC SMALL YEH"
\u06E7 "ARABIC SMALL HIGH YEH"
\u06E8 "ARABIC SMALL HIGH NOON"
\u06E9 "ARABIC PLACE OF SAJDAH"
\u06EA "ARABIC EMPTY CENTRE LOW STOP"
\u06EB "ARABIC EMPTY CENTRE HIGH STOP"
\u06EC "ARABIC ROUNDED HIGH STOP WITH FILLED CENTRE"
\u06ED "ARABIC SMALL LOW MEEM"
\u06EE "ARABIC LETTER DAL WITH INVERTED V"
\u06EF "ARABIC LETTER REH WITH INVERTED V"
\u06F0 "EXTENDED ARABIC-INDIC DIGIT ZERO"
\u06F1 "EXTENDED ARABIC-INDIC DIGIT ONE"
\u06F2 "EXTENDED ARABIC-INDIC DIGIT TWO"
\u06F3 "EXTENDED ARABIC-INDIC DIGIT THREE"
\u06F4 "EXTENDED ARABIC-INDIC DIGIT FOUR"
\u06F5 "EXTENDED ARABIC-INDIC DIGIT FIVE"
\u06F6 "EXTENDED ARABIC-INDIC DIGIT SIX"
\u06F7 "EXTENDED ARABIC-INDIC DIGIT SEVEN"
\u06F8 "EXTENDED ARABIC-INDIC DIGIT EIGHT"
\u06F9 "EXTENDED ARABIC-INDIC DIGIT NINE"
\u06FA "ARABIC LETTER SHEEN WITH DOT BELOW"
\u06FB "ARABIC LETTER DAD WITH DOT BELOW"
\u06FC "ARABIC LETTER GHAIN WITH DOT BELOW"
\u06FD "ARABIC SIGN SINDHI AMPERSAND"
\u06FE "ARABIC SIGN SINDHI POSTPOSITION MEN"
\u06FF "ARABIC LETTER HEH WITH INVERTED V"
\u0700 "SYRIAC END OF PARAGRAPH"
\u0701 "SYRIAC SUPRALINEAR FULL STOP"
\u0702 "SYRIAC SUBLINEAR FULL STOP"
\u0703 "SYRIAC SUPRALINEAR COLON"
\u0704 "SYRIAC SUBLINEAR COLON"
\u0705 "SYRIAC HORIZONTAL COLON"
\u0706 "SYRIAC COLON SKEWED LEFT"
\u0707 "SYRIAC COLON SKEWED RIGHT"
\u0708 "SYRIAC SUPRALINEAR COLON SKEWED LEFT"
\u0709 "SYRIAC SUBLINEAR COLON SKEWED RIGHT"
\u070A "SYRIAC CONTRACTION"
\u070B "SYRIAC HARKLEAN OBELUS"
\u070C "SYRIAC HARKLEAN METOBELUS"
\u070D "SYRIAC HARKLEAN ASTERISCUS"
\u070F "SYRIAC ABBREVIATION MARK"
\u0710 "SYRIAC LETTER ALAPH"
\u0711 "SYRIAC LETTER SUPERSCRIPT ALAPH"
\u0712 "SYRIAC LETTER BETH"
\u0713 "SYRIAC LETTER GAMAL"
\u0714 "SYRIAC LETTER GAMAL GARSHUNI"
\u0715 "SYRIAC LETTER DALATH"
\u0716 "SYRIAC LETTER DOTLESS DALATH RISH"
\u0717 "SYRIAC LETTER HE"
\u0718 "SYRIAC LETTER WAW"
\u0719 "SYRIAC LETTER ZAIN"
\u071A "SYRIAC LETTER HETH"
\u071B "SYRIAC LETTER TETH"
\u071C "SYRIAC LETTER TETH GARSHUNI"
\u071D "SYRIAC LETTER YUDH"
\u071E "SYRIAC LETTER YUDH HE"
\u071F "SYRIAC LETTER KAPH"
\u0720 "SYRIAC LETTER LAMADH"
\u0721 "SYRIAC LETTER MIM"
\u0722 "SYRIAC LETTER NUN"
\u0723 "SYRIAC LETTER SEMKATH"
\u0724 "SYRIAC LETTER FINAL SEMKATH"
\u0725 "SYRIAC LETTER E"
\u0726 "SYRIAC LETTER PE"
\u0727 "SYRIAC LETTER REVERSED PE"
\u0728 "SYRIAC LETTER SADHE"
\u0729 "SYRIAC LETTER QAPH"
\u072A "SYRIAC LETTER RISH"
\u072B "SYRIAC LETTER SHIN"
\u072C "SYRIAC LETTER TAW"
\u072D "SYRIAC LETTER PERSIAN BHETH"
\u072E "SYRIAC LETTER PERSIAN GHAMAL"
\u072F "SYRIAC LETTER PERSIAN DHALATH"
\u0730 "SYRIAC PTHAHA ABOVE"
\u0731 "SYRIAC PTHAHA BELOW"
\u0732 "SYRIAC PTHAHA DOTTED"
\u0733 "SYRIAC ZQAPHA ABOVE"
\u0734 "SYRIAC ZQAPHA BELOW"
\u0735 "SYRIAC ZQAPHA DOTTED"
\u0736 "SYRIAC RBASA ABOVE"
\u0737 "SYRIAC RBASA BELOW"
\u0738 "SYRIAC DOTTED ZLAMA HORIZONTAL"
\u0739 "SYRIAC DOTTED ZLAMA ANGULAR"
\u073A "SYRIAC HBASA ABOVE"
\u073B "SYRIAC HBASA BELOW"
\u073C "SYRIAC HBASA-ESASA DOTTED"
\u073D "SYRIAC ESASA ABOVE"
\u073E "SYRIAC ESASA BELOW"
\u073F "SYRIAC RWAHA"
\u0740 "SYRIAC FEMININE DOT"
\u0741 "SYRIAC QUSHSHAYA"
\u0742 "SYRIAC RUKKAKHA"
\u0743 "SYRIAC TWO VERTICAL DOTS ABOVE"
\u0744 "SYRIAC TWO VERTICAL DOTS BELOW"
\u0745 "SYRIAC THREE DOTS ABOVE"
\u0746 "SYRIAC THREE DOTS BELOW"
\u0747 "SYRIAC OBLIQUE LINE ABOVE"
\u0748 "SYRIAC OBLIQUE LINE BELOW"
\u0749 "SYRIAC MUSIC"
\u074A "SYRIAC BARREKH"
\u074D "SYRIAC LETTER SOGDIAN ZHAIN"
\u074E "SYRIAC LETTER SOGDIAN KHAPH"
\u074F "SYRIAC LETTER SOGDIAN FE"
\u0750 "ARABIC LETTER BEH WITH THREE DOTS HORIZONTALLY BELOW"
\u0751 "ARABIC LETTER BEH WITH DOT BELOW AND THREE DOTS ABOVE"
\u0752 "ARABIC LETTER BEH WITH THREE DOTS POINTING UPWARDS BELOW"
\u0753 "ARABIC LETTER BEH WITH THREE DOTS POINTING UPWARDS BELOW AND TWO DOTS ABOVE"
\u0754 "ARABIC LETTER BEH WITH TWO DOTS BELOW AND DOT ABOVE"
\u0755 "ARABIC LETTER BEH WITH INVERTED SMALL V BELOW"
\u0756 "ARABIC LETTER BEH WITH SMALL V"
\u0757 "ARABIC LETTER HAH WITH TWO DOTS ABOVE"
\u0758 "ARABIC LETTER HAH WITH THREE DOTS POINTING UPWARDS BELOW"
\u0759 "ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW AND SMALL TAH"
\u075A "ARABIC LETTER DAL WITH INVERTED SMALL V BELOW"
\u075B "ARABIC LETTER REH WITH STROKE"
\u075C "ARABIC LETTER SEEN WITH FOUR DOTS ABOVE"
\u075D "ARABIC LETTER AIN WITH TWO DOTS ABOVE"
\u075E "ARABIC LETTER AIN WITH THREE DOTS POINTING DOWNWARDS ABOVE"
\u075F "ARABIC LETTER AIN WITH TWO DOTS VERTICALLY ABOVE"
\u0760 "ARABIC LETTER FEH WITH TWO DOTS BELOW"
\u0761 "ARABIC LETTER FEH WITH THREE DOTS POINTING UPWARDS BELOW"
\u0762 "ARABIC LETTER KEHEH WITH DOT ABOVE"
\u0763 "ARABIC LETTER KEHEH WITH THREE DOTS ABOVE"
\u0764 "ARABIC LETTER KEHEH WITH THREE DOTS POINTING UPWARDS BELOW"
\u0765 "ARABIC LETTER MEEM WITH DOT ABOVE"
\u0766 "ARABIC LETTER MEEM WITH DOT BELOW"
\u0767 "ARABIC LETTER NOON WITH TWO DOTS BELOW"
\u0768 "ARABIC LETTER NOON WITH SMALL TAH"
\u0769 "ARABIC LETTER NOON WITH SMALL V"
\u076A "ARABIC LETTER LAM WITH BAR"
\u076B "ARABIC LETTER REH WITH TWO DOTS VERTICALLY ABOVE"
\u076C "ARABIC LETTER REH WITH HAMZA ABOVE"
\u076D "ARABIC LETTER SEEN WITH TWO DOTS VERTICALLY ABOVE"
\u076E "ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH BELOW"
\u076F "ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH AND TWO DOTS"
\u0770 "ARABIC LETTER SEEN WITH SMALL ARABIC LETTER TAH AND TWO DOTS"
\u0771 "ARABIC LETTER REH WITH SMALL ARABIC LETTER TAH AND TWO DOTS"
\u0772 "ARABIC LETTER HAH WITH SMALL ARABIC LETTER TAH ABOVE"
\u0773 "ARABIC LETTER ALEF WITH EXTENDED ARABIC-INDIC DIGIT TWO ABOVE"
\u0774 "ARABIC LETTER ALEF WITH EXTENDED ARABIC-INDIC DIGIT THREE ABOVE"
\u0775 "ARABIC LETTER FARSI YEH WITH EXTENDED ARABIC-INDIC DIGIT TWO ABOVE"
\u0776 "ARABIC LETTER FARSI YEH WITH EXTENDED ARABIC-INDIC DIGIT THREE ABOVE"
\u0777 "ARABIC LETTER FARSI YEH WITH EXTENDED ARABIC-INDIC DIGIT FOUR BELOW"
\u0778 "ARABIC LETTER WAW WITH EXTENDED ARABIC-INDIC DIGIT TWO ABOVE"
\u0779 "ARABIC LETTER WAW WITH EXTENDED ARABIC-INDIC DIGIT THREE ABOVE"
\u077A "ARABIC LETTER YEH BARREE WITH EXTENDED ARABIC-INDIC DIGIT TWO ABOVE"
\u077B "ARABIC LETTER YEH BARREE WITH EXTENDED ARABIC-INDIC DIGIT THREE ABOVE"
\u077C "ARABIC LETTER HAH WITH EXTENDED ARABIC-INDIC DIGIT FOUR BELOW"
\u077D "ARABIC LETTER SEEN WITH EXTENDED ARABIC-INDIC DIGIT FOUR ABOVE"
\u077E "ARABIC LETTER SEEN WITH INVERTED V"
\u077F "ARABIC LETTER KAF WITH TWO DOTS ABOVE"
\u0780 "THAANA LETTER HAA"
\u0781 "THAANA LETTER SHAVIYANI"
\u0782 "THAANA LETTER NOONU"
\u0783 "THAANA LETTER RAA"
\u0784 "THAANA LETTER BAA"
\u0785 "THAANA LETTER LHAVIYANI"
\u0786 "THAANA LETTER KAAFU"
\u0787 "THAANA LETTER ALIFU"
\u0788 "THAANA LETTER VAAVU"
\u0789 "THAANA LETTER MEEMU"
\u078A "THAANA LETTER FAAFU"
\u078B "THAANA LETTER DHAALU"
\u078C "THAANA LETTER THAA"
\u078D "THAANA LETTER LAAMU"
\u078E "THAANA LETTER GAAFU"
\u078F "THAANA LETTER GNAVIYANI"
\u0790 "THAANA LETTER SEENU"
\u0791 "THAANA LETTER DAVIYANI"
\u0792 "THAANA LETTER ZAVIYANI"
\u0793 "THAANA LETTER TAVIYANI"
\u0794 "THAANA LETTER YAA"
\u0795 "THAANA LETTER PAVIYANI"
\u0796 "THAANA LETTER JAVIYANI"
\u0797 "THAANA LETTER CHAVIYANI"
\u0798 "THAANA LETTER TTAA"
\u0799 "THAANA LETTER HHAA"
\u079A "THAANA LETTER KHAA"
\u079B "THAANA LETTER THAALU"
\u079C "THAANA LETTER ZAA"
\u079D "THAANA LETTER SHEENU"
\u079E "THAANA LETTER SAADHU"
\u079F "THAANA LETTER DAADHU"
\u07A0 "THAANA LETTER TO"
\u07A1 "THAANA LETTER ZO"
\u07A2 "THAANA LETTER AINU"
\u07A3 "THAANA LETTER GHAINU"
\u07A4 "THAANA LETTER QAAFU"
\u07A5 "THAANA LETTER WAAVU"
\u07A6 "THAANA ABAFILI"
\u07A7 "THAANA AABAAFILI"
\u07A8 "THAANA IBIFILI"
\u07A9 "THAANA EEBEEFILI"
\u07AA "THAANA UBUFILI"
\u07AB "THAANA OOBOOFILI"
\u07AC "THAANA EBEFILI"
\u07AD "THAANA EYBEYFILI"
\u07AE "THAANA OBOFILI"
\u07AF "THAANA OABOAFILI"
\u07B0 "THAANA SUKUN"
\u07B1 "THAANA LETTER NAA"
\u07C0 "NKO DIGIT ZERO"
\u07C1 "NKO DIGIT ONE"
\u07C2 "NKO DIGIT TWO"
\u07C3 "NKO DIGIT THREE"
\u07C4 "NKO DIGIT FOUR"
\u07C5 "NKO DIGIT FIVE"
\u07C6 "NKO DIGIT SIX"
\u07C7 "NKO DIGIT SEVEN"
\u07C8 "NKO DIGIT EIGHT"
\u07C9 "NKO DIGIT NINE"
\u07CA "NKO LETTER A"
\u07CB "NKO LETTER EE"
\u07CC "NKO LETTER I"
\u07CD "NKO LETTER E"
\u07CE "NKO LETTER U"
\u07CF "NKO LETTER OO"
\u07D0 "NKO LETTER O"
\u07D1 "NKO LETTER DAGBASINNA"
\u07D2 "NKO LETTER N"
\u07D3 "NKO LETTER BA"
\u07D4 "NKO LETTER PA"
\u07D5 "NKO LETTER TA"
\u07D6 "NKO LETTER JA"
\u07D7 "NKO LETTER CHA"
\u07D8 "NKO LETTER DA"
\u07D9 "NKO LETTER RA"
\u07DA "NKO LETTER RRA"
\u07DB "NKO LETTER SA"
\u07DC "NKO LETTER GBA"
\u07DD "NKO LETTER FA"
\u07DE "NKO LETTER KA"
\u07DF "NKO LETTER LA"
\u07E0 "NKO LETTER NA WOLOSO"
\u07E1 "NKO LETTER MA"
\u07E2 "NKO LETTER NYA"
\u07E3 "NKO LETTER NA"
\u07E4 "NKO LETTER HA"
\u07E5 "NKO LETTER WA"
\u07E6 "NKO LETTER YA"
\u07E7 "NKO LETTER NYA WOLOSO"
\u07E8 "NKO LETTER JONA JA"
\u07E9 "NKO LETTER JONA CHA"
\u07EA "NKO LETTER JONA RA"
\u07EB "NKO COMBINING SHORT HIGH TONE"
\u07EC "NKO COMBINING SHORT LOW TONE"
\u07ED "NKO COMBINING SHORT RISING TONE"
\u07EE "NKO COMBINING LONG DESCENDING TONE"
\u07EF "NKO COMBINING LONG HIGH TONE"
\u07F0 "NKO COMBINING LONG LOW TONE"
\u07F1 "NKO COMBINING LONG RISING TONE"
\u07F2 "NKO COMBINING NASALIZATION MARK"
\u07F3 "NKO COMBINING DOUBLE DOT ABOVE"
\u07F4 "NKO HIGH TONE APOSTROPHE"
\u07F5 "NKO LOW TONE APOSTROPHE"
\u07F6 "NKO SYMBOL OO DENNEN"
\u07F7 "NKO SYMBOL GBAKURUNEN"
\u07F8 "NKO COMMA"
\u07F9 "NKO EXCLAMATION MARK"
\u07FA "NKO LAJANYALAN"
\u0901 "DEVANAGARI SIGN CANDRABINDU"
\u0902 "DEVANAGARI SIGN ANUSVARA"
\u0903 "DEVANAGARI SIGN VISARGA"
\u0904 "DEVANAGARI LETTER SHORT A"
\u0905 "DEVANAGARI LETTER A"
\u0906 "DEVANAGARI LETTER AA"
\u0907 "DEVANAGARI LETTER I"
\u0908 "DEVANAGARI LETTER II"
\u0909 "DEVANAGARI LETTER U"
\u090A "DEVANAGARI LETTER UU"
\u090B "DEVANAGARI LETTER VOCALIC R"
\u090C "DEVANAGARI LETTER VOCALIC L"
\u090D "DEVANAGARI LETTER CANDRA E"
\u090E "DEVANAGARI LETTER SHORT E"
\u090F "DEVANAGARI LETTER E"
\u0910 "DEVANAGARI LETTER AI"
\u0911 "DEVANAGARI LETTER CANDRA O"
\u0912 "DEVANAGARI LETTER SHORT O"
\u0913 "DEVANAGARI LETTER O"
\u0914 "DEVANAGARI LETTER AU"
\u0915 "DEVANAGARI LETTER KA"
\u0916 "DEVANAGARI LETTER KHA"
\u0917 "DEVANAGARI LETTER GA"
\u0918 "DEVANAGARI LETTER GHA"
\u0919 "DEVANAGARI LETTER NGA"
\u091A "DEVANAGARI LETTER CA"
\u091B "DEVANAGARI LETTER CHA"
\u091C "DEVANAGARI LETTER JA"
\u091D "DEVANAGARI LETTER JHA"
\u091E "DEVANAGARI LETTER NYA"
\u091F "DEVANAGARI LETTER TTA"
\u0920 "DEVANAGARI LETTER TTHA"
\u0921 "DEVANAGARI LETTER DDA"
\u0922 "DEVANAGARI LETTER DDHA"
\u0923 "DEVANAGARI LETTER NNA"
\u0924 "DEVANAGARI LETTER TA"
\u0925 "DEVANAGARI LETTER THA"
\u0926 "DEVANAGARI LETTER DA"
\u0927 "DEVANAGARI LETTER DHA"
\u0928 "DEVANAGARI LETTER NA"
\u0929 "DEVANAGARI LETTER NNNA"
\u092A "DEVANAGARI LETTER PA"
\u092B "DEVANAGARI LETTER PHA"
\u092C "DEVANAGARI LETTER BA"
\u092D "DEVANAGARI LETTER BHA"
\u092E "DEVANAGARI LETTER MA"
\u092F "DEVANAGARI LETTER YA"
\u0930 "DEVANAGARI LETTER RA"
\u0931 "DEVANAGARI LETTER RRA"
\u0932 "DEVANAGARI LETTER LA"
\u0933 "DEVANAGARI LETTER LLA"
\u0934 "DEVANAGARI LETTER LLLA"
\u0935 "DEVANAGARI LETTER VA"
\u0936 "DEVANAGARI LETTER SHA"
\u0937 "DEVANAGARI LETTER SSA"
\u0938 "DEVANAGARI LETTER SA"
\u0939 "DEVANAGARI LETTER HA"
\u093C "DEVANAGARI SIGN NUKTA"
\u093D "DEVANAGARI SIGN AVAGRAHA"
\u093E "DEVANAGARI VOWEL SIGN AA"
\u093F "DEVANAGARI VOWEL SIGN I"
\u0940 "DEVANAGARI VOWEL SIGN II"
\u0941 "DEVANAGARI VOWEL SIGN U"
\u0942 "DEVANAGARI VOWEL SIGN UU"
\u0943 "DEVANAGARI VOWEL SIGN VOCALIC R"
\u0944 "DEVANAGARI VOWEL SIGN VOCALIC RR"
\u0945 "DEVANAGARI VOWEL SIGN CANDRA E"
\u0946 "DEVANAGARI VOWEL SIGN SHORT E"
\u0947 "DEVANAGARI VOWEL SIGN E"
\u0948 "DEVANAGARI VOWEL SIGN AI"
\u0949 "DEVANAGARI VOWEL SIGN CANDRA O"
\u094A "DEVANAGARI VOWEL SIGN SHORT O"
\u094B "DEVANAGARI VOWEL SIGN O"
\u094C "DEVANAGARI VOWEL SIGN AU"
\u094D "DEVANAGARI SIGN VIRAMA"
\u0950 "DEVANAGARI OM"
\u0951 "DEVANAGARI STRESS SIGN UDATTA"
\u0952 "DEVANAGARI STRESS SIGN ANUDATTA"
\u0953 "DEVANAGARI GRAVE ACCENT"
\u0954 "DEVANAGARI ACUTE ACCENT"
\u0958 "DEVANAGARI LETTER QA"
\u0959 "DEVANAGARI LETTER KHHA"
\u095A "DEVANAGARI LETTER GHHA"
\u095B "DEVANAGARI LETTER ZA"
\u095C "DEVANAGARI LETTER DDDHA"
\u095D "DEVANAGARI LETTER RHA"
\u095E "DEVANAGARI LETTER FA"
\u095F "DEVANAGARI LETTER YYA"
\u0960 "DEVANAGARI LETTER VOCALIC RR"
\u0961 "DEVANAGARI LETTER VOCALIC LL"
\u0962 "DEVANAGARI VOWEL SIGN VOCALIC L"
\u0963 "DEVANAGARI VOWEL SIGN VOCALIC LL"
\u0964 "DEVANAGARI DANDA"
\u0965 "DEVANAGARI DOUBLE DANDA"
\u0966 "DEVANAGARI DIGIT ZERO"
\u0967 "DEVANAGARI DIGIT ONE"
\u0968 "DEVANAGARI DIGIT TWO"
\u0969 "DEVANAGARI DIGIT THREE"
\u096A "DEVANAGARI DIGIT FOUR"
\u096B "DEVANAGARI DIGIT FIVE"
\u096C "DEVANAGARI DIGIT SIX"
\u096D "DEVANAGARI DIGIT SEVEN"
\u096E "DEVANAGARI DIGIT EIGHT"
\u096F "DEVANAGARI DIGIT NINE"
\u0970 "DEVANAGARI ABBREVIATION SIGN"
\u0971 "DEVANAGARI SIGN HIGH SPACING DOT"
\u0972 "DEVANAGARI LETTER CANDRA A"
\u097B "DEVANAGARI LETTER GGA"
\u097C "DEVANAGARI LETTER JJA"
\u097D "DEVANAGARI LETTER GLOTTAL STOP"
\u097E "DEVANAGARI LETTER DDDA"
\u097F "DEVANAGARI LETTER BBA"
\u0981 "BENGALI SIGN CANDRABINDU"
\u0982 "BENGALI SIGN ANUSVARA"
\u0983 "BENGALI SIGN VISARGA"
\u0985 "BENGALI LETTER A"
\u0986 "BENGALI LETTER AA"
\u0987 "BENGALI LETTER I"
\u0988 "BENGALI LETTER II"
\u0989 "BENGALI LETTER U"
\u098A "BENGALI LETTER UU"
\u098B "BENGALI LETTER VOCALIC R"
\u098C "BENGALI LETTER VOCALIC L"
\u098F "BENGALI LETTER E"
\u0990 "BENGALI LETTER AI"
\u0993 "BENGALI LETTER O"
\u0994 "BENGALI LETTER AU"
\u0995 "BENGALI LETTER KA"
\u0996 "BENGALI LETTER KHA"
\u0997 "BENGALI LETTER GA"
\u0998 "BENGALI LETTER GHA"
\u0999 "BENGALI LETTER NGA"
\u099A "BENGALI LETTER CA"
\u099B "BENGALI LETTER CHA"
\u099C "BENGALI LETTER JA"
\u099D "BENGALI LETTER JHA"
\u099E "BENGALI LETTER NYA"
\u099F "BENGALI LETTER TTA"
\u09A0 "BENGALI LETTER TTHA"
\u09A1 "BENGALI LETTER DDA"
\u09A2 "BENGALI LETTER DDHA"
\u09A3 "BENGALI LETTER NNA"
\u09A4 "BENGALI LETTER TA"
\u09A5 "BENGALI LETTER THA"
\u09A6 "BENGALI LETTER DA"
\u09A7 "BENGALI LETTER DHA"
\u09A8 "BENGALI LETTER NA"
\u09AA "BENGALI LETTER PA"
\u09AB "BENGALI LETTER PHA"
\u09AC "BENGALI LETTER BA"
\u09AD "BENGALI LETTER BHA"
\u09AE "BENGALI LETTER MA"
\u09AF "BENGALI LETTER YA"
\u09B0 "BENGALI LETTER RA"
\u09B2 "BENGALI LETTER LA"
\u09B6 "BENGALI LETTER SHA"
\u09B7 "BENGALI LETTER SSA"
\u09B8 "BENGALI LETTER SA"
\u09B9 "BENGALI LETTER HA"
\u09BC "BENGALI SIGN NUKTA"
\u09BD "BENGALI SIGN AVAGRAHA"
\u09BE "BENGALI VOWEL SIGN AA"
\u09BF "BENGALI VOWEL SIGN I"
\u09C0 "BENGALI VOWEL SIGN II"
\u09C1 "BENGALI VOWEL SIGN U"
\u09C2 "BENGALI VOWEL SIGN UU"
\u09C3 "BENGALI VOWEL SIGN VOCALIC R"
\u09C4 "BENGALI VOWEL SIGN VOCALIC RR"
\u09C7 "BENGALI VOWEL SIGN E"
\u09C8 "BENGALI VOWEL SIGN AI"
\u09CB "BENGALI VOWEL SIGN O"
\u09CC "BENGALI VOWEL SIGN AU"
\u09CD "BENGALI SIGN VIRAMA"
\u09CE "BENGALI LETTER KHANDA TA"
\u09D7 "BENGALI AU LENGTH MARK"
\u09DC "BENGALI LETTER RRA"
\u09DD "BENGALI LETTER RHA"
\u09DF "BENGALI LETTER YYA"
\u09E0 "BENGALI LETTER VOCALIC RR"
\u09E1 "BENGALI LETTER VOCALIC LL"
\u09E2 "BENGALI VOWEL SIGN VOCALIC L"
\u09E3 "BENGALI VOWEL SIGN VOCALIC LL"
\u09E6 "BENGALI DIGIT ZERO"
\u09E7 "BENGALI DIGIT ONE"
\u09E8 "BENGALI DIGIT TWO"
\u09E9 "BENGALI DIGIT THREE"
\u09EA "BENGALI DIGIT FOUR"
\u09EB "BENGALI DIGIT FIVE"
\u09EC "BENGALI DIGIT SIX"
\u09ED "BENGALI DIGIT SEVEN"
\u09EE "BENGALI DIGIT EIGHT"
\u09EF "BENGALI DIGIT NINE"
\u09F0 "BENGALI LETTER RA WITH MIDDLE DIAGONAL"
\u09F1 "BENGALI LETTER RA WITH LOWER DIAGONAL"
\u09F2 "BENGALI RUPEE MARK"
\u09F3 "BENGALI RUPEE SIGN"
\u09F4 "BENGALI CURRENCY NUMERATOR ONE"
\u09F5 "BENGALI CURRENCY NUMERATOR TWO"
\u09F6 "BENGALI CURRENCY NUMERATOR THREE"
\u09F7 "BENGALI CURRENCY NUMERATOR FOUR"
\u09F8 "BENGALI CURRENCY NUMERATOR ONE LESS THAN THE DENOMINATOR"
\u09F9 "BENGALI CURRENCY DENOMINATOR SIXTEEN"
\u09FA "BENGALI ISSHAR"
\u0A01 "GURMUKHI SIGN ADAK BINDI"
\u0A02 "GURMUKHI SIGN BINDI"
\u0A03 "GURMUKHI SIGN VISARGA"
\u0A05 "GURMUKHI LETTER A"
\u0A06 "GURMUKHI LETTER AA"
\u0A07 "GURMUKHI LETTER I"
\u0A08 "GURMUKHI LETTER II"
\u0A09 "GURMUKHI LETTER U"
\u0A0A "GURMUKHI LETTER UU"
\u0A0F "GURMUKHI LETTER EE"
\u0A10 "GURMUKHI LETTER AI"
\u0A13 "GURMUKHI LETTER OO"
\u0A14 "GURMUKHI LETTER AU"
\u0A15 "GURMUKHI LETTER KA"
\u0A16 "GURMUKHI LETTER KHA"
\u0A17 "GURMUKHI LETTER GA"
\u0A18 "GURMUKHI LETTER GHA"
\u0A19 "GURMUKHI LETTER NGA"
\u0A1A "GURMUKHI LETTER CA"
\u0A1B "GURMUKHI LETTER CHA"
\u0A1C "GURMUKHI LETTER JA"
\u0A1D "GURMUKHI LETTER JHA"
\u0A1E "GURMUKHI LETTER NYA"
\u0A1F "GURMUKHI LETTER TTA"
\u0A20 "GURMUKHI LETTER TTHA"
\u0A21 "GURMUKHI LETTER DDA"
\u0A22 "GURMUKHI LETTER DDHA"
\u0A23 "GURMUKHI LETTER NNA"
\u0A24 "GURMUKHI LETTER TA"
\u0A25 "GURMUKHI LETTER THA"
\u0A26 "GURMUKHI LETTER DA"
\u0A27 "GURMUKHI LETTER DHA"
\u0A28 "GURMUKHI LETTER NA"
\u0A2A "GURMUKHI LETTER PA"
\u0A2B "GURMUKHI LETTER PHA"
\u0A2C "GURMUKHI LETTER BA"
\u0A2D "GURMUKHI LETTER BHA"
\u0A2E "GURMUKHI LETTER MA"
\u0A2F "GURMUKHI LETTER YA"
\u0A30 "GURMUKHI LETTER RA"
\u0A32 "GURMUKHI LETTER LA"
\u0A33 "GURMUKHI LETTER LLA"
\u0A35 "GURMUKHI LETTER VA"
\u0A36 "GURMUKHI LETTER SHA"
\u0A38 "GURMUKHI LETTER SA"
\u0A39 "GURMUKHI LETTER HA"
\u0A3C "GURMUKHI SIGN NUKTA"
\u0A3E "GURMUKHI VOWEL SIGN AA"
\u0A3F "GURMUKHI VOWEL SIGN I"
\u0A40 "GURMUKHI VOWEL SIGN II"
\u0A41 "GURMUKHI VOWEL SIGN U"
\u0A42 "GURMUKHI VOWEL SIGN UU"
\u0A47 "GURMUKHI VOWEL SIGN EE"
\u0A48 "GURMUKHI VOWEL SIGN AI"
\u0A4B "GURMUKHI VOWEL SIGN OO"
\u0A4C "GURMUKHI VOWEL SIGN AU"
\u0A4D "GURMUKHI SIGN VIRAMA"
\u0A51 "GURMUKHI SIGN UDAAT"
\u0A59 "GURMUKHI LETTER KHHA"
\u0A5A "GURMUKHI LETTER GHHA"
\u0A5B "GURMUKHI LETTER ZA"
\u0A5C "GURMUKHI LETTER RRA"
\u0A5E "GURMUKHI LETTER FA"
\u0A66 "GURMUKHI DIGIT ZERO"
\u0A67 "GURMUKHI DIGIT ONE"
\u0A68 "GURMUKHI DIGIT TWO"
\u0A69 "GURMUKHI DIGIT THREE"
\u0A6A "GURMUKHI DIGIT FOUR"
\u0A6B "GURMUKHI DIGIT FIVE"
\u0A6C "GURMUKHI DIGIT SIX"
\u0A6D "GURMUKHI DIGIT SEVEN"
\u0A6E "GURMUKHI DIGIT EIGHT"
\u0A6F "GURMUKHI DIGIT NINE"
\u0A70 "GURMUKHI TIPPI"
\u0A71 "GURMUKHI ADDAK"
\u0A72 "GURMUKHI IRI"
\u0A73 "GURMUKHI URA"
\u0A74 "GURMUKHI EK ONKAR"
\u0A75 "GURMUKHI SIGN YAKASH"
\u0A81 "GUJARATI SIGN CANDRABINDU"
\u0A82 "GUJARATI SIGN ANUSVARA"
\u0A83 "GUJARATI SIGN VISARGA"
\u0A85 "GUJARATI LETTER A"
\u0A86 "GUJARATI LETTER AA"
\u0A87 "GUJARATI LETTER I"
\u0A88 "GUJARATI LETTER II"
\u0A89 "GUJARATI LETTER U"
\u0A8A "GUJARATI LETTER UU"
\u0A8B "GUJARATI LETTER VOCALIC R"
\u0A8C "GUJARATI LETTER VOCALIC L"
\u0A8D "GUJARATI VOWEL CANDRA E"
\u0A8F "GUJARATI LETTER E"
\u0A90 "GUJARATI LETTER AI"
\u0A91 "GUJARATI VOWEL CANDRA O"
\u0A93 "GUJARATI LETTER O"
\u0A94 "GUJARATI LETTER AU"
\u0A95 "GUJARATI LETTER KA"
\u0A96 "GUJARATI LETTER KHA"
\u0A97 "GUJARATI LETTER GA"
\u0A98 "GUJARATI LETTER GHA"
\u0A99 "GUJARATI LETTER NGA"
\u0A9A "GUJARATI LETTER CA"
\u0A9B "GUJARATI LETTER CHA"
\u0A9C "GUJARATI LETTER JA"
\u0A9D "GUJARATI LETTER JHA"
\u0A9E "GUJARATI LETTER NYA"
\u0A9F "GUJARATI LETTER TTA"
\u0AA0 "GUJARATI LETTER TTHA"
\u0AA1 "GUJARATI LETTER DDA"
\u0AA2 "GUJARATI LETTER DDHA"
\u0AA3 "GUJARATI LETTER NNA"
\u0AA4 "GUJARATI LETTER TA"
\u0AA5 "GUJARATI LETTER THA"
\u0AA6 "GUJARATI LETTER DA"
\u0AA7 "GUJARATI LETTER DHA"
\u0AA8 "GUJARATI LETTER NA"
\u0AAA "GUJARATI LETTER PA"
\u0AAB "GUJARATI LETTER PHA"
\u0AAC "GUJARATI LETTER BA"
\u0AAD "GUJARATI LETTER BHA"
\u0AAE "GUJARATI LETTER MA"
\u0AAF "GUJARATI LETTER YA"
\u0AB0 "GUJARATI LETTER RA"
\u0AB2 "GUJARATI LETTER LA"
\u0AB3 "GUJARATI LETTER LLA"
\u0AB5 "GUJARATI LETTER VA"
\u0AB6 "GUJARATI LETTER SHA"
\u0AB7 "GUJARATI LETTER SSA"
\u0AB8 "GUJARATI LETTER SA"
\u0AB9 "GUJARATI LETTER HA"
\u0ABC "GUJARATI SIGN NUKTA"
\u0ABD "GUJARATI SIGN AVAGRAHA"
\u0ABE "GUJARATI VOWEL SIGN AA"
\u0ABF "GUJARATI VOWEL SIGN I"
\u0AC0 "GUJARATI VOWEL SIGN II"
\u0AC1 "GUJARATI VOWEL SIGN U"
\u0AC2 "GUJARATI VOWEL SIGN UU"
\u0AC3 "GUJARATI VOWEL SIGN VOCALIC R"
\u0AC4 "GUJARATI VOWEL SIGN VOCALIC RR"
\u0AC5 "GUJARATI VOWEL SIGN CANDRA E"
\u0AC7 "GUJARATI VOWEL SIGN E"
\u0AC8 "GUJARATI VOWEL SIGN AI"
\u0AC9 "GUJARATI VOWEL SIGN CANDRA O"
\u0ACB "GUJARATI VOWEL SIGN O"
\u0ACC "GUJARATI VOWEL SIGN AU"
\u0ACD "GUJARATI SIGN VIRAMA"
\u0AD0 "GUJARATI OM"
\u0AE0 "GUJARATI LETTER VOCALIC RR"
\u0AE1 "GUJARATI LETTER VOCALIC LL"
\u0AE2 "GUJARATI VOWEL SIGN VOCALIC L"
\u0AE3 "GUJARATI VOWEL SIGN VOCALIC LL"
\u0AE6 "GUJARATI DIGIT ZERO"
\u0AE7 "GUJARATI DIGIT ONE"
\u0AE8 "GUJARATI DIGIT TWO"
\u0AE9 "GUJARATI DIGIT THREE"
\u0AEA "GUJARATI DIGIT FOUR"
\u0AEB "GUJARATI DIGIT FIVE"
\u0AEC "GUJARATI DIGIT SIX"
\u0AED "GUJARATI DIGIT SEVEN"
\u0AEE "GUJARATI DIGIT EIGHT"
\u0AEF "GUJARATI DIGIT NINE"
\u0AF1 "GUJARATI RUPEE SIGN"
\u0B01 "ORIYA SIGN CANDRABINDU"
\u0B02 "ORIYA SIGN ANUSVARA"
\u0B03 "ORIYA SIGN VISARGA"
\u0B05 "ORIYA LETTER A"
\u0B06 "ORIYA LETTER AA"
\u0B07 "ORIYA LETTER I"
\u0B08 "ORIYA LETTER II"
\u0B09 "ORIYA LETTER U"
\u0B0A "ORIYA LETTER UU"
\u0B0B "ORIYA LETTER VOCALIC R"
\u0B0C "ORIYA LETTER VOCALIC L"
\u0B0F "ORIYA LETTER E"
\u0B10 "ORIYA LETTER AI"
\u0B13 "ORIYA LETTER O"
\u0B14 "ORIYA LETTER AU"
\u0B15 "ORIYA LETTER KA"
\u0B16 "ORIYA LETTER KHA"
\u0B17 "ORIYA LETTER GA"
\u0B18 "ORIYA LETTER GHA"
\u0B19 "ORIYA LETTER NGA"
\u0B1A "ORIYA LETTER CA"
\u0B1B "ORIYA LETTER CHA"
\u0B1C "ORIYA LETTER JA"
\u0B1D "ORIYA LETTER JHA"
\u0B1E "ORIYA LETTER NYA"
\u0B1F "ORIYA LETTER TTA"
\u0B20 "ORIYA LETTER TTHA"
\u0B21 "ORIYA LETTER DDA"
\u0B22 "ORIYA LETTER DDHA"
\u0B23 "ORIYA LETTER NNA"
\u0B24 "ORIYA LETTER TA"
\u0B25 "ORIYA LETTER THA"
\u0B26 "ORIYA LETTER DA"
\u0B27 "ORIYA LETTER DHA"
\u0B28 "ORIYA LETTER NA"
\u0B2A "ORIYA LETTER PA"
\u0B2B "ORIYA LETTER PHA"
\u0B2C "ORIYA LETTER BA"
\u0B2D "ORIYA LETTER BHA"
\u0B2E "ORIYA LETTER MA"
\u0B2F "ORIYA LETTER YA"
\u0B30 "ORIYA LETTER RA"
\u0B32 "ORIYA LETTER LA"
\u0B33 "ORIYA LETTER LLA"
\u0B35 "ORIYA LETTER VA"
\u0B36 "ORIYA LETTER SHA"
\u0B37 "ORIYA LETTER SSA"
\u0B38 "ORIYA LETTER SA"
\u0B39 "ORIYA LETTER HA"
\u0B3C "ORIYA SIGN NUKTA"
\u0B3D "ORIYA SIGN AVAGRAHA"
\u0B3E "ORIYA VOWEL SIGN AA"
\u0B3F "ORIYA VOWEL SIGN I"
\u0B40 "ORIYA VOWEL SIGN II"
\u0B41 "ORIYA VOWEL SIGN U"
\u0B42 "ORIYA VOWEL SIGN UU"
\u0B43 "ORIYA VOWEL SIGN VOCALIC R"
\u0B44 "ORIYA VOWEL SIGN VOCALIC RR"
\u0B47 "ORIYA VOWEL SIGN E"
\u0B48 "ORIYA VOWEL SIGN AI"
\u0B4B "ORIYA VOWEL SIGN O"
\u0B4C "ORIYA VOWEL SIGN AU"
\u0B4D "ORIYA SIGN VIRAMA"
\u0B56 "ORIYA AI LENGTH MARK"
\u0B57 "ORIYA AU LENGTH MARK"
\u0B5C "ORIYA LETTER RRA"
\u0B5D "ORIYA LETTER RHA"
\u0B5F "ORIYA LETTER YYA"
\u0B60 "ORIYA LETTER VOCALIC RR"
\u0B61 "ORIYA LETTER VOCALIC LL"
\u0B62 "ORIYA VOWEL SIGN VOCALIC L"
\u0B63 "ORIYA VOWEL SIGN VOCALIC LL"
\u0B66 "ORIYA DIGIT ZERO"
\u0B67 "ORIYA DIGIT ONE"
\u0B68 "ORIYA DIGIT TWO"
\u0B69 "ORIYA DIGIT THREE"
\u0B6A "ORIYA DIGIT FOUR"
\u0B6B "ORIYA DIGIT FIVE"
\u0B6C "ORIYA DIGIT SIX"
\u0B6D "ORIYA DIGIT SEVEN"
\u0B6E "ORIYA DIGIT EIGHT"
\u0B6F "ORIYA DIGIT NINE"
\u0B70 "ORIYA ISSHAR"
\u0B71 "ORIYA LETTER WA"
\u0B82 "TAMIL SIGN ANUSVARA"
\u0B83 "TAMIL SIGN VISARGA"
\u0B85 "TAMIL LETTER A"
\u0B86 "TAMIL LETTER AA"
\u0B87 "TAMIL LETTER I"
\u0B88 "TAMIL LETTER II"
\u0B89 "TAMIL LETTER U"
\u0B8A "TAMIL LETTER UU"
\u0B8E "TAMIL LETTER E"
\u0B8F "TAMIL LETTER EE"
\u0B90 "TAMIL LETTER AI"
\u0B92 "TAMIL LETTER O"
\u0B93 "TAMIL LETTER OO"
\u0B94 "TAMIL LETTER AU"
\u0B95 "TAMIL LETTER KA"
\u0B99 "TAMIL LETTER NGA"
\u0B9A "TAMIL LETTER CA"
\u0B9C "TAMIL LETTER JA"
\u0B9E "TAMIL LETTER NYA"
\u0B9F "TAMIL LETTER TTA"
\u0BA3 "TAMIL LETTER NNA"
\u0BA4 "TAMIL LETTER TA"
\u0BA8 "TAMIL LETTER NA"
\u0BA9 "TAMIL LETTER NNNA"
\u0BAA "TAMIL LETTER PA"
\u0BAE "TAMIL LETTER MA"
\u0BAF "TAMIL LETTER YA"
\u0BB0 "TAMIL LETTER RA"
\u0BB1 "TAMIL LETTER RRA"
\u0BB2 "TAMIL LETTER LA"
\u0BB3 "TAMIL LETTER LLA"
\u0BB4 "TAMIL LETTER LLLA"
\u0BB5 "TAMIL LETTER VA"
\u0BB6 "TAMIL LETTER SHA"
\u0BB7 "TAMIL LETTER SSA"
\u0BB8 "TAMIL LETTER SA"
\u0BB9 "TAMIL LETTER HA"
\u0BBE "TAMIL VOWEL SIGN AA"
\u0BBF "TAMIL VOWEL SIGN I"
\u0BC0 "TAMIL VOWEL SIGN II"
\u0BC1 "TAMIL VOWEL SIGN U"
\u0BC2 "TAMIL VOWEL SIGN UU"
\u0BC6 "TAMIL VOWEL SIGN E"
\u0BC7 "TAMIL VOWEL SIGN EE"
\u0BC8 "TAMIL VOWEL SIGN AI"
\u0BCA "TAMIL VOWEL SIGN O"
\u0BCB "TAMIL VOWEL SIGN OO"
\u0BCC "TAMIL VOWEL SIGN AU"
\u0BCD "TAMIL SIGN VIRAMA"
\u0BD0 "TAMIL OM"
\u0BD7 "TAMIL AU LENGTH MARK"
\u0BE6 "TAMIL DIGIT ZERO"
\u0BE7 "TAMIL DIGIT ONE"
\u0BE8 "TAMIL DIGIT TWO"
\u0BE9 "TAMIL DIGIT THREE"
\u0BEA "TAMIL DIGIT FOUR"
\u0BEB "TAMIL DIGIT FIVE"
\u0BEC "TAMIL DIGIT SIX"
\u0BED "TAMIL DIGIT SEVEN"
\u0BEE "TAMIL DIGIT EIGHT"
\u0BEF "TAMIL DIGIT NINE"
\u0BF0 "TAMIL NUMBER TEN"
\u0BF1 "TAMIL NUMBER ONE HUNDRED"
\u0BF2 "TAMIL NUMBER ONE THOUSAND"
\u0BF3 "TAMIL DAY SIGN"
\u0BF4 "TAMIL MONTH SIGN"
\u0BF5 "TAMIL YEAR SIGN"
\u0BF6 "TAMIL DEBIT SIGN"
\u0BF7 "TAMIL CREDIT SIGN"
\u0BF8 "TAMIL AS ABOVE SIGN"
\u0BF9 "TAMIL RUPEE SIGN"
\u0BFA "TAMIL NUMBER SIGN"
\u0C01 "TELUGU SIGN CANDRABINDU"
\u0C02 "TELUGU SIGN ANUSVARA"
\u0C03 "TELUGU SIGN VISARGA"
\u0C05 "TELUGU LETTER A"
\u0C06 "TELUGU LETTER AA"
\u0C07 "TELUGU LETTER I"
\u0C08 "TELUGU LETTER II"
\u0C09 "TELUGU LETTER U"
\u0C0A "TELUGU LETTER UU"
\u0C0B "TELUGU LETTER VOCALIC R"
\u0C0C "TELUGU LETTER VOCALIC L"
\u0C0E "TELUGU LETTER E"
\u0C0F "TELUGU LETTER EE"
\u0C10 "TELUGU LETTER AI"
\u0C12 "TELUGU LETTER O"
\u0C13 "TELUGU LETTER OO"
\u0C14 "TELUGU LETTER AU"
\u0C15 "TELUGU LETTER KA"
\u0C16 "TELUGU LETTER KHA"
\u0C17 "TELUGU LETTER GA"
\u0C18 "TELUGU LETTER GHA"
\u0C19 "TELUGU LETTER NGA"
\u0C1A "TELUGU LETTER CA"
\u0C1B "TELUGU LETTER CHA"
\u0C1C "TELUGU LETTER JA"
\u0C1D "TELUGU LETTER JHA"
\u0C1E "TELUGU LETTER NYA"
\u0C1F "TELUGU LETTER TTA"
\u0C20 "TELUGU LETTER TTHA"
\u0C21 "TELUGU LETTER DDA"
\u0C22 "TELUGU LETTER DDHA"
\u0C23 "TELUGU LETTER NNA"
\u0C24 "TELUGU LETTER TA"
\u0C25 "TELUGU LETTER THA"
\u0C26 "TELUGU LETTER DA"
\u0C27 "TELUGU LETTER DHA"
\u0C28 "TELUGU LETTER NA"
\u0C2A "TELUGU LETTER PA"
\u0C2B "TELUGU LETTER PHA"
\u0C2C "TELUGU LETTER BA"
\u0C2D "TELUGU LETTER BHA"
\u0C2E "TELUGU LETTER MA"
\u0C2F "TELUGU LETTER YA"
\u0C30 "TELUGU LETTER RA"
\u0C31 "TELUGU LETTER RRA"
\u0C32 "TELUGU LETTER LA"
\u0C33 "TELUGU LETTER LLA"
\u0C35 "TELUGU LETTER VA"
\u0C36 "TELUGU LETTER SHA"
\u0C37 "TELUGU LETTER SSA"
\u0C38 "TELUGU LETTER SA"
\u0C39 "TELUGU LETTER HA"
\u0C3D "TELUGU SIGN AVAGRAHA"
\u0C3E "TELUGU VOWEL SIGN AA"
\u0C3F "TELUGU VOWEL SIGN I"
\u0C40 "TELUGU VOWEL SIGN II"
\u0C41 "TELUGU VOWEL SIGN U"
\u0C42 "TELUGU VOWEL SIGN UU"
\u0C43 "TELUGU VOWEL SIGN VOCALIC R"
\u0C44 "TELUGU VOWEL SIGN VOCALIC RR"
\u0C46 "TELUGU VOWEL SIGN E"
\u0C47 "TELUGU VOWEL SIGN EE"
\u0C48 "TELUGU VOWEL SIGN AI"
\u0C4A "TELUGU VOWEL SIGN O"
\u0C4B "TELUGU VOWEL SIGN OO"
\u0C4C "TELUGU VOWEL SIGN AU"
\u0C4D "TELUGU SIGN VIRAMA"
\u0C55 "TELUGU LENGTH MARK"
\u0C56 "TELUGU AI LENGTH MARK"
\u0C58 "TELUGU LETTER TSA"
\u0C59 "TELUGU LETTER DZA"
\u0C60 "TELUGU LETTER VOCALIC RR"
\u0C61 "TELUGU LETTER VOCALIC LL"
\u0C62 "TELUGU VOWEL SIGN VOCALIC L"
\u0C63 "TELUGU VOWEL SIGN VOCALIC LL"
\u0C66 "TELUGU DIGIT ZERO"
\u0C67 "TELUGU DIGIT ONE"
\u0C68 "TELUGU DIGIT TWO"
\u0C69 "TELUGU DIGIT THREE"
\u0C6A "TELUGU DIGIT FOUR"
\u0C6B "TELUGU DIGIT FIVE"
\u0C6C "TELUGU DIGIT SIX"
\u0C6D "TELUGU DIGIT SEVEN"
\u0C6E "TELUGU DIGIT EIGHT"
\u0C6F "TELUGU DIGIT NINE"
\u0C78 "TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR"
\u0C79 "TELUGU FRACTION DIGIT ONE FOR ODD POWERS OF FOUR"
\u0C7A "TELUGU FRACTION DIGIT TWO FOR ODD POWERS OF FOUR"
\u0C7B "TELUGU FRACTION DIGIT THREE FOR ODD POWERS OF FOUR"
\u0C7C "TELUGU FRACTION DIGIT ONE FOR EVEN POWERS OF FOUR"
\u0C7D "TELUGU FRACTION DIGIT TWO FOR EVEN POWERS OF FOUR"
\u0C7E "TELUGU FRACTION DIGIT THREE FOR EVEN POWERS OF FOUR"
\u0C7F "TELUGU SIGN TUUMU"
\u0C82 "KANNADA SIGN ANUSVARA"
\u0C83 "KANNADA SIGN VISARGA"
\u0C85 "KANNADA LETTER A"
\u0C86 "KANNADA LETTER AA"
\u0C87 "KANNADA LETTER I"
\u0C88 "KANNADA LETTER II"
\u0C89 "KANNADA LETTER U"
\u0C8A "KANNADA LETTER UU"
\u0C8B "KANNADA LETTER VOCALIC R"
\u0C8C "KANNADA LETTER VOCALIC L"
\u0C8E "KANNADA LETTER E"
\u0C8F "KANNADA LETTER EE"
\u0C90 "KANNADA LETTER AI"
\u0C92 "KANNADA LETTER O"
\u0C93 "KANNADA LETTER OO"
\u0C94 "KANNADA LETTER AU"
\u0C95 "KANNADA LETTER KA"
\u0C96 "KANNADA LETTER KHA"
\u0C97 "KANNADA LETTER GA"
\u0C98 "KANNADA LETTER GHA"
\u0C99 "KANNADA LETTER NGA"
\u0C9A "KANNADA LETTER CA"
\u0C9B "KANNADA LETTER CHA"
\u0C9C "KANNADA LETTER JA"
\u0C9D "KANNADA LETTER JHA"
\u0C9E "KANNADA LETTER NYA"
\u0C9F "KANNADA LETTER TTA"
\u0CA0 "KANNADA LETTER TTHA"
\u0CA1 "KANNADA LETTER DDA"
\u0CA2 "KANNADA LETTER DDHA"
\u0CA3 "KANNADA LETTER NNA"
\u0CA4 "KANNADA LETTER TA"
\u0CA5 "KANNADA LETTER THA"
\u0CA6 "KANNADA LETTER DA"
\u0CA7 "KANNADA LETTER DHA"
\u0CA8 "KANNADA LETTER NA"
\u0CAA "KANNADA LETTER PA"
\u0CAB "KANNADA LETTER PHA"
\u0CAC "KANNADA LETTER BA"
\u0CAD "KANNADA LETTER BHA"
\u0CAE "KANNADA LETTER MA"
\u0CAF "KANNADA LETTER YA"
\u0CB0 "KANNADA LETTER RA"
\u0CB1 "KANNADA LETTER RRA"
\u0CB2 "KANNADA LETTER LA"
\u0CB3 "KANNADA LETTER LLA"
\u0CB5 "KANNADA LETTER VA"
\u0CB6 "KANNADA LETTER SHA"
\u0CB7 "KANNADA LETTER SSA"
\u0CB8 "KANNADA LETTER SA"
\u0CB9 "KANNADA LETTER HA"
\u0CBC "KANNADA SIGN NUKTA"
\u0CBD "KANNADA SIGN AVAGRAHA"
\u0CBE "KANNADA VOWEL SIGN AA"
\u0CBF "KANNADA VOWEL SIGN I"
\u0CC0 "KANNADA VOWEL SIGN II"
\u0CC1 "KANNADA VOWEL SIGN U"
\u0CC2 "KANNADA VOWEL SIGN UU"
\u0CC3 "KANNADA VOWEL SIGN VOCALIC R"
\u0CC4 "KANNADA VOWEL SIGN VOCALIC RR"
\u0CC6 "KANNADA VOWEL SIGN E"
\u0CC7 "KANNADA VOWEL SIGN EE"
\u0CC8 "KANNADA VOWEL SIGN AI"
\u0CCA "KANNADA VOWEL SIGN O"
\u0CCB "KANNADA VOWEL SIGN OO"
\u0CCC "KANNADA VOWEL SIGN AU"
\u0CCD "KANNADA SIGN VIRAMA"
\u0CD5 "KANNADA LENGTH MARK"
\u0CD6 "KANNADA AI LENGTH MARK"
\u0CDE "KANNADA LETTER FA"
\u0CE0 "KANNADA LETTER VOCALIC RR"
\u0CE1 "KANNADA LETTER VOCALIC LL"
\u0CE2 "KANNADA VOWEL SIGN VOCALIC L"
\u0CE3 "KANNADA VOWEL SIGN VOCALIC LL"
\u0CE6 "KANNADA DIGIT ZERO"
\u0CE7 "KANNADA DIGIT ONE"
\u0CE8 "KANNADA DIGIT TWO"
\u0CE9 "KANNADA DIGIT THREE"
\u0CEA "KANNADA DIGIT FOUR"
\u0CEB "KANNADA DIGIT FIVE"
\u0CEC "KANNADA DIGIT SIX"
\u0CED "KANNADA DIGIT SEVEN"
\u0CEE "KANNADA DIGIT EIGHT"
\u0CEF "KANNADA DIGIT NINE"
\u0CF1 "KANNADA SIGN JIHVAMULIYA"
\u0CF2 "KANNADA SIGN UPADHMANIYA"
\u0D02 "MALAYALAM SIGN ANUSVARA"
\u0D03 "MALAYALAM SIGN VISARGA"
\u0D05 "MALAYALAM LETTER A"
\u0D06 "MALAYALAM LETTER AA"
\u0D07 "MALAYALAM LETTER I"
\u0D08 "MALAYALAM LETTER II"
\u0D09 "MALAYALAM LETTER U"
\u0D0A "MALAYALAM LETTER UU"
\u0D0B "MALAYALAM LETTER VOCALIC R"
\u0D0C "MALAYALAM LETTER VOCALIC L"
\u0D0E "MALAYALAM LETTER E"
\u0D0F "MALAYALAM LETTER EE"
\u0D10 "MALAYALAM LETTER AI"
\u0D12 "MALAYALAM LETTER O"
\u0D13 "MALAYALAM LETTER OO"
\u0D14 "MALAYALAM LETTER AU"
\u0D15 "MALAYALAM LETTER KA"
\u0D16 "MALAYALAM LETTER KHA"
\u0D17 "MALAYALAM LETTER GA"
\u0D18 "MALAYALAM LETTER GHA"
\u0D19 "MALAYALAM LETTER NGA"
\u0D1A "MALAYALAM LETTER CA"
\u0D1B "MALAYALAM LETTER CHA"
\u0D1C "MALAYALAM LETTER JA"
\u0D1D "MALAYALAM LETTER JHA"
\u0D1E "MALAYALAM LETTER NYA"
\u0D1F "MALAYALAM LETTER TTA"
\u0D20 "MALAYALAM LETTER TTHA"
\u0D21 "MALAYALAM LETTER DDA"
\u0D22 "MALAYALAM LETTER DDHA"
\u0D23 "MALAYALAM LETTER NNA"
\u0D24 "MALAYALAM LETTER TA"
\u0D25 "MALAYALAM LETTER THA"
\u0D26 "MALAYALAM LETTER DA"
\u0D27 "MALAYALAM LETTER DHA"
\u0D28 "MALAYALAM LETTER NA"
\u0D2A "MALAYALAM LETTER PA"
\u0D2B "MALAYALAM LETTER PHA"
\u0D2C "MALAYALAM LETTER BA"
\u0D2D "MALAYALAM LETTER BHA"
\u0D2E "MALAYALAM LETTER MA"
\u0D2F "MALAYALAM LETTER YA"
\u0D30 "MALAYALAM LETTER RA"
\u0D31 "MALAYALAM LETTER RRA"
\u0D32 "MALAYALAM LETTER LA"
\u0D33 "MALAYALAM LETTER LLA"
\u0D34 "MALAYALAM LETTER LLLA"
\u0D35 "MALAYALAM LETTER VA"
\u0D36 "MALAYALAM LETTER SHA"
\u0D37 "MALAYALAM LETTER SSA"
\u0D38 "MALAYALAM LETTER SA"
\u0D39 "MALAYALAM LETTER HA"
\u0D3D "MALAYALAM SIGN AVAGRAHA"
\u0D3E "MALAYALAM VOWEL SIGN AA"
\u0D3F "MALAYALAM VOWEL SIGN I"
\u0D40 "MALAYALAM VOWEL SIGN II"
\u0D41 "MALAYALAM VOWEL SIGN U"
\u0D42 "MALAYALAM VOWEL SIGN UU"
\u0D43 "MALAYALAM VOWEL SIGN VOCALIC R"
\u0D44 "MALAYALAM VOWEL SIGN VOCALIC RR"
\u0D46 "MALAYALAM VOWEL SIGN E"
\u0D47 "MALAYALAM VOWEL SIGN EE"
\u0D48 "MALAYALAM VOWEL SIGN AI"
\u0D4A "MALAYALAM VOWEL SIGN O"
\u0D4B "MALAYALAM VOWEL SIGN OO"
\u0D4C "MALAYALAM VOWEL SIGN AU"
\u0D4D "MALAYALAM SIGN VIRAMA"
\u0D57 "MALAYALAM AU LENGTH MARK"
\u0D60 "MALAYALAM LETTER VOCALIC RR"
\u0D61 "MALAYALAM LETTER VOCALIC LL"
\u0D62 "MALAYALAM VOWEL SIGN VOCALIC L"
\u0D63 "MALAYALAM VOWEL SIGN VOCALIC LL"
\u0D66 "MALAYALAM DIGIT ZERO"
\u0D67 "MALAYALAM DIGIT ONE"
\u0D68 "MALAYALAM DIGIT TWO"
\u0D69 "MALAYALAM DIGIT THREE"
\u0D6A "MALAYALAM DIGIT FOUR"
\u0D6B "MALAYALAM DIGIT FIVE"
\u0D6C "MALAYALAM DIGIT SIX"
\u0D6D "MALAYALAM DIGIT SEVEN"
\u0D6E "MALAYALAM DIGIT EIGHT"
\u0D6F "MALAYALAM DIGIT NINE"
\u0D70 "MALAYALAM NUMBER TEN"
\u0D71 "MALAYALAM NUMBER ONE HUNDRED"
\u0D72 "MALAYALAM NUMBER ONE THOUSAND"
\u0D73 "MALAYALAM FRACTION ONE QUARTER"
\u0D74 "MALAYALAM FRACTION ONE HALF"
\u0D75 "MALAYALAM FRACTION THREE QUARTERS"
\u0D79 "MALAYALAM DATE MARK"
\u0D7A "MALAYALAM LETTER CHILLU NN"
\u0D7B "MALAYALAM LETTER CHILLU N"
\u0D7C "MALAYALAM LETTER CHILLU RR"
\u0D7D "MALAYALAM LETTER CHILLU L"
\u0D7E "MALAYALAM LETTER CHILLU LL"
\u0D7F "MALAYALAM LETTER CHILLU K"
\u0D82 "SINHALA SIGN ANUSVARAYA"
\u0D83 "SINHALA SIGN VISARGAYA"
\u0D85 "SINHALA LETTER AYANNA"
\u0D86 "SINHALA LETTER AAYANNA"
\u0D87 "SINHALA LETTER AEYANNA"
\u0D88 "SINHALA LETTER AEEYANNA"
\u0D89 "SINHALA LETTER IYANNA"
\u0D8A "SINHALA LETTER IIYANNA"
\u0D8B "SINHALA LETTER UYANNA"
\u0D8C "SINHALA LETTER UUYANNA"
\u0D8D "SINHALA LETTER IRUYANNA"
\u0D8E "SINHALA LETTER IRUUYANNA"
\u0D8F "SINHALA LETTER ILUYANNA"
\u0D90 "SINHALA LETTER ILUUYANNA"
\u0D91 "SINHALA LETTER EYANNA"
\u0D92 "SINHALA LETTER EEYANNA"
\u0D93 "SINHALA LETTER AIYANNA"
\u0D94 "SINHALA LETTER OYANNA"
\u0D95 "SINHALA LETTER OOYANNA"
\u0D96 "SINHALA LETTER AUYANNA"
\u0D9A "SINHALA LETTER ALPAPRAANA KAYANNA"
\u0D9B "SINHALA LETTER MAHAAPRAANA KAYANNA"
\u0D9C "SINHALA LETTER ALPAPRAANA GAYANNA"
\u0D9D "SINHALA LETTER MAHAAPRAANA GAYANNA"
\u0D9E "SINHALA LETTER KANTAJA NAASIKYAYA"
\u0D9F "SINHALA LETTER SANYAKA GAYANNA"
\u0DA0 "SINHALA LETTER ALPAPRAANA CAYANNA"
\u0DA1 "SINHALA LETTER MAHAAPRAANA CAYANNA"
\u0DA2 "SINHALA LETTER ALPAPRAANA JAYANNA"
\u0DA3 "SINHALA LETTER MAHAAPRAANA JAYANNA"
\u0DA4 "SINHALA LETTER TAALUJA NAASIKYAYA"
\u0DA5 "SINHALA LETTER TAALUJA SANYOOGA NAAKSIKYAYA"
\u0DA6 "SINHALA LETTER SANYAKA JAYANNA"
\u0DA7 "SINHALA LETTER ALPAPRAANA TTAYANNA"
\u0DA8 "SINHALA LETTER MAHAAPRAANA TTAYANNA"
\u0DA9 "SINHALA LETTER ALPAPRAANA DDAYANNA"
\u0DAA "SINHALA LETTER MAHAAPRAANA DDAYANNA"
\u0DAB "SINHALA LETTER MUURDHAJA NAYANNA"
\u0DAC "SINHALA LETTER SANYAKA DDAYANNA"
\u0DAD "SINHALA LETTER ALPAPRAANA TAYANNA"
\u0DAE "SINHALA LETTER MAHAAPRAANA TAYANNA"
\u0DAF "SINHALA LETTER ALPAPRAANA DAYANNA"
\u0DB0 "SINHALA LETTER MAHAAPRAANA DAYANNA"
\u0DB1 "SINHALA LETTER DANTAJA NAYANNA"
\u0DB3 "SINHALA LETTER SANYAKA DAYANNA"
\u0DB4 "SINHALA LETTER ALPAPRAANA PAYANNA"
\u0DB5 "SINHALA LETTER MAHAAPRAANA PAYANNA"
\u0DB6 "SINHALA LETTER ALPAPRAANA BAYANNA"
\u0DB7 "SINHALA LETTER MAHAAPRAANA BAYANNA"
\u0DB8 "SINHALA LETTER MAYANNA"
\u0DB9 "SINHALA LETTER AMBA BAYANNA"
\u0DBA "SINHALA LETTER YAYANNA"
\u0DBB "SINHALA LETTER RAYANNA"
\u0DBD "SINHALA LETTER DANTAJA LAYANNA"
\u0DC0 "SINHALA LETTER VAYANNA"
\u0DC1 "SINHALA LETTER TAALUJA SAYANNA"
\u0DC2 "SINHALA LETTER MUURDHAJA SAYANNA"
\u0DC3 "SINHALA LETTER DANTAJA SAYANNA"
\u0DC4 "SINHALA LETTER HAYANNA"
\u0DC5 "SINHALA LETTER MUURDHAJA LAYANNA"
\u0DC6 "SINHALA LETTER FAYANNA"
\u0DCA "SINHALA SIGN AL-LAKUNA"
\u0DCF "SINHALA VOWEL SIGN AELA-PILLA"
\u0DD0 "SINHALA VOWEL SIGN KETTI AEDA-PILLA"
\u0DD1 "SINHALA VOWEL SIGN DIGA AEDA-PILLA"
\u0DD2 "SINHALA VOWEL SIGN KETTI IS-PILLA"
\u0DD3 "SINHALA VOWEL SIGN DIGA IS-PILLA"
\u0DD4 "SINHALA VOWEL SIGN KETTI PAA-PILLA"
\u0DD6 "SINHALA VOWEL SIGN DIGA PAA-PILLA"
\u0DD8 "SINHALA VOWEL SIGN GAETTA-PILLA"
\u0DD9 "SINHALA VOWEL SIGN KOMBUVA"
\u0DDA "SINHALA VOWEL SIGN DIGA KOMBUVA"
\u0DDB "SINHALA VOWEL SIGN KOMBU DEKA"
\u0DDC "SINHALA VOWEL SIGN KOMBUVA HAA AELA-PILLA"
\u0DDD "SINHALA VOWEL SIGN KOMBUVA HAA DIGA AELA-PILLA"
\u0DDE "SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA"
\u0DDF "SINHALA VOWEL SIGN GAYANUKITTA"
\u0DF2 "SINHALA VOWEL SIGN DIGA GAETTA-PILLA"
\u0DF3 "SINHALA VOWEL SIGN DIGA GAYANUKITTA"
\u0DF4 "SINHALA PUNCTUATION KUNDDALIYA"
\u0E01 "THAI CHARACTER KO KAI"
\u0E02 "THAI CHARACTER KHO KHAI"
\u0E03 "THAI CHARACTER KHO KHUAT"
\u0E04 "THAI CHARACTER KHO KHWAI"
\u0E05 "THAI CHARACTER KHO KHON"
\u0E06 "THAI CHARACTER KHO RAKHANG"
\u0E07 "THAI CHARACTER NGO NGU"
\u0E08 "THAI CHARACTER CHO CHAN"
\u0E09 "THAI CHARACTER CHO CHING"
\u0E0A "THAI CHARACTER CHO CHANG"
\u0E0B "THAI CHARACTER SO SO"
\u0E0C "THAI CHARACTER CHO CHOE"
\u0E0D "THAI CHARACTER YO YING"
\u0E0E "THAI CHARACTER DO CHADA"
\u0E0F "THAI CHARACTER TO PATAK"
\u0E10 "THAI CHARACTER THO THAN"
\u0E11 "THAI CHARACTER THO NANGMONTHO"
\u0E12 "THAI CHARACTER THO PHUTHAO"
\u0E13 "THAI CHARACTER NO NEN"
\u0E14 "THAI CHARACTER DO DEK"
\u0E15 "THAI CHARACTER TO TAO"
\u0E16 "THAI CHARACTER THO THUNG"
\u0E17 "THAI CHARACTER THO THAHAN"
\u0E18 "THAI CHARACTER THO THONG"
\u0E19 "THAI CHARACTER NO NU"
\u0E1A "THAI CHARACTER BO BAIMAI"
\u0E1B "THAI CHARACTER PO PLA"
\u0E1C "THAI CHARACTER PHO PHUNG"
\u0E1D "THAI CHARACTER FO FA"
\u0E1E "THAI CHARACTER PHO PHAN"
\u0E1F "THAI CHARACTER FO FAN"
\u0E20 "THAI CHARACTER PHO SAMPHAO"
\u0E21 "THAI CHARACTER MO MA"
\u0E22 "THAI CHARACTER YO YAK"
\u0E23 "THAI CHARACTER RO RUA"
\u0E24 "THAI CHARACTER RU"
\u0E25 "THAI CHARACTER LO LING"
\u0E26 "THAI CHARACTER LU"
\u0E27 "THAI CHARACTER WO WAEN"
\u0E28 "THAI CHARACTER SO SALA"
\u0E29 "THAI CHARACTER SO RUSI"
\u0E2A "THAI CHARACTER SO SUA"
\u0E2B "THAI CHARACTER HO HIP"
\u0E2C "THAI CHARACTER LO CHULA"
\u0E2D "THAI CHARACTER O ANG"
\u0E2E "THAI CHARACTER HO NOKHUK"
\u0E2F "THAI CHARACTER PAIYANNOI"
\u0E30 "THAI CHARACTER SARA A"
\u0E31 "THAI CHARACTER MAI HAN-AKAT"
\u0E32 "THAI CHARACTER SARA AA"
\u0E33 "THAI CHARACTER SARA AM"
\u0E34 "THAI CHARACTER SARA I"
\u0E35 "THAI CHARACTER SARA II"
\u0E36 "THAI CHARACTER SARA UE"
\u0E37 "THAI CHARACTER SARA UEE"
\u0E38 "THAI CHARACTER SARA U"
\u0E39 "THAI CHARACTER SARA UU"
\u0E3A "THAI CHARACTER PHINTHU"
\u0E3F "THAI CURRENCY SYMBOL BAHT"
\u0E40 "THAI CHARACTER SARA E"
\u0E41 "THAI CHARACTER SARA AE"
\u0E42 "THAI CHARACTER SARA O"
\u0E43 "THAI CHARACTER SARA AI MAIMUAN"
\u0E44 "THAI CHARACTER SARA AI MAIMALAI"
\u0E45 "THAI CHARACTER LAKKHANGYAO"
\u0E46 "THAI CHARACTER MAIYAMOK"
\u0E47 "THAI CHARACTER MAITAIKHU"
\u0E48 "THAI CHARACTER MAI EK"
\u0E49 "THAI CHARACTER MAI THO"
\u0E4A "THAI CHARACTER MAI TRI"
\u0E4B "THAI CHARACTER MAI CHATTAWA"
\u0E4C "THAI CHARACTER THANTHAKHAT"
\u0E4D "THAI CHARACTER NIKHAHIT"
\u0E4E "THAI CHARACTER YAMAKKAN"
\u0E4F "THAI CHARACTER FONGMAN"
\u0E50 "THAI DIGIT ZERO"
\u0E51 "THAI DIGIT ONE"
\u0E52 "THAI DIGIT TWO"
\u0E53 "THAI DIGIT THREE"
\u0E54 "THAI DIGIT FOUR"
\u0E55 "THAI DIGIT FIVE"
\u0E56 "THAI DIGIT SIX"
\u0E57 "THAI DIGIT SEVEN"
\u0E58 "THAI DIGIT EIGHT"
\u0E59 "THAI DIGIT NINE"
\u0E5A "THAI CHARACTER ANGKHANKHU"
\u0E5B "THAI CHARACTER KHOMUT"
\u0E81 "LAO LETTER KO"
\u0E82 "LAO LETTER KHO SUNG"
\u0E84 "LAO LETTER KHO TAM"
\u0E87 "LAO LETTER NGO"
\u0E88 "LAO LETTER CO"
\u0E8A "LAO LETTER SO TAM"
\u0E8D "LAO LETTER NYO"
\u0E94 "LAO LETTER DO"
\u0E95 "LAO LETTER TO"
\u0E96 "LAO LETTER THO SUNG"
\u0E97 "LAO LETTER THO TAM"
\u0E99 "LAO LETTER NO"
\u0E9A "LAO LETTER BO"
\u0E9B "LAO LETTER PO"
\u0E9C "LAO LETTER PHO SUNG"
\u0E9D "LAO LETTER FO TAM"
\u0E9E "LAO LETTER PHO TAM"
\u0E9F "LAO LETTER FO SUNG"
\u0EA1 "LAO LETTER MO"
\u0EA2 "LAO LETTER YO"
\u0EA3 "LAO LETTER LO LING"
\u0EA5 "LAO LETTER LO LOOT"
\u0EA7 "LAO LETTER WO"
\u0EAA "LAO LETTER SO SUNG"
\u0EAB "LAO LETTER HO SUNG"
\u0EAD "LAO LETTER O"
\u0EAE "LAO LETTER HO TAM"
\u0EAF "LAO ELLIPSIS"
\u0EB0 "LAO VOWEL SIGN A"
\u0EB1 "LAO VOWEL SIGN MAI KAN"
\u0EB2 "LAO VOWEL SIGN AA"
\u0EB3 "LAO VOWEL SIGN AM"
\u0EB4 "LAO VOWEL SIGN I"
\u0EB5 "LAO VOWEL SIGN II"
\u0EB6 "LAO VOWEL SIGN Y"
\u0EB7 "LAO VOWEL SIGN YY"
\u0EB8 "LAO VOWEL SIGN U"
\u0EB9 "LAO VOWEL SIGN UU"
\u0EBB "LAO VOWEL SIGN MAI KON"
\u0EBC "LAO SEMIVOWEL SIGN LO"
\u0EBD "LAO SEMIVOWEL SIGN NYO"
\u0EC0 "LAO VOWEL SIGN E"
\u0EC1 "LAO VOWEL SIGN EI"
\u0EC2 "LAO VOWEL SIGN O"
\u0EC3 "LAO VOWEL SIGN AY"
\u0EC4 "LAO VOWEL SIGN AI"
\u0EC6 "LAO KO LA"
\u0EC8 "LAO TONE MAI EK"
\u0EC9 "LAO TONE MAI THO"
\u0ECA "LAO TONE MAI TI"
\u0ECB "LAO TONE MAI CATAWA"
\u0ECC "LAO CANCELLATION MARK"
\u0ECD "LAO NIGGAHITA"
\u0ED0 "LAO DIGIT ZERO"
\u0ED1 "LAO DIGIT ONE"
\u0ED2 "LAO DIGIT TWO"
\u0ED3 "LAO DIGIT THREE"
\u0ED4 "LAO DIGIT FOUR"
\u0ED5 "LAO DIGIT FIVE"
\u0ED6 "LAO DIGIT SIX"
\u0ED7 "LAO DIGIT SEVEN"
\u0ED8 "LAO DIGIT EIGHT"
\u0ED9 "LAO DIGIT NINE"
\u0EDC "LAO HO NO"
\u0EDD "LAO HO MO"
\u0F00 "TIBETAN SYLLABLE OM"
\u0F01 "TIBETAN MARK GTER YIG MGO TRUNCATED A"
\u0F02 "TIBETAN MARK GTER YIG MGO -UM RNAM BCAD MA"
\u0F03 "TIBETAN MARK GTER YIG MGO -UM GTER TSHEG MA"
\u0F04 "TIBETAN MARK INITIAL YIG MGO MDUN MA"
\u0F05 "TIBETAN MARK CLOSING YIG MGO SGAB MA"
\u0F06 "TIBETAN MARK CARET YIG MGO PHUR SHAD MA"
\u0F07 "TIBETAN MARK YIG MGO TSHEG SHAD MA"
\u0F08 "TIBETAN MARK SBRUL SHAD"
\u0F09 "TIBETAN MARK BSKUR YIG MGO"
\u0F0A "TIBETAN MARK BKA- SHOG YIG MGO"
\u0F0B "TIBETAN MARK INTERSYLLABIC TSHEG"
\u0F0C "TIBETAN MARK DELIMITER TSHEG BSTAR"
\u0F0D "TIBETAN MARK SHAD"
\u0F0E "TIBETAN MARK NYIS SHAD"
\u0F0F "TIBETAN MARK TSHEG SHAD"
\u0F10 "TIBETAN MARK NYIS TSHEG SHAD"
\u0F11 "TIBETAN MARK RIN CHEN SPUNGS SHAD"
\u0F12 "TIBETAN MARK RGYA GRAM SHAD"
\u0F13 "TIBETAN MARK CARET -DZUD RTAGS ME LONG CAN"
\u0F14 "TIBETAN MARK GTER TSHEG"
\u0F15 "TIBETAN LOGOTYPE SIGN CHAD RTAGS"
\u0F16 "TIBETAN LOGOTYPE SIGN LHAG RTAGS"
\u0F17 "TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS"
\u0F18 "TIBETAN ASTROLOGICAL SIGN -KHYUD PA"
\u0F19 "TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS"
\u0F1A "TIBETAN SIGN RDEL DKAR GCIG"
\u0F1B "TIBETAN SIGN RDEL DKAR GNYIS"
\u0F1C "TIBETAN SIGN RDEL DKAR GSUM"
\u0F1D "TIBETAN SIGN RDEL NAG GCIG"
\u0F1E "TIBETAN SIGN RDEL NAG GNYIS"
\u0F1F "TIBETAN SIGN RDEL DKAR RDEL NAG"
\u0F20 "TIBETAN DIGIT ZERO"
\u0F21 "TIBETAN DIGIT ONE"
\u0F22 "TIBETAN DIGIT TWO"
\u0F23 "TIBETAN DIGIT THREE"
\u0F24 "TIBETAN DIGIT FOUR"
\u0F25 "TIBETAN DIGIT FIVE"
\u0F26 "TIBETAN DIGIT SIX"
\u0F27 "TIBETAN DIGIT SEVEN"
\u0F28 "TIBETAN DIGIT EIGHT"
\u0F29 "TIBETAN DIGIT NINE"
\u0F2A "TIBETAN DIGIT HALF ONE"
\u0F2B "TIBETAN DIGIT HALF TWO"
\u0F2C "TIBETAN DIGIT HALF THREE"
\u0F2D "TIBETAN DIGIT HALF FOUR"
\u0F2E "TIBETAN DIGIT HALF FIVE"
\u0F2F "TIBETAN DIGIT HALF SIX"
\u0F30 "TIBETAN DIGIT HALF SEVEN"
\u0F31 "TIBETAN DIGIT HALF EIGHT"
\u0F32 "TIBETAN DIGIT HALF NINE"
\u0F33 "TIBETAN DIGIT HALF ZERO"
\u0F34 "TIBETAN MARK BSDUS RTAGS"
\u0F35 "TIBETAN MARK NGAS BZUNG NYI ZLA"
\u0F36 "TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN"
\u0F37 "TIBETAN MARK NGAS BZUNG SGOR RTAGS"
\u0F38 "TIBETAN MARK CHE MGO"
\u0F39 "TIBETAN MARK TSA -PHRU"
\u0F3A "TIBETAN MARK GUG RTAGS GYON"
\u0F3B "TIBETAN MARK GUG RTAGS GYAS"
\u0F3C "TIBETAN MARK ANG KHANG GYON"
\u0F3D "TIBETAN MARK ANG KHANG GYAS"
\u0F3E "TIBETAN SIGN YAR TSHES"
\u0F3F "TIBETAN SIGN MAR TSHES"
\u0F40 "TIBETAN LETTER KA"
\u0F41 "TIBETAN LETTER KHA"
\u0F42 "TIBETAN LETTER GA"
\u0F43 "TIBETAN LETTER GHA"
\u0F44 "TIBETAN LETTER NGA"
\u0F45 "TIBETAN LETTER CA"
\u0F46 "TIBETAN LETTER CHA"
\u0F47 "TIBETAN LETTER JA"
\u0F49 "TIBETAN LETTER NYA"
\u0F4A "TIBETAN LETTER TTA"
\u0F4B "TIBETAN LETTER TTHA"
\u0F4C "TIBETAN LETTER DDA"
\u0F4D "TIBETAN LETTER DDHA"
\u0F4E "TIBETAN LETTER NNA"
\u0F4F "TIBETAN LETTER TA"
\u0F50 "TIBETAN LETTER THA"
\u0F51 "TIBETAN LETTER DA"
\u0F52 "TIBETAN LETTER DHA"
\u0F53 "TIBETAN LETTER NA"
\u0F54 "TIBETAN LETTER PA"
\u0F55 "TIBETAN LETTER PHA"
\u0F56 "TIBETAN LETTER BA"
\u0F57 "TIBETAN LETTER BHA"
\u0F58 "TIBETAN LETTER MA"
\u0F59 "TIBETAN LETTER TSA"
\u0F5A "TIBETAN LETTER TSHA"
\u0F5B "TIBETAN LETTER DZA"
\u0F5C "TIBETAN LETTER DZHA"
\u0F5D "TIBETAN LETTER WA"
\u0F5E "TIBETAN LETTER ZHA"
\u0F5F "TIBETAN LETTER ZA"
\u0F60 "TIBETAN LETTER -A"
\u0F61 "TIBETAN LETTER YA"
\u0F62 "TIBETAN LETTER RA"
\u0F63 "TIBETAN LETTER LA"
\u0F64 "TIBETAN LETTER SHA"
\u0F65 "TIBETAN LETTER SSA"
\u0F66 "TIBETAN LETTER SA"
\u0F67 "TIBETAN LETTER HA"
\u0F68 "TIBETAN LETTER A"
\u0F69 "TIBETAN LETTER KSSA"
\u0F6A "TIBETAN LETTER FIXED-FORM RA"
\u0F6B "TIBETAN LETTER KKA"
\u0F6C "TIBETAN LETTER RRA"
\u0F71 "TIBETAN VOWEL SIGN AA"
\u0F72 "TIBETAN VOWEL SIGN I"
\u0F73 "TIBETAN VOWEL SIGN II"
\u0F74 "TIBETAN VOWEL SIGN U"
\u0F75 "TIBETAN VOWEL SIGN UU"
\u0F76 "TIBETAN VOWEL SIGN VOCALIC R"
\u0F77 "TIBETAN VOWEL SIGN VOCALIC RR"
\u0F78 "TIBETAN VOWEL SIGN VOCALIC L"
\u0F79 "TIBETAN VOWEL SIGN VOCALIC LL"
\u0F7A "TIBETAN VOWEL SIGN E"
\u0F7B "TIBETAN VOWEL SIGN EE"
\u0F7C "TIBETAN VOWEL SIGN O"
\u0F7D "TIBETAN VOWEL SIGN OO"
\u0F7E "TIBETAN SIGN RJES SU NGA RO"
\u0F7F "TIBETAN SIGN RNAM BCAD"
\u0F80 "TIBETAN VOWEL SIGN REVERSED I"
\u0F81 "TIBETAN VOWEL SIGN REVERSED II"
\u0F82 "TIBETAN SIGN NYI ZLA NAA DA"
\u0F83 "TIBETAN SIGN SNA LDAN"
\u0F84 "TIBETAN MARK HALANTA"
\u0F85 "TIBETAN MARK PALUTA"
\u0F86 "TIBETAN SIGN LCI RTAGS"
\u0F87 "TIBETAN SIGN YANG RTAGS"
\u0F88 "TIBETAN SIGN LCE TSA CAN"
\u0F89 "TIBETAN SIGN MCHU CAN"
\u0F8A "TIBETAN SIGN GRU CAN RGYINGS"
\u0F8B "TIBETAN SIGN GRU MED RGYINGS"
\u0F90 "TIBETAN SUBJOINED LETTER KA"
\u0F91 "TIBETAN SUBJOINED LETTER KHA"
\u0F92 "TIBETAN SUBJOINED LETTER GA"
\u0F93 "TIBETAN SUBJOINED LETTER GHA"
\u0F94 "TIBETAN SUBJOINED LETTER NGA"
\u0F95 "TIBETAN SUBJOINED LETTER CA"
\u0F96 "TIBETAN SUBJOINED LETTER CHA"
\u0F97 "TIBETAN SUBJOINED LETTER JA"
\u0F99 "TIBETAN SUBJOINED LETTER NYA"
\u0F9A "TIBETAN SUBJOINED LETTER TTA"
\u0F9B "TIBETAN SUBJOINED LETTER TTHA"
\u0F9C "TIBETAN SUBJOINED LETTER DDA"
\u0F9D "TIBETAN SUBJOINED LETTER DDHA"
\u0F9E "TIBETAN SUBJOINED LETTER NNA"
\u0F9F "TIBETAN SUBJOINED LETTER TA"
\u0FA0 "TIBETAN SUBJOINED LETTER THA"
\u0FA1 "TIBETAN SUBJOINED LETTER DA"
\u0FA2 "TIBETAN SUBJOINED LETTER DHA"
\u0FA3 "TIBETAN SUBJOINED LETTER NA"
\u0FA4 "TIBETAN SUBJOINED LETTER PA"
\u0FA5 "TIBETAN SUBJOINED LETTER PHA"
\u0FA6 "TIBETAN SUBJOINED LETTER BA"
\u0FA7 "TIBETAN SUBJOINED LETTER BHA"
\u0FA8 "TIBETAN SUBJOINED LETTER MA"
\u0FA9 "TIBETAN SUBJOINED LETTER TSA"
\u0FAA "TIBETAN SUBJOINED LETTER TSHA"
\u0FAB "TIBETAN SUBJOINED LETTER DZA"
\u0FAC "TIBETAN SUBJOINED LETTER DZHA"
\u0FAD "TIBETAN SUBJOINED LETTER WA"
\u0FAE "TIBETAN SUBJOINED LETTER ZHA"
\u0FAF "TIBETAN SUBJOINED LETTER ZA"
\u0FB0 "TIBETAN SUBJOINED LETTER -A"
\u0FB1 "TIBETAN SUBJOINED LETTER YA"
\u0FB2 "TIBETAN SUBJOINED LETTER RA"
\u0FB3 "TIBETAN SUBJOINED LETTER LA"
\u0FB4 "TIBETAN SUBJOINED LETTER SHA"
\u0FB5 "TIBETAN SUBJOINED LETTER SSA"
\u0FB6 "TIBETAN SUBJOINED LETTER SA"
\u0FB7 "TIBETAN SUBJOINED LETTER HA"
\u0FB8 "TIBETAN SUBJOINED LETTER A"
\u0FB9 "TIBETAN SUBJOINED LETTER KSSA"
\u0FBA "TIBETAN SUBJOINED LETTER FIXED-FORM WA"
\u0FBB "TIBETAN SUBJOINED LETTER FIXED-FORM YA"
\u0FBC "TIBETAN SUBJOINED LETTER FIXED-FORM RA"
\u0FBE "TIBETAN KU RU KHA"
\u0FBF "TIBETAN KU RU KHA BZHI MIG CAN"
\u0FC0 "TIBETAN CANTILLATION SIGN HEAVY BEAT"
\u0FC1 "TIBETAN CANTILLATION SIGN LIGHT BEAT"
\u0FC2 "TIBETAN CANTILLATION SIGN CANG TE-U"
\u0FC3 "TIBETAN CANTILLATION SIGN SBUB -CHAL"
\u0FC4 "TIBETAN SYMBOL DRIL BU"
\u0FC5 "TIBETAN SYMBOL RDO RJE"
\u0FC6 "TIBETAN SYMBOL PADMA GDAN"
\u0FC7 "TIBETAN SYMBOL RDO RJE RGYA GRAM"
\u0FC8 "TIBETAN SYMBOL PHUR PA"
\u0FC9 "TIBETAN SYMBOL NOR BU"
\u0FCA "TIBETAN SYMBOL NOR BU NYIS -KHYIL"
\u0FCB "TIBETAN SYMBOL NOR BU GSUM -KHYIL"
\u0FCC "TIBETAN SYMBOL NOR BU BZHI -KHYIL"
\u0FCE "TIBETAN SIGN RDEL NAG RDEL DKAR"
\u0FCF "TIBETAN SIGN RDEL NAG GSUM"
\u0FD0 "TIBETAN MARK BSKA- SHOG GI MGO RGYAN"
\u0FD1 "TIBETAN MARK MNYAM YIG GI MGO RGYAN"
\u0FD2 "TIBETAN MARK NYIS TSHEG"
\u0FD3 "TIBETAN MARK INITIAL BRDA RNYING YIG MGO MDUN MA"
\u0FD4 "TIBETAN MARK CLOSING BRDA RNYING YIG MGO SGAB MA"
\u1000 "MYANMAR LETTER KA"
\u1001 "MYANMAR LETTER KHA"
\u1002 "MYANMAR LETTER GA"
\u1003 "MYANMAR LETTER GHA"
\u1004 "MYANMAR LETTER NGA"
\u1005 "MYANMAR LETTER CA"
\u1006 "MYANMAR LETTER CHA"
\u1007 "MYANMAR LETTER JA"
\u1008 "MYANMAR LETTER JHA"
\u1009 "MYANMAR LETTER NYA"
\u100A "MYANMAR LETTER NNYA"
\u100B "MYANMAR LETTER TTA"
\u100C "MYANMAR LETTER TTHA"
\u100D "MYANMAR LETTER DDA"
\u100E "MYANMAR LETTER DDHA"
\u100F "MYANMAR LETTER NNA"
\u1010 "MYANMAR LETTER TA"
\u1011 "MYANMAR LETTER THA"
\u1012 "MYANMAR LETTER DA"
\u1013 "MYANMAR LETTER DHA"
\u1014 "MYANMAR LETTER NA"
\u1015 "MYANMAR LETTER PA"
\u1016 "MYANMAR LETTER PHA"
\u1017 "MYANMAR LETTER BA"
\u1018 "MYANMAR LETTER BHA"
\u1019 "MYANMAR LETTER MA"
\u101A "MYANMAR LETTER YA"
\u101B "MYANMAR LETTER RA"
\u101C "MYANMAR LETTER LA"
\u101D "MYANMAR LETTER WA"
\u101E "MYANMAR LETTER SA"
\u101F "MYANMAR LETTER HA"
\u1020 "MYANMAR LETTER LLA"
\u1021 "MYANMAR LETTER A"
\u1022 "MYANMAR LETTER SHAN A"
\u1023 "MYANMAR LETTER I"
\u1024 "MYANMAR LETTER II"
\u1025 "MYANMAR LETTER U"
\u1026 "MYANMAR LETTER UU"
\u1027 "MYANMAR LETTER E"
\u1028 "MYANMAR LETTER MON E"
\u1029 "MYANMAR LETTER O"
\u102A "MYANMAR LETTER AU"
\u102B "MYANMAR VOWEL SIGN TALL AA"
\u102C "MYANMAR VOWEL SIGN AA"
\u102D "MYANMAR VOWEL SIGN I"
\u102E "MYANMAR VOWEL SIGN II"
\u102F "MYANMAR VOWEL SIGN U"
\u1030 "MYANMAR VOWEL SIGN UU"
\u1031 "MYANMAR VOWEL SIGN E"
\u1032 "MYANMAR VOWEL SIGN AI"
\u1033 "MYANMAR VOWEL SIGN MON II"
\u1034 "MYANMAR VOWEL SIGN MON O"
\u1035 "MYANMAR VOWEL SIGN E ABOVE"
\u1036 "MYANMAR SIGN ANUSVARA"
\u1037 "MYANMAR SIGN DOT BELOW"
\u1038 "MYANMAR SIGN VISARGA"
\u1039 "MYANMAR SIGN VIRAMA"
\u103A "MYANMAR SIGN ASAT"
\u103B "MYANMAR CONSONANT SIGN MEDIAL YA"
\u103C "MYANMAR CONSONANT SIGN MEDIAL RA"
\u103D "MYANMAR CONSONANT SIGN MEDIAL WA"
\u103E "MYANMAR CONSONANT SIGN MEDIAL HA"
\u103F "MYANMAR LETTER GREAT SA"
\u1040 "MYANMAR DIGIT ZERO"
\u1041 "MYANMAR DIGIT ONE"
\u1042 "MYANMAR DIGIT TWO"
\u1043 "MYANMAR DIGIT THREE"
\u1044 "MYANMAR DIGIT FOUR"
\u1045 "MYANMAR DIGIT FIVE"
\u1046 "MYANMAR DIGIT SIX"
\u1047 "MYANMAR DIGIT SEVEN"
\u1048 "MYANMAR DIGIT EIGHT"
\u1049 "MYANMAR DIGIT NINE"
\u104A "MYANMAR SIGN LITTLE SECTION"
\u104B "MYANMAR SIGN SECTION"
\u104C "MYANMAR SYMBOL LOCATIVE"
\u104D "MYANMAR SYMBOL COMPLETED"
\u104E "MYANMAR SYMBOL AFOREMENTIONED"
\u104F "MYANMAR SYMBOL GENITIVE"
\u1050 "MYANMAR LETTER SHA"
\u1051 "MYANMAR LETTER SSA"
\u1052 "MYANMAR LETTER VOCALIC R"
\u1053 "MYANMAR LETTER VOCALIC RR"
\u1054 "MYANMAR LETTER VOCALIC L"
\u1055 "MYANMAR LETTER VOCALIC LL"
\u1056 "MYANMAR VOWEL SIGN VOCALIC R"
\u1057 "MYANMAR VOWEL SIGN VOCALIC RR"
\u1058 "MYANMAR VOWEL SIGN VOCALIC L"
\u1059 "MYANMAR VOWEL SIGN VOCALIC LL"
\u105A "MYANMAR LETTER MON NGA"
\u105B "MYANMAR LETTER MON JHA"
\u105C "MYANMAR LETTER MON BBA"
\u105D "MYANMAR LETTER MON BBE"
\u105E "MYANMAR CONSONANT SIGN MON MEDIAL NA"
\u105F "MYANMAR CONSONANT SIGN MON MEDIAL MA"
\u1060 "MYANMAR CONSONANT SIGN MON MEDIAL LA"
\u1061 "MYANMAR LETTER SGAW KAREN SHA"
\u1062 "MYANMAR VOWEL SIGN SGAW KAREN EU"
\u1063 "MYANMAR TONE MARK SGAW KAREN HATHI"
\u1064 "MYANMAR TONE MARK SGAW KAREN KE PHO"
\u1065 "MYANMAR LETTER WESTERN PWO KAREN THA"
\u1066 "MYANMAR LETTER WESTERN PWO KAREN PWA"
\u1067 "MYANMAR VOWEL SIGN WESTERN PWO KAREN EU"
\u1068 "MYANMAR VOWEL SIGN WESTERN PWO KAREN UE"
\u1069 "MYANMAR SIGN WESTERN PWO KAREN TONE-1"
\u106A "MYANMAR SIGN WESTERN PWO KAREN TONE-2"
\u106B "MYANMAR SIGN WESTERN PWO KAREN TONE-3"
\u106C "MYANMAR SIGN WESTERN PWO KAREN TONE-4"
\u106D "MYANMAR SIGN WESTERN PWO KAREN TONE-5"
\u106E "MYANMAR LETTER EASTERN PWO KAREN NNA"
\u106F "MYANMAR LETTER EASTERN PWO KAREN YWA"
\u1070 "MYANMAR LETTER EASTERN PWO KAREN GHWA"
\u1071 "MYANMAR VOWEL SIGN GEBA KAREN I"
\u1072 "MYANMAR VOWEL SIGN KAYAH OE"
\u1073 "MYANMAR VOWEL SIGN KAYAH U"
\u1074 "MYANMAR VOWEL SIGN KAYAH EE"
\u1075 "MYANMAR LETTER SHAN KA"
\u1076 "MYANMAR LETTER SHAN KHA"
\u1077 "MYANMAR LETTER SHAN GA"
\u1078 "MYANMAR LETTER SHAN CA"
\u1079 "MYANMAR LETTER SHAN ZA"
\u107A "MYANMAR LETTER SHAN NYA"
\u107B "MYANMAR LETTER SHAN DA"
\u107C "MYANMAR LETTER SHAN NA"
\u107D "MYANMAR LETTER SHAN PHA"
\u107E "MYANMAR LETTER SHAN FA"
\u107F "MYANMAR LETTER SHAN BA"
\u1080 "MYANMAR LETTER SHAN THA"
\u1081 "MYANMAR LETTER SHAN HA"
\u1082 "MYANMAR CONSONANT SIGN SHAN MEDIAL WA"
\u1083 "MYANMAR VOWEL SIGN SHAN AA"
\u1084 "MYANMAR VOWEL SIGN SHAN E"
\u1085 "MYANMAR VOWEL SIGN SHAN E ABOVE"
\u1086 "MYANMAR VOWEL SIGN SHAN FINAL Y"
\u1087 "MYANMAR SIGN SHAN TONE-2"
\u1088 "MYANMAR SIGN SHAN TONE-3"
\u1089 "MYANMAR SIGN SHAN TONE-5"
\u108A "MYANMAR SIGN SHAN TONE-6"
\u108B "MYANMAR SIGN SHAN COUNCIL TONE-2"
\u108C "MYANMAR SIGN SHAN COUNCIL TONE-3"
\u108D "MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE"
\u108E "MYANMAR LETTER RUMAI PALAUNG FA"
\u108F "MYANMAR SIGN RUMAI PALAUNG TONE-5"
\u1090 "MYANMAR SHAN DIGIT ZERO"
\u1091 "MYANMAR SHAN DIGIT ONE"
\u1092 "MYANMAR SHAN DIGIT TWO"
\u1093 "MYANMAR SHAN DIGIT THREE"
\u1094 "MYANMAR SHAN DIGIT FOUR"
\u1095 "MYANMAR SHAN DIGIT FIVE"
\u1096 "MYANMAR SHAN DIGIT SIX"
\u1097 "MYANMAR SHAN DIGIT SEVEN"
\u1098 "MYANMAR SHAN DIGIT EIGHT"
\u1099 "MYANMAR SHAN DIGIT NINE"
\u109E "MYANMAR SYMBOL SHAN ONE"
\u109F "MYANMAR SYMBOL SHAN EXCLAMATION"
\u10A0 "GEORGIAN CAPITAL LETTER AN"
\u10A1 "GEORGIAN CAPITAL LETTER BAN"
\u10A2 "GEORGIAN CAPITAL LETTER GAN"
\u10A3 "GEORGIAN CAPITAL LETTER DON"
\u10A4 "GEORGIAN CAPITAL LETTER EN"
\u10A5 "GEORGIAN CAPITAL LETTER VIN"
\u10A6 "GEORGIAN CAPITAL LETTER ZEN"
\u10A7 "GEORGIAN CAPITAL LETTER TAN"
\u10A8 "GEORGIAN CAPITAL LETTER IN"
\u10A9 "GEORGIAN CAPITAL LETTER KAN"
\u10AA "GEORGIAN CAPITAL LETTER LAS"
\u10AB "GEORGIAN CAPITAL LETTER MAN"
\u10AC "GEORGIAN CAPITAL LETTER NAR"
\u10AD "GEORGIAN CAPITAL LETTER ON"
\u10AE "GEORGIAN CAPITAL LETTER PAR"
\u10AF "GEORGIAN CAPITAL LETTER ZHAR"
\u10B0 "GEORGIAN CAPITAL LETTER RAE"
\u10B1 "GEORGIAN CAPITAL LETTER SAN"
\u10B2 "GEORGIAN CAPITAL LETTER TAR"
\u10B3 "GEORGIAN CAPITAL LETTER UN"
\u10B4 "GEORGIAN CAPITAL LETTER PHAR"
\u10B5 "GEORGIAN CAPITAL LETTER KHAR"
\u10B6 "GEORGIAN CAPITAL LETTER GHAN"
\u10B7 "GEORGIAN CAPITAL LETTER QAR"
\u10B8 "GEORGIAN CAPITAL LETTER SHIN"
\u10B9 "GEORGIAN CAPITAL LETTER CHIN"
\u10BA "GEORGIAN CAPITAL LETTER CAN"
\u10BB "GEORGIAN CAPITAL LETTER JIL"
\u10BC "GEORGIAN CAPITAL LETTER CIL"
\u10BD "GEORGIAN CAPITAL LETTER CHAR"
\u10BE "GEORGIAN CAPITAL LETTER XAN"
\u10BF "GEORGIAN CAPITAL LETTER JHAN"
\u10C0 "GEORGIAN CAPITAL LETTER HAE"
\u10C1 "GEORGIAN CAPITAL LETTER HE"
\u10C2 "GEORGIAN CAPITAL LETTER HIE"
\u10C3 "GEORGIAN CAPITAL LETTER WE"
\u10C4 "GEORGIAN CAPITAL LETTER HAR"
\u10C5 "GEORGIAN CAPITAL LETTER HOE"
\u10D0 "GEORGIAN LETTER AN"
\u10D1 "GEORGIAN LETTER BAN"
\u10D2 "GEORGIAN LETTER GAN"
\u10D3 "GEORGIAN LETTER DON"
\u10D4 "GEORGIAN LETTER EN"
\u10D5 "GEORGIAN LETTER VIN"
\u10D6 "GEORGIAN LETTER ZEN"
\u10D7 "GEORGIAN LETTER TAN"
\u10D8 "GEORGIAN LETTER IN"
\u10D9 "GEORGIAN LETTER KAN"
\u10DA "GEORGIAN LETTER LAS"
\u10DB "GEORGIAN LETTER MAN"
\u10DC "GEORGIAN LETTER NAR"
\u10DD "GEORGIAN LETTER ON"
\u10DE "GEORGIAN LETTER PAR"
\u10DF "GEORGIAN LETTER ZHAR"
\u10E0 "GEORGIAN LETTER RAE"
\u10E1 "GEORGIAN LETTER SAN"
\u10E2 "GEORGIAN LETTER TAR"
\u10E3 "GEORGIAN LETTER UN"
\u10E4 "GEORGIAN LETTER PHAR"
\u10E5 "GEORGIAN LETTER KHAR"
\u10E6 "GEORGIAN LETTER GHAN"
\u10E7 "GEORGIAN LETTER QAR"
\u10E8 "GEORGIAN LETTER SHIN"
\u10E9 "GEORGIAN LETTER CHIN"
\u10EA "GEORGIAN LETTER CAN"
\u10EB "GEORGIAN LETTER JIL"
\u10EC "GEORGIAN LETTER CIL"
\u10ED "GEORGIAN LETTER CHAR"
\u10EE "GEORGIAN LETTER XAN"
\u10EF "GEORGIAN LETTER JHAN"
\u10F0 "GEORGIAN LETTER HAE"
\u10F1 "GEORGIAN LETTER HE"
\u10F2 "GEORGIAN LETTER HIE"
\u10F3 "GEORGIAN LETTER WE"
\u10F4 "GEORGIAN LETTER HAR"
\u10F5 "GEORGIAN LETTER HOE"
\u10F6 "GEORGIAN LETTER FI"
\u10F7 "GEORGIAN LETTER YN"
\u10F8 "GEORGIAN LETTER ELIFI"
\u10F9 "GEORGIAN LETTER TURNED GAN"
\u10FA "GEORGIAN LETTER AIN"
\u10FB "GEORGIAN PARAGRAPH SEPARATOR"
\u10FC "MODIFIER LETTER GEORGIAN NAR"
\u1100 "HANGUL CHOSEONG KIYEOK"
\u1101 "HANGUL CHOSEONG SSANGKIYEOK"
\u1102 "HANGUL CHOSEONG NIEUN"
\u1103 "HANGUL CHOSEONG TIKEUT"
\u1104 "HANGUL CHOSEONG SSANGTIKEUT"
\u1105 "HANGUL CHOSEONG RIEUL"
\u1106 "HANGUL CHOSEONG MIEUM"
\u1107 "HANGUL CHOSEONG PIEUP"
\u1108 "HANGUL CHOSEONG SSANGPIEUP"
\u1109 "HANGUL CHOSEONG SIOS"
\u110A "HANGUL CHOSEONG SSANGSIOS"
\u110B "HANGUL CHOSEONG IEUNG"
\u110C "HANGUL CHOSEONG CIEUC"
\u110D "HANGUL CHOSEONG SSANGCIEUC"
\u110E "HANGUL CHOSEONG CHIEUCH"
\u110F "HANGUL CHOSEONG KHIEUKH"
\u1110 "HANGUL CHOSEONG THIEUTH"
\u1111 "HANGUL CHOSEONG PHIEUPH"
\u1112 "HANGUL CHOSEONG HIEUH"
\u1113 "HANGUL CHOSEONG NIEUN-KIYEOK"
\u1114 "HANGUL CHOSEONG SSANGNIEUN"
\u1115 "HANGUL CHOSEONG NIEUN-TIKEUT"
\u1116 "HANGUL CHOSEONG NIEUN-PIEUP"
\u1117 "HANGUL CHOSEONG TIKEUT-KIYEOK"
\u1118 "HANGUL CHOSEONG RIEUL-NIEUN"
\u1119 "HANGUL CHOSEONG SSANGRIEUL"
\u111A "HANGUL CHOSEONG RIEUL-HIEUH"
\u111B "HANGUL CHOSEONG KAPYEOUNRIEUL"
\u111C "HANGUL CHOSEONG MIEUM-PIEUP"
\u111D "HANGUL CHOSEONG KAPYEOUNMIEUM"
\u111E "HANGUL CHOSEONG PIEUP-KIYEOK"
\u111F "HANGUL CHOSEONG PIEUP-NIEUN"
\u1120 "HANGUL CHOSEONG PIEUP-TIKEUT"
\u1121 "HANGUL CHOSEONG PIEUP-SIOS"
\u1122 "HANGUL CHOSEONG PIEUP-SIOS-KIYEOK"
\u1123 "HANGUL CHOSEONG PIEUP-SIOS-TIKEUT"
\u1124 "HANGUL CHOSEONG PIEUP-SIOS-PIEUP"
\u1125 "HANGUL CHOSEONG PIEUP-SSANGSIOS"
\u1126 "HANGUL CHOSEONG PIEUP-SIOS-CIEUC"
\u1127 "HANGUL CHOSEONG PIEUP-CIEUC"
\u1128 "HANGUL CHOSEONG PIEUP-CHIEUCH"
\u1129 "HANGUL CHOSEONG PIEUP-THIEUTH"
\u112A "HANGUL CHOSEONG PIEUP-PHIEUPH"
\u112B "HANGUL CHOSEONG KAPYEOUNPIEUP"
\u112C "HANGUL CHOSEONG KAPYEOUNSSANGPIEUP"
\u112D "HANGUL CHOSEONG SIOS-KIYEOK"
\u112E "HANGUL CHOSEONG SIOS-NIEUN"
\u112F "HANGUL CHOSEONG SIOS-TIKEUT"
\u1130 "HANGUL CHOSEONG SIOS-RIEUL"
\u1131 "HANGUL CHOSEONG SIOS-MIEUM"
\u1132 "HANGUL CHOSEONG SIOS-PIEUP"
\u1133 "HANGUL CHOSEONG SIOS-PIEUP-KIYEOK"
\u1134 "HANGUL CHOSEONG SIOS-SSANGSIOS"
\u1135 "HANGUL CHOSEONG SIOS-IEUNG"
\u1136 "HANGUL CHOSEONG SIOS-CIEUC"
\u1137 "HANGUL CHOSEONG SIOS-CHIEUCH"
\u1138 "HANGUL CHOSEONG SIOS-KHIEUKH"
\u1139 "HANGUL CHOSEONG SIOS-THIEUTH"
\u113A "HANGUL CHOSEONG SIOS-PHIEUPH"
\u113B "HANGUL CHOSEONG SIOS-HIEUH"
\u113C "HANGUL CHOSEONG CHITUEUMSIOS"
\u113D "HANGUL CHOSEONG CHITUEUMSSANGSIOS"
\u113E "HANGUL CHOSEONG CEONGCHIEUMSIOS"
\u113F "HANGUL CHOSEONG CEONGCHIEUMSSANGSIOS"
\u1140 "HANGUL CHOSEONG PANSIOS"
\u1141 "HANGUL CHOSEONG IEUNG-KIYEOK"
\u1142 "HANGUL CHOSEONG IEUNG-TIKEUT"
\u1143 "HANGUL CHOSEONG IEUNG-MIEUM"
\u1144 "HANGUL CHOSEONG IEUNG-PIEUP"
\u1145 "HANGUL CHOSEONG IEUNG-SIOS"
\u1146 "HANGUL CHOSEONG IEUNG-PANSIOS"
\u1147 "HANGUL CHOSEONG SSANGIEUNG"
\u1148 "HANGUL CHOSEONG IEUNG-CIEUC"
\u1149 "HANGUL CHOSEONG IEUNG-CHIEUCH"
\u114A "HANGUL CHOSEONG IEUNG-THIEUTH"
\u114B "HANGUL CHOSEONG IEUNG-PHIEUPH"
\u114C "HANGUL CHOSEONG YESIEUNG"
\u114D "HANGUL CHOSEONG CIEUC-IEUNG"
\u114E "HANGUL CHOSEONG CHITUEUMCIEUC"
\u114F "HANGUL CHOSEONG CHITUEUMSSANGCIEUC"
\u1150 "HANGUL CHOSEONG CEONGCHIEUMCIEUC"
\u1151 "HANGUL CHOSEONG CEONGCHIEUMSSANGCIEUC"
\u1152 "HANGUL CHOSEONG CHIEUCH-KHIEUKH"
\u1153 "HANGUL CHOSEONG CHIEUCH-HIEUH"
\u1154 "HANGUL CHOSEONG CHITUEUMCHIEUCH"
\u1155 "HANGUL CHOSEONG CEONGCHIEUMCHIEUCH"
\u1156 "HANGUL CHOSEONG PHIEUPH-PIEUP"
\u1157 "HANGUL CHOSEONG KAPYEOUNPHIEUPH"
\u1158 "HANGUL CHOSEONG SSANGHIEUH"
\u1159 "HANGUL CHOSEONG YEORINHIEUH"
\u115F "HANGUL CHOSEONG FILLER"
\u1160 "HANGUL JUNGSEONG FILLER"
\u1161 "HANGUL JUNGSEONG A"
\u1162 "HANGUL JUNGSEONG AE"
\u1163 "HANGUL JUNGSEONG YA"
\u1164 "HANGUL JUNGSEONG YAE"
\u1165 "HANGUL JUNGSEONG EO"
\u1166 "HANGUL JUNGSEONG E"
\u1167 "HANGUL JUNGSEONG YEO"
\u1168 "HANGUL JUNGSEONG YE"
\u1169 "HANGUL JUNGSEONG O"
\u116A "HANGUL JUNGSEONG WA"
\u116B "HANGUL JUNGSEONG WAE"
\u116C "HANGUL JUNGSEONG OE"
\u116D "HANGUL JUNGSEONG YO"
\u116E "HANGUL JUNGSEONG U"
\u116F "HANGUL JUNGSEONG WEO"
\u1170 "HANGUL JUNGSEONG WE"
\u1171 "HANGUL JUNGSEONG WI"
\u1172 "HANGUL JUNGSEONG YU"
\u1173 "HANGUL JUNGSEONG EU"
\u1174 "HANGUL JUNGSEONG YI"
\u1175 "HANGUL JUNGSEONG I"
\u1176 "HANGUL JUNGSEONG A-O"
\u1177 "HANGUL JUNGSEONG A-U"
\u1178 "HANGUL JUNGSEONG YA-O"
\u1179 "HANGUL JUNGSEONG YA-YO"
\u117A "HANGUL JUNGSEONG EO-O"
\u117B "HANGUL JUNGSEONG EO-U"
\u117C "HANGUL JUNGSEONG EO-EU"
\u117D "HANGUL JUNGSEONG YEO-O"
\u117E "HANGUL JUNGSEONG YEO-U"
\u117F "HANGUL JUNGSEONG O-EO"
\u1180 "HANGUL JUNGSEONG O-E"
\u1181 "HANGUL JUNGSEONG O-YE"
\u1182 "HANGUL JUNGSEONG O-O"
\u1183 "HANGUL JUNGSEONG O-U"
\u1184 "HANGUL JUNGSEONG YO-YA"
\u1185 "HANGUL JUNGSEONG YO-YAE"
\u1186 "HANGUL JUNGSEONG YO-YEO"
\u1187 "HANGUL JUNGSEONG YO-O"
\u1188 "HANGUL JUNGSEONG YO-I"
\u1189 "HANGUL JUNGSEONG U-A"
\u118A "HANGUL JUNGSEONG U-AE"
\u118B "HANGUL JUNGSEONG U-EO-EU"
\u118C "HANGUL JUNGSEONG U-YE"
\u118D "HANGUL JUNGSEONG U-U"
\u118E "HANGUL JUNGSEONG YU-A"
\u118F "HANGUL JUNGSEONG YU-EO"
\u1190 "HANGUL JUNGSEONG YU-E"
\u1191 "HANGUL JUNGSEONG YU-YEO"
\u1192 "HANGUL JUNGSEONG YU-YE"
\u1193 "HANGUL JUNGSEONG YU-U"
\u1194 "HANGUL JUNGSEONG YU-I"
\u1195 "HANGUL JUNGSEONG EU-U"
\u1196 "HANGUL JUNGSEONG EU-EU"
\u1197 "HANGUL JUNGSEONG YI-U"
\u1198 "HANGUL JUNGSEONG I-A"
\u1199 "HANGUL JUNGSEONG I-YA"
\u119A "HANGUL JUNGSEONG I-O"
\u119B "HANGUL JUNGSEONG I-U"
\u119C "HANGUL JUNGSEONG I-EU"
\u119D "HANGUL JUNGSEONG I-ARAEA"
\u119E "HANGUL JUNGSEONG ARAEA"
\u119F "HANGUL JUNGSEONG ARAEA-EO"
\u11A0 "HANGUL JUNGSEONG ARAEA-U"
\u11A1 "HANGUL JUNGSEONG ARAEA-I"
\u11A2 "HANGUL JUNGSEONG SSANGARAEA"
\u11A8 "HANGUL JONGSEONG KIYEOK"
\u11A9 "HANGUL JONGSEONG SSANGKIYEOK"
\u11AA "HANGUL JONGSEONG KIYEOK-SIOS"
\u11AB "HANGUL JONGSEONG NIEUN"
\u11AC "HANGUL JONGSEONG NIEUN-CIEUC"
\u11AD "HANGUL JONGSEONG NIEUN-HIEUH"
\u11AE "HANGUL JONGSEONG TIKEUT"
\u11AF "HANGUL JONGSEONG RIEUL"
\u11B0 "HANGUL JONGSEONG RIEUL-KIYEOK"
\u11B1 "HANGUL JONGSEONG RIEUL-MIEUM"
\u11B2 "HANGUL JONGSEONG RIEUL-PIEUP"
\u11B3 "HANGUL JONGSEONG RIEUL-SIOS"
\u11B4 "HANGUL JONGSEONG RIEUL-THIEUTH"
\u11B5 "HANGUL JONGSEONG RIEUL-PHIEUPH"
\u11B6 "HANGUL JONGSEONG RIEUL-HIEUH"
\u11B7 "HANGUL JONGSEONG MIEUM"
\u11B8 "HANGUL JONGSEONG PIEUP"
\u11B9 "HANGUL JONGSEONG PIEUP-SIOS"
\u11BA "HANGUL JONGSEONG SIOS"
\u11BB "HANGUL JONGSEONG SSANGSIOS"
\u11BC "HANGUL JONGSEONG IEUNG"
\u11BD "HANGUL JONGSEONG CIEUC"
\u11BE "HANGUL JONGSEONG CHIEUCH"
\u11BF "HANGUL JONGSEONG KHIEUKH"
\u11C0 "HANGUL JONGSEONG THIEUTH"
\u11C1 "HANGUL JONGSEONG PHIEUPH"
\u11C2 "HANGUL JONGSEONG HIEUH"
\u11C3 "HANGUL JONGSEONG KIYEOK-RIEUL"
\u11C4 "HANGUL JONGSEONG KIYEOK-SIOS-KIYEOK"
\u11C5 "HANGUL JONGSEONG NIEUN-KIYEOK"
\u11C6 "HANGUL JONGSEONG NIEUN-TIKEUT"
\u11C7 "HANGUL JONGSEONG NIEUN-SIOS"
\u11C8 "HANGUL JONGSEONG NIEUN-PANSIOS"
\u11C9 "HANGUL JONGSEONG NIEUN-THIEUTH"
\u11CA "HANGUL JONGSEONG TIKEUT-KIYEOK"
\u11CB "HANGUL JONGSEONG TIKEUT-RIEUL"
\u11CC "HANGUL JONGSEONG RIEUL-KIYEOK-SIOS"
\u11CD "HANGUL JONGSEONG RIEUL-NIEUN"
\u11CE "HANGUL JONGSEONG RIEUL-TIKEUT"
\u11CF "HANGUL JONGSEONG RIEUL-TIKEUT-HIEUH"
\u11D0 "HANGUL JONGSEONG SSANGRIEUL"
\u11D1 "HANGUL JONGSEONG RIEUL-MIEUM-KIYEOK"
\u11D2 "HANGUL JONGSEONG RIEUL-MIEUM-SIOS"
\u11D3 "HANGUL JONGSEONG RIEUL-PIEUP-SIOS"
\u11D4 "HANGUL JONGSEONG RIEUL-PIEUP-HIEUH"
\u11D5 "HANGUL JONGSEONG RIEUL-KAPYEOUNPIEUP"
\u11D6 "HANGUL JONGSEONG RIEUL-SSANGSIOS"
\u11D7 "HANGUL JONGSEONG RIEUL-PANSIOS"
\u11D8 "HANGUL JONGSEONG RIEUL-KHIEUKH"
\u11D9 "HANGUL JONGSEONG RIEUL-YEORINHIEUH"
\u11DA "HANGUL JONGSEONG MIEUM-KIYEOK"
\u11DB "HANGUL JONGSEONG MIEUM-RIEUL"
\u11DC "HANGUL JONGSEONG MIEUM-PIEUP"
\u11DD "HANGUL JONGSEONG MIEUM-SIOS"
\u11DE "HANGUL JONGSEONG MIEUM-SSANGSIOS"
\u11DF "HANGUL JONGSEONG MIEUM-PANSIOS"
\u11E0 "HANGUL JONGSEONG MIEUM-CHIEUCH"
\u11E1 "HANGUL JONGSEONG MIEUM-HIEUH"
\u11E2 "HANGUL JONGSEONG KAPYEOUNMIEUM"
\u11E3 "HANGUL JONGSEONG PIEUP-RIEUL"
\u11E4 "HANGUL JONGSEONG PIEUP-PHIEUPH"
\u11E5 "HANGUL JONGSEONG PIEUP-HIEUH"
\u11E6 "HANGUL JONGSEONG KAPYEOUNPIEUP"
\u11E7 "HANGUL JONGSEONG SIOS-KIYEOK"
\u11E8 "HANGUL JONGSEONG SIOS-TIKEUT"
\u11E9 "HANGUL JONGSEONG SIOS-RIEUL"
\u11EA "HANGUL JONGSEONG SIOS-PIEUP"
\u11EB "HANGUL JONGSEONG PANSIOS"
\u11EC "HANGUL JONGSEONG IEUNG-KIYEOK"
\u11ED "HANGUL JONGSEONG IEUNG-SSANGKIYEOK"
\u11EE "HANGUL JONGSEONG SSANGIEUNG"
\u11EF "HANGUL JONGSEONG IEUNG-KHIEUKH"
\u11F0 "HANGUL JONGSEONG YESIEUNG"
\u11F1 "HANGUL JONGSEONG YESIEUNG-SIOS"
\u11F2 "HANGUL JONGSEONG YESIEUNG-PANSIOS"
\u11F3 "HANGUL JONGSEONG PHIEUPH-PIEUP"
\u11F4 "HANGUL JONGSEONG KAPYEOUNPHIEUPH"
\u11F5 "HANGUL JONGSEONG HIEUH-NIEUN"
\u11F6 "HANGUL JONGSEONG HIEUH-RIEUL"
\u11F7 "HANGUL JONGSEONG HIEUH-MIEUM"
\u11F8 "HANGUL JONGSEONG HIEUH-PIEUP"
\u11F9 "HANGUL JONGSEONG YEORINHIEUH"
\u1200 "ETHIOPIC SYLLABLE HA"
\u1201 "ETHIOPIC SYLLABLE HU"
\u1202 "ETHIOPIC SYLLABLE HI"
\u1203 "ETHIOPIC SYLLABLE HAA"
\u1204 "ETHIOPIC SYLLABLE HEE"
\u1205 "ETHIOPIC SYLLABLE HE"
\u1206 "ETHIOPIC SYLLABLE HO"
\u1207 "ETHIOPIC SYLLABLE HOA"
\u1208 "ETHIOPIC SYLLABLE LA"
\u1209 "ETHIOPIC SYLLABLE LU"
\u120A "ETHIOPIC SYLLABLE LI"
\u120B "ETHIOPIC SYLLABLE LAA"
\u120C "ETHIOPIC SYLLABLE LEE"
\u120D "ETHIOPIC SYLLABLE LE"
\u120E "ETHIOPIC SYLLABLE LO"
\u120F "ETHIOPIC SYLLABLE LWA"
\u1210 "ETHIOPIC SYLLABLE HHA"
\u1211 "ETHIOPIC SYLLABLE HHU"
\u1212 "ETHIOPIC SYLLABLE HHI"
\u1213 "ETHIOPIC SYLLABLE HHAA"
\u1214 "ETHIOPIC SYLLABLE HHEE"
\u1215 "ETHIOPIC SYLLABLE HHE"
\u1216 "ETHIOPIC SYLLABLE HHO"
\u1217 "ETHIOPIC SYLLABLE HHWA"
\u1218 "ETHIOPIC SYLLABLE MA"
\u1219 "ETHIOPIC SYLLABLE MU"
\u121A "ETHIOPIC SYLLABLE MI"
\u121B "ETHIOPIC SYLLABLE MAA"
\u121C "ETHIOPIC SYLLABLE MEE"
\u121D "ETHIOPIC SYLLABLE ME"
\u121E "ETHIOPIC SYLLABLE MO"
\u121F "ETHIOPIC SYLLABLE MWA"
\u1220 "ETHIOPIC SYLLABLE SZA"
\u1221 "ETHIOPIC SYLLABLE SZU"
\u1222 "ETHIOPIC SYLLABLE SZI"
\u1223 "ETHIOPIC SYLLABLE SZAA"
\u1224 "ETHIOPIC SYLLABLE SZEE"
\u1225 "ETHIOPIC SYLLABLE SZE"
\u1226 "ETHIOPIC SYLLABLE SZO"
\u1227 "ETHIOPIC SYLLABLE SZWA"
\u1228 "ETHIOPIC SYLLABLE RA"
\u1229 "ETHIOPIC SYLLABLE RU"
\u122A "ETHIOPIC SYLLABLE RI"
\u122B "ETHIOPIC SYLLABLE RAA"
\u122C "ETHIOPIC SYLLABLE REE"
\u122D "ETHIOPIC SYLLABLE RE"
\u122E "ETHIOPIC SYLLABLE RO"
\u122F "ETHIOPIC SYLLABLE RWA"
\u1230 "ETHIOPIC SYLLABLE SA"
\u1231 "ETHIOPIC SYLLABLE SU"
\u1232 "ETHIOPIC SYLLABLE SI"
\u1233 "ETHIOPIC SYLLABLE SAA"
\u1234 "ETHIOPIC SYLLABLE SEE"
\u1235 "ETHIOPIC SYLLABLE SE"
\u1236 "ETHIOPIC SYLLABLE SO"
\u1237 "ETHIOPIC SYLLABLE SWA"
\u1238 "ETHIOPIC SYLLABLE SHA"
\u1239 "ETHIOPIC SYLLABLE SHU"
\u123A "ETHIOPIC SYLLABLE SHI"
\u123B "ETHIOPIC SYLLABLE SHAA"
\u123C "ETHIOPIC SYLLABLE SHEE"
\u123D "ETHIOPIC SYLLABLE SHE"
\u123E "ETHIOPIC SYLLABLE SHO"
\u123F "ETHIOPIC SYLLABLE SHWA"
\u1240 "ETHIOPIC SYLLABLE QA"
\u1241 "ETHIOPIC SYLLABLE QU"
\u1242 "ETHIOPIC SYLLABLE QI"
\u1243 "ETHIOPIC SYLLABLE QAA"
\u1244 "ETHIOPIC SYLLABLE QEE"
\u1245 "ETHIOPIC SYLLABLE QE"
\u1246 "ETHIOPIC SYLLABLE QO"
\u1247 "ETHIOPIC SYLLABLE QOA"
\u1248 "ETHIOPIC SYLLABLE QWA"
\u124A "ETHIOPIC SYLLABLE QWI"
\u124B "ETHIOPIC SYLLABLE QWAA"
\u124C "ETHIOPIC SYLLABLE QWEE"
\u124D "ETHIOPIC SYLLABLE QWE"
\u1250 "ETHIOPIC SYLLABLE QHA"
\u1251 "ETHIOPIC SYLLABLE QHU"
\u1252 "ETHIOPIC SYLLABLE QHI"
\u1253 "ETHIOPIC SYLLABLE QHAA"
\u1254 "ETHIOPIC SYLLABLE QHEE"
\u1255 "ETHIOPIC SYLLABLE QHE"
\u1256 "ETHIOPIC SYLLABLE QHO"
\u1258 "ETHIOPIC SYLLABLE QHWA"
\u125A "ETHIOPIC SYLLABLE QHWI"
\u125B "ETHIOPIC SYLLABLE QHWAA"
\u125C "ETHIOPIC SYLLABLE QHWEE"
\u125D "ETHIOPIC SYLLABLE QHWE"
\u1260 "ETHIOPIC SYLLABLE BA"
\u1261 "ETHIOPIC SYLLABLE BU"
\u1262 "ETHIOPIC SYLLABLE BI"
\u1263 "ETHIOPIC SYLLABLE BAA"
\u1264 "ETHIOPIC SYLLABLE BEE"
\u1265 "ETHIOPIC SYLLABLE BE"
\u1266 "ETHIOPIC SYLLABLE BO"
\u1267 "ETHIOPIC SYLLABLE BWA"
\u1268 "ETHIOPIC SYLLABLE VA"
\u1269 "ETHIOPIC SYLLABLE VU"
\u126A "ETHIOPIC SYLLABLE VI"
\u126B "ETHIOPIC SYLLABLE VAA"
\u126C "ETHIOPIC SYLLABLE VEE"
\u126D "ETHIOPIC SYLLABLE VE"
\u126E "ETHIOPIC SYLLABLE VO"
\u126F "ETHIOPIC SYLLABLE VWA"
\u1270 "ETHIOPIC SYLLABLE TA"
\u1271 "ETHIOPIC SYLLABLE TU"
\u1272 "ETHIOPIC SYLLABLE TI"
\u1273 "ETHIOPIC SYLLABLE TAA"
\u1274 "ETHIOPIC SYLLABLE TEE"
\u1275 "ETHIOPIC SYLLABLE TE"
\u1276 "ETHIOPIC SYLLABLE TO"
\u1277 "ETHIOPIC SYLLABLE TWA"
\u1278 "ETHIOPIC SYLLABLE CA"
\u1279 "ETHIOPIC SYLLABLE CU"
\u127A "ETHIOPIC SYLLABLE CI"
\u127B "ETHIOPIC SYLLABLE CAA"
\u127C "ETHIOPIC SYLLABLE CEE"
\u127D "ETHIOPIC SYLLABLE CE"
\u127E "ETHIOPIC SYLLABLE CO"
\u127F "ETHIOPIC SYLLABLE CWA"
\u1280 "ETHIOPIC SYLLABLE XA"
\u1281 "ETHIOPIC SYLLABLE XU"
\u1282 "ETHIOPIC SYLLABLE XI"
\u1283 "ETHIOPIC SYLLABLE XAA"
\u1284 "ETHIOPIC SYLLABLE XEE"
\u1285 "ETHIOPIC SYLLABLE XE"
\u1286 "ETHIOPIC SYLLABLE XO"
\u1287 "ETHIOPIC SYLLABLE XOA"
\u1288 "ETHIOPIC SYLLABLE XWA"
\u128A "ETHIOPIC SYLLABLE XWI"
\u128B "ETHIOPIC SYLLABLE XWAA"
\u128C "ETHIOPIC SYLLABLE XWEE"
\u128D "ETHIOPIC SYLLABLE XWE"
\u1290 "ETHIOPIC SYLLABLE NA"
\u1291 "ETHIOPIC SYLLABLE NU"
\u1292 "ETHIOPIC SYLLABLE NI"
\u1293 "ETHIOPIC SYLLABLE NAA"
\u1294 "ETHIOPIC SYLLABLE NEE"
\u1295 "ETHIOPIC SYLLABLE NE"
\u1296 "ETHIOPIC SYLLABLE NO"
\u1297 "ETHIOPIC SYLLABLE NWA"
\u1298 "ETHIOPIC SYLLABLE NYA"
\u1299 "ETHIOPIC SYLLABLE NYU"
\u129A "ETHIOPIC SYLLABLE NYI"
\u129B "ETHIOPIC SYLLABLE NYAA"
\u129C "ETHIOPIC SYLLABLE NYEE"
\u129D "ETHIOPIC SYLLABLE NYE"
\u129E "ETHIOPIC SYLLABLE NYO"
\u129F "ETHIOPIC SYLLABLE NYWA"
\u12A0 "ETHIOPIC SYLLABLE GLOTTAL A"
\u12A1 "ETHIOPIC SYLLABLE GLOTTAL U"
\u12A2 "ETHIOPIC SYLLABLE GLOTTAL I"
\u12A3 "ETHIOPIC SYLLABLE GLOTTAL AA"
\u12A4 "ETHIOPIC SYLLABLE GLOTTAL EE"
\u12A5 "ETHIOPIC SYLLABLE GLOTTAL E"
\u12A6 "ETHIOPIC SYLLABLE GLOTTAL O"
\u12A7 "ETHIOPIC SYLLABLE GLOTTAL WA"
\u12A8 "ETHIOPIC SYLLABLE KA"
\u12A9 "ETHIOPIC SYLLABLE KU"
\u12AA "ETHIOPIC SYLLABLE KI"
\u12AB "ETHIOPIC SYLLABLE KAA"
\u12AC "ETHIOPIC SYLLABLE KEE"
\u12AD "ETHIOPIC SYLLABLE KE"
\u12AE "ETHIOPIC SYLLABLE KO"
\u12AF "ETHIOPIC SYLLABLE KOA"
\u12B0 "ETHIOPIC SYLLABLE KWA"
\u12B2 "ETHIOPIC SYLLABLE KWI"
\u12B3 "ETHIOPIC SYLLABLE KWAA"
\u12B4 "ETHIOPIC SYLLABLE KWEE"
\u12B5 "ETHIOPIC SYLLABLE KWE"
\u12B8 "ETHIOPIC SYLLABLE KXA"
\u12B9 "ETHIOPIC SYLLABLE KXU"
\u12BA "ETHIOPIC SYLLABLE KXI"
\u12BB "ETHIOPIC SYLLABLE KXAA"
\u12BC "ETHIOPIC SYLLABLE KXEE"
\u12BD "ETHIOPIC SYLLABLE KXE"
\u12BE "ETHIOPIC SYLLABLE KXO"
\u12C0 "ETHIOPIC SYLLABLE KXWA"
\u12C2 "ETHIOPIC SYLLABLE KXWI"
\u12C3 "ETHIOPIC SYLLABLE KXWAA"
\u12C4 "ETHIOPIC SYLLABLE KXWEE"
\u12C5 "ETHIOPIC SYLLABLE KXWE"
\u12C8 "ETHIOPIC SYLLABLE WA"
\u12C9 "ETHIOPIC SYLLABLE WU"
\u12CA "ETHIOPIC SYLLABLE WI"
\u12CB "ETHIOPIC SYLLABLE WAA"
\u12CC "ETHIOPIC SYLLABLE WEE"
\u12CD "ETHIOPIC SYLLABLE WE"
\u12CE "ETHIOPIC SYLLABLE WO"
\u12CF "ETHIOPIC SYLLABLE WOA"
\u12D0 "ETHIOPIC SYLLABLE PHARYNGEAL A"
\u12D1 "ETHIOPIC SYLLABLE PHARYNGEAL U"
\u12D2 "ETHIOPIC SYLLABLE PHARYNGEAL I"
\u12D3 "ETHIOPIC SYLLABLE PHARYNGEAL AA"
\u12D4 "ETHIOPIC SYLLABLE PHARYNGEAL EE"
\u12D5 "ETHIOPIC SYLLABLE PHARYNGEAL E"
\u12D6 "ETHIOPIC SYLLABLE PHARYNGEAL O"
\u12D8 "ETHIOPIC SYLLABLE ZA"
\u12D9 "ETHIOPIC SYLLABLE ZU"
\u12DA "ETHIOPIC SYLLABLE ZI"
\u12DB "ETHIOPIC SYLLABLE ZAA"
\u12DC "ETHIOPIC SYLLABLE ZEE"
\u12DD "ETHIOPIC SYLLABLE ZE"
\u12DE "ETHIOPIC SYLLABLE ZO"
\u12DF "ETHIOPIC SYLLABLE ZWA"
\u12E0 "ETHIOPIC SYLLABLE ZHA"
\u12E1 "ETHIOPIC SYLLABLE ZHU"
\u12E2 "ETHIOPIC SYLLABLE ZHI"
\u12E3 "ETHIOPIC SYLLABLE ZHAA"
\u12E4 "ETHIOPIC SYLLABLE ZHEE"
\u12E5 "ETHIOPIC SYLLABLE ZHE"
\u12E6 "ETHIOPIC SYLLABLE ZHO"
\u12E7 "ETHIOPIC SYLLABLE ZHWA"
\u12E8 "ETHIOPIC SYLLABLE YA"
\u12E9 "ETHIOPIC SYLLABLE YU"
\u12EA "ETHIOPIC SYLLABLE YI"
\u12EB "ETHIOPIC SYLLABLE YAA"
\u12EC "ETHIOPIC SYLLABLE YEE"
\u12ED "ETHIOPIC SYLLABLE YE"
\u12EE "ETHIOPIC SYLLABLE YO"
\u12EF "ETHIOPIC SYLLABLE YOA"
\u12F0 "ETHIOPIC SYLLABLE DA"
\u12F1 "ETHIOPIC SYLLABLE DU"
\u12F2 "ETHIOPIC SYLLABLE DI"
\u12F3 "ETHIOPIC SYLLABLE DAA"
\u12F4 "ETHIOPIC SYLLABLE DEE"
\u12F5 "ETHIOPIC SYLLABLE DE"
\u12F6 "ETHIOPIC SYLLABLE DO"
\u12F7 "ETHIOPIC SYLLABLE DWA"
\u12F8 "ETHIOPIC SYLLABLE DDA"
\u12F9 "ETHIOPIC SYLLABLE DDU"
\u12FA "ETHIOPIC SYLLABLE DDI"
\u12FB "ETHIOPIC SYLLABLE DDAA"
\u12FC "ETHIOPIC SYLLABLE DDEE"
\u12FD "ETHIOPIC SYLLABLE DDE"
\u12FE "ETHIOPIC SYLLABLE DDO"
\u12FF "ETHIOPIC SYLLABLE DDWA"
\u1300 "ETHIOPIC SYLLABLE JA"
\u1301 "ETHIOPIC SYLLABLE JU"
\u1302 "ETHIOPIC SYLLABLE JI"
\u1303 "ETHIOPIC SYLLABLE JAA"
\u1304 "ETHIOPIC SYLLABLE JEE"
\u1305 "ETHIOPIC SYLLABLE JE"
\u1306 "ETHIOPIC SYLLABLE JO"
\u1307 "ETHIOPIC SYLLABLE JWA"
\u1308 "ETHIOPIC SYLLABLE GA"
\u1309 "ETHIOPIC SYLLABLE GU"
\u130A "ETHIOPIC SYLLABLE GI"
\u130B "ETHIOPIC SYLLABLE GAA"
\u130C "ETHIOPIC SYLLABLE GEE"
\u130D "ETHIOPIC SYLLABLE GE"
\u130E "ETHIOPIC SYLLABLE GO"
\u130F "ETHIOPIC SYLLABLE GOA"
\u1310 "ETHIOPIC SYLLABLE GWA"
\u1312 "ETHIOPIC SYLLABLE GWI"
\u1313 "ETHIOPIC SYLLABLE GWAA"
\u1314 "ETHIOPIC SYLLABLE GWEE"
\u1315 "ETHIOPIC SYLLABLE GWE"
\u1318 "ETHIOPIC SYLLABLE GGA"
\u1319 "ETHIOPIC SYLLABLE GGU"
\u131A "ETHIOPIC SYLLABLE GGI"
\u131B "ETHIOPIC SYLLABLE GGAA"
\u131C "ETHIOPIC SYLLABLE GGEE"
\u131D "ETHIOPIC SYLLABLE GGE"
\u131E "ETHIOPIC SYLLABLE GGO"
\u131F "ETHIOPIC SYLLABLE GGWAA"
\u1320 "ETHIOPIC SYLLABLE THA"
\u1321 "ETHIOPIC SYLLABLE THU"
\u1322 "ETHIOPIC SYLLABLE THI"
\u1323 "ETHIOPIC SYLLABLE THAA"
\u1324 "ETHIOPIC SYLLABLE THEE"
\u1325 "ETHIOPIC SYLLABLE THE"
\u1326 "ETHIOPIC SYLLABLE THO"
\u1327 "ETHIOPIC SYLLABLE THWA"
\u1328 "ETHIOPIC SYLLABLE CHA"
\u1329 "ETHIOPIC SYLLABLE CHU"
\u132A "ETHIOPIC SYLLABLE CHI"
\u132B "ETHIOPIC SYLLABLE CHAA"
\u132C "ETHIOPIC SYLLABLE CHEE"
\u132D "ETHIOPIC SYLLABLE CHE"
\u132E "ETHIOPIC SYLLABLE CHO"
\u132F "ETHIOPIC SYLLABLE CHWA"
\u1330 "ETHIOPIC SYLLABLE PHA"
\u1331 "ETHIOPIC SYLLABLE PHU"
\u1332 "ETHIOPIC SYLLABLE PHI"
\u1333 "ETHIOPIC SYLLABLE PHAA"
\u1334 "ETHIOPIC SYLLABLE PHEE"
\u1335 "ETHIOPIC SYLLABLE PHE"
\u1336 "ETHIOPIC SYLLABLE PHO"
\u1337 "ETHIOPIC SYLLABLE PHWA"
\u1338 "ETHIOPIC SYLLABLE TSA"
\u1339 "ETHIOPIC SYLLABLE TSU"
\u133A "ETHIOPIC SYLLABLE TSI"
\u133B "ETHIOPIC SYLLABLE TSAA"
\u133C "ETHIOPIC SYLLABLE TSEE"
\u133D "ETHIOPIC SYLLABLE TSE"
\u133E "ETHIOPIC SYLLABLE TSO"
\u133F "ETHIOPIC SYLLABLE TSWA"
\u1340 "ETHIOPIC SYLLABLE TZA"
\u1341 "ETHIOPIC SYLLABLE TZU"
\u1342 "ETHIOPIC SYLLABLE TZI"
\u1343 "ETHIOPIC SYLLABLE TZAA"
\u1344 "ETHIOPIC SYLLABLE TZEE"
\u1345 "ETHIOPIC SYLLABLE TZE"
\u1346 "ETHIOPIC SYLLABLE TZO"
\u1347 "ETHIOPIC SYLLABLE TZOA"
\u1348 "ETHIOPIC SYLLABLE FA"
\u1349 "ETHIOPIC SYLLABLE FU"
\u134A "ETHIOPIC SYLLABLE FI"
\u134B "ETHIOPIC SYLLABLE FAA"
\u134C "ETHIOPIC SYLLABLE FEE"
\u134D "ETHIOPIC SYLLABLE FE"
\u134E "ETHIOPIC SYLLABLE FO"
\u134F "ETHIOPIC SYLLABLE FWA"
\u1350 "ETHIOPIC SYLLABLE PA"
\u1351 "ETHIOPIC SYLLABLE PU"
\u1352 "ETHIOPIC SYLLABLE PI"
\u1353 "ETHIOPIC SYLLABLE PAA"
\u1354 "ETHIOPIC SYLLABLE PEE"
\u1355 "ETHIOPIC SYLLABLE PE"
\u1356 "ETHIOPIC SYLLABLE PO"
\u1357 "ETHIOPIC SYLLABLE PWA"
\u1358 "ETHIOPIC SYLLABLE RYA"
\u1359 "ETHIOPIC SYLLABLE MYA"
\u135A "ETHIOPIC SYLLABLE FYA"
\u135F "ETHIOPIC COMBINING GEMINATION MARK"
\u1360 "ETHIOPIC SECTION MARK"
\u1361 "ETHIOPIC WORDSPACE"
\u1362 "ETHIOPIC FULL STOP"
\u1363 "ETHIOPIC COMMA"
\u1364 "ETHIOPIC SEMICOLON"
\u1365 "ETHIOPIC COLON"
\u1366 "ETHIOPIC PREFACE COLON"
\u1367 "ETHIOPIC QUESTION MARK"
\u1368 "ETHIOPIC PARAGRAPH SEPARATOR"
\u1369 "ETHIOPIC DIGIT ONE"
\u136A "ETHIOPIC DIGIT TWO"
\u136B "ETHIOPIC DIGIT THREE"
\u136C "ETHIOPIC DIGIT FOUR"
\u136D "ETHIOPIC DIGIT FIVE"
\u136E "ETHIOPIC DIGIT SIX"
\u136F "ETHIOPIC DIGIT SEVEN"
\u1370 "ETHIOPIC DIGIT EIGHT"
\u1371 "ETHIOPIC DIGIT NINE"
\u1372 "ETHIOPIC NUMBER TEN"
\u1373 "ETHIOPIC NUMBER TWENTY"
\u1374 "ETHIOPIC NUMBER THIRTY"
\u1375 "ETHIOPIC NUMBER FORTY"
\u1376 "ETHIOPIC NUMBER FIFTY"
\u1377 "ETHIOPIC NUMBER SIXTY"
\u1378 "ETHIOPIC NUMBER SEVENTY"
\u1379 "ETHIOPIC NUMBER EIGHTY"
\u137A "ETHIOPIC NUMBER NINETY"
\u137B "ETHIOPIC NUMBER HUNDRED"
\u137C "ETHIOPIC NUMBER TEN THOUSAND"
\u1380 "ETHIOPIC SYLLABLE SEBATBEIT MWA"
\u1381 "ETHIOPIC SYLLABLE MWI"
\u1382 "ETHIOPIC SYLLABLE MWEE"
\u1383 "ETHIOPIC SYLLABLE MWE"
\u1384 "ETHIOPIC SYLLABLE SEBATBEIT BWA"
\u1385 "ETHIOPIC SYLLABLE BWI"
\u1386 "ETHIOPIC SYLLABLE BWEE"
\u1387 "ETHIOPIC SYLLABLE BWE"
\u1388 "ETHIOPIC SYLLABLE SEBATBEIT FWA"
\u1389 "ETHIOPIC SYLLABLE FWI"
\u138A "ETHIOPIC SYLLABLE FWEE"
\u138B "ETHIOPIC SYLLABLE FWE"
\u138C "ETHIOPIC SYLLABLE SEBATBEIT PWA"
\u138D "ETHIOPIC SYLLABLE PWI"
\u138E "ETHIOPIC SYLLABLE PWEE"
\u138F "ETHIOPIC SYLLABLE PWE"
\u1390 "ETHIOPIC TONAL MARK YIZET"
\u1391 "ETHIOPIC TONAL MARK DERET"
\u1392 "ETHIOPIC TONAL MARK RIKRIK"
\u1393 "ETHIOPIC TONAL MARK SHORT RIKRIK"
\u1394 "ETHIOPIC TONAL MARK DIFAT"
\u1395 "ETHIOPIC TONAL MARK KENAT"
\u1396 "ETHIOPIC TONAL MARK CHIRET"
\u1397 "ETHIOPIC TONAL MARK HIDET"
\u1398 "ETHIOPIC TONAL MARK DERET-HIDET"
\u1399 "ETHIOPIC TONAL MARK KURT"
\u13A0 "CHEROKEE LETTER A"
\u13A1 "CHEROKEE LETTER E"
\u13A2 "CHEROKEE LETTER I"
\u13A3 "CHEROKEE LETTER O"
\u13A4 "CHEROKEE LETTER U"
\u13A5 "CHEROKEE LETTER V"
\u13A6 "CHEROKEE LETTER GA"
\u13A7 "CHEROKEE LETTER KA"
\u13A8 "CHEROKEE LETTER GE"
\u13A9 "CHEROKEE LETTER GI"
\u13AA "CHEROKEE LETTER GO"
\u13AB "CHEROKEE LETTER GU"
\u13AC "CHEROKEE LETTER GV"
\u13AD "CHEROKEE LETTER HA"
\u13AE "CHEROKEE LETTER HE"
\u13AF "CHEROKEE LETTER HI"
\u13B0 "CHEROKEE LETTER HO"
\u13B1 "CHEROKEE LETTER HU"
\u13B2 "CHEROKEE LETTER HV"
\u13B3 "CHEROKEE LETTER LA"
\u13B4 "CHEROKEE LETTER LE"
\u13B5 "CHEROKEE LETTER LI"
\u13B6 "CHEROKEE LETTER LO"
\u13B7 "CHEROKEE LETTER LU"
\u13B8 "CHEROKEE LETTER LV"
\u13B9 "CHEROKEE LETTER MA"
\u13BA "CHEROKEE LETTER ME"
\u13BB "CHEROKEE LETTER MI"
\u13BC "CHEROKEE LETTER MO"
\u13BD "CHEROKEE LETTER MU"
\u13BE "CHEROKEE LETTER NA"
\u13BF "CHEROKEE LETTER HNA"
\u13C0 "CHEROKEE LETTER NAH"
\u13C1 "CHEROKEE LETTER NE"
\u13C2 "CHEROKEE LETTER NI"
\u13C3 "CHEROKEE LETTER NO"
\u13C4 "CHEROKEE LETTER NU"
\u13C5 "CHEROKEE LETTER NV"
\u13C6 "CHEROKEE LETTER QUA"
\u13C7 "CHEROKEE LETTER QUE"
\u13C8 "CHEROKEE LETTER QUI"
\u13C9 "CHEROKEE LETTER QUO"
\u13CA "CHEROKEE LETTER QUU"
\u13CB "CHEROKEE LETTER QUV"
\u13CC "CHEROKEE LETTER SA"
\u13CD "CHEROKEE LETTER S"
\u13CE "CHEROKEE LETTER SE"
\u13CF "CHEROKEE LETTER SI"
\u13D0 "CHEROKEE LETTER SO"
\u13D1 "CHEROKEE LETTER SU"
\u13D2 "CHEROKEE LETTER SV"
\u13D3 "CHEROKEE LETTER DA"
\u13D4 "CHEROKEE LETTER TA"
\u13D5 "CHEROKEE LETTER DE"
\u13D6 "CHEROKEE LETTER TE"
\u13D7 "CHEROKEE LETTER DI"
\u13D8 "CHEROKEE LETTER TI"
\u13D9 "CHEROKEE LETTER DO"
\u13DA "CHEROKEE LETTER DU"
\u13DB "CHEROKEE LETTER DV"
\u13DC "CHEROKEE LETTER DLA"
\u13DD "CHEROKEE LETTER TLA"
\u13DE "CHEROKEE LETTER TLE"
\u13DF "CHEROKEE LETTER TLI"
\u13E0 "CHEROKEE LETTER TLO"
\u13E1 "CHEROKEE LETTER TLU"
\u13E2 "CHEROKEE LETTER TLV"
\u13E3 "CHEROKEE LETTER TSA"
\u13E4 "CHEROKEE LETTER TSE"
\u13E5 "CHEROKEE LETTER TSI"
\u13E6 "CHEROKEE LETTER TSO"
\u13E7 "CHEROKEE LETTER TSU"
\u13E8 "CHEROKEE LETTER TSV"
\u13E9 "CHEROKEE LETTER WA"
\u13EA "CHEROKEE LETTER WE"
\u13EB "CHEROKEE LETTER WI"
\u13EC "CHEROKEE LETTER WO"
\u13ED "CHEROKEE LETTER WU"
\u13EE "CHEROKEE LETTER WV"
\u13EF "CHEROKEE LETTER YA"
\u13F0 "CHEROKEE LETTER YE"
\u13F1 "CHEROKEE LETTER YI"
\u13F2 "CHEROKEE LETTER YO"
\u13F3 "CHEROKEE LETTER YU"
\u13F4 "CHEROKEE LETTER YV"
\u1401 "CANADIAN SYLLABICS E"
\u1402 "CANADIAN SYLLABICS AAI"
\u1403 "CANADIAN SYLLABICS I"
\u1404 "CANADIAN SYLLABICS II"
\u1405 "CANADIAN SYLLABICS O"
\u1406 "CANADIAN SYLLABICS OO"
\u1407 "CANADIAN SYLLABICS Y-CREE OO"
\u1408 "CANADIAN SYLLABICS CARRIER EE"
\u1409 "CANADIAN SYLLABICS CARRIER I"
\u140A "CANADIAN SYLLABICS A"
\u140B "CANADIAN SYLLABICS AA"
\u140C "CANADIAN SYLLABICS WE"
\u140D "CANADIAN SYLLABICS WEST-CREE WE"
\u140E "CANADIAN SYLLABICS WI"
\u140F "CANADIAN SYLLABICS WEST-CREE WI"
\u1410 "CANADIAN SYLLABICS WII"
\u1411 "CANADIAN SYLLABICS WEST-CREE WII"
\u1412 "CANADIAN SYLLABICS WO"
\u1413 "CANADIAN SYLLABICS WEST-CREE WO"
\u1414 "CANADIAN SYLLABICS WOO"
\u1415 "CANADIAN SYLLABICS WEST-CREE WOO"
\u1416 "CANADIAN SYLLABICS NASKAPI WOO"
\u1417 "CANADIAN SYLLABICS WA"
\u1418 "CANADIAN SYLLABICS WEST-CREE WA"
\u1419 "CANADIAN SYLLABICS WAA"
\u141A "CANADIAN SYLLABICS WEST-CREE WAA"
\u141B "CANADIAN SYLLABICS NASKAPI WAA"
\u141C "CANADIAN SYLLABICS AI"
\u141D "CANADIAN SYLLABICS Y-CREE W"
\u141E "CANADIAN SYLLABICS GLOTTAL STOP"
\u141F "CANADIAN SYLLABICS FINAL ACUTE"
\u1420 "CANADIAN SYLLABICS FINAL GRAVE"
\u1421 "CANADIAN SYLLABICS FINAL BOTTOM HALF RING"
\u1422 "CANADIAN SYLLABICS FINAL TOP HALF RING"
\u1423 "CANADIAN SYLLABICS FINAL RIGHT HALF RING"
\u1424 "CANADIAN SYLLABICS FINAL RING"
\u1425 "CANADIAN SYLLABICS FINAL DOUBLE ACUTE"
\u1426 "CANADIAN SYLLABICS FINAL DOUBLE SHORT VERTICAL STROKES"
\u1427 "CANADIAN SYLLABICS FINAL MIDDLE DOT"
\u1428 "CANADIAN SYLLABICS FINAL SHORT HORIZONTAL STROKE"
\u1429 "CANADIAN SYLLABICS FINAL PLUS"
\u142A "CANADIAN SYLLABICS FINAL DOWN TACK"
\u142B "CANADIAN SYLLABICS EN"
\u142C "CANADIAN SYLLABICS IN"
\u142D "CANADIAN SYLLABICS ON"
\u142E "CANADIAN SYLLABICS AN"
\u142F "CANADIAN SYLLABICS PE"
\u1430 "CANADIAN SYLLABICS PAAI"
\u1431 "CANADIAN SYLLABICS PI"
\u1432 "CANADIAN SYLLABICS PII"
\u1433 "CANADIAN SYLLABICS PO"
\u1434 "CANADIAN SYLLABICS POO"
\u1435 "CANADIAN SYLLABICS Y-CREE POO"
\u1436 "CANADIAN SYLLABICS CARRIER HEE"
\u1437 "CANADIAN SYLLABICS CARRIER HI"
\u1438 "CANADIAN SYLLABICS PA"
\u1439 "CANADIAN SYLLABICS PAA"
\u143A "CANADIAN SYLLABICS PWE"
\u143B "CANADIAN SYLLABICS WEST-CREE PWE"
\u143C "CANADIAN SYLLABICS PWI"
\u143D "CANADIAN SYLLABICS WEST-CREE PWI"
\u143E "CANADIAN SYLLABICS PWII"
\u143F "CANADIAN SYLLABICS WEST-CREE PWII"
\u1440 "CANADIAN SYLLABICS PWO"
\u1441 "CANADIAN SYLLABICS WEST-CREE PWO"
\u1442 "CANADIAN SYLLABICS PWOO"
\u1443 "CANADIAN SYLLABICS WEST-CREE PWOO"
\u1444 "CANADIAN SYLLABICS PWA"
\u1445 "CANADIAN SYLLABICS WEST-CREE PWA"
\u1446 "CANADIAN SYLLABICS PWAA"
\u1447 "CANADIAN SYLLABICS WEST-CREE PWAA"
\u1448 "CANADIAN SYLLABICS Y-CREE PWAA"
\u1449 "CANADIAN SYLLABICS P"
\u144A "CANADIAN SYLLABICS WEST-CREE P"
\u144B "CANADIAN SYLLABICS CARRIER H"
\u144C "CANADIAN SYLLABICS TE"
\u144D "CANADIAN SYLLABICS TAAI"
\u144E "CANADIAN SYLLABICS TI"
\u144F "CANADIAN SYLLABICS TII"
\u1450 "CANADIAN SYLLABICS TO"
\u1451 "CANADIAN SYLLABICS TOO"
\u1452 "CANADIAN SYLLABICS Y-CREE TOO"
\u1453 "CANADIAN SYLLABICS CARRIER DEE"
\u1454 "CANADIAN SYLLABICS CARRIER DI"
\u1455 "CANADIAN SYLLABICS TA"
\u1456 "CANADIAN SYLLABICS TAA"
\u1457 "CANADIAN SYLLABICS TWE"
\u1458 "CANADIAN SYLLABICS WEST-CREE TWE"
\u1459 "CANADIAN SYLLABICS TWI"
\u145A "CANADIAN SYLLABICS WEST-CREE TWI"
\u145B "CANADIAN SYLLABICS TWII"
\u145C "CANADIAN SYLLABICS WEST-CREE TWII"
\u145D "CANADIAN SYLLABICS TWO"
\u145E "CANADIAN SYLLABICS WEST-CREE TWO"
\u145F "CANADIAN SYLLABICS TWOO"
\u1460 "CANADIAN SYLLABICS WEST-CREE TWOO"
\u1461 "CANADIAN SYLLABICS TWA"
\u1462 "CANADIAN SYLLABICS WEST-CREE TWA"
\u1463 "CANADIAN SYLLABICS TWAA"
\u1464 "CANADIAN SYLLABICS WEST-CREE TWAA"
\u1465 "CANADIAN SYLLABICS NASKAPI TWAA"
\u1466 "CANADIAN SYLLABICS T"
\u1467 "CANADIAN SYLLABICS TTE"
\u1468 "CANADIAN SYLLABICS TTI"
\u1469 "CANADIAN SYLLABICS TTO"
\u146A "CANADIAN SYLLABICS TTA"
\u146B "CANADIAN SYLLABICS KE"
\u146C "CANADIAN SYLLABICS KAAI"
\u146D "CANADIAN SYLLABICS KI"
\u146E "CANADIAN SYLLABICS KII"
\u146F "CANADIAN SYLLABICS KO"
\u1470 "CANADIAN SYLLABICS KOO"
\u1471 "CANADIAN SYLLABICS Y-CREE KOO"
\u1472 "CANADIAN SYLLABICS KA"
\u1473 "CANADIAN SYLLABICS KAA"
\u1474 "CANADIAN SYLLABICS KWE"
\u1475 "CANADIAN SYLLABICS WEST-CREE KWE"
\u1476 "CANADIAN SYLLABICS KWI"
\u1477 "CANADIAN SYLLABICS WEST-CREE KWI"
\u1478 "CANADIAN SYLLABICS KWII"
\u1479 "CANADIAN SYLLABICS WEST-CREE KWII"
\u147A "CANADIAN SYLLABICS KWO"
\u147B "CANADIAN SYLLABICS WEST-CREE KWO"
\u147C "CANADIAN SYLLABICS KWOO"
\u147D "CANADIAN SYLLABICS WEST-CREE KWOO"
\u147E "CANADIAN SYLLABICS KWA"
\u147F "CANADIAN SYLLABICS WEST-CREE KWA"
\u1480 "CANADIAN SYLLABICS KWAA"
\u1481 "CANADIAN SYLLABICS WEST-CREE KWAA"
\u1482 "CANADIAN SYLLABICS NASKAPI KWAA"
\u1483 "CANADIAN SYLLABICS K"
\u1484 "CANADIAN SYLLABICS KW"
\u1485 "CANADIAN SYLLABICS SOUTH-SLAVEY KEH"
\u1486 "CANADIAN SYLLABICS SOUTH-SLAVEY KIH"
\u1487 "CANADIAN SYLLABICS SOUTH-SLAVEY KOH"
\u1488 "CANADIAN SYLLABICS SOUTH-SLAVEY KAH"
\u1489 "CANADIAN SYLLABICS CE"
\u148A "CANADIAN SYLLABICS CAAI"
\u148B "CANADIAN SYLLABICS CI"
\u148C "CANADIAN SYLLABICS CII"
\u148D "CANADIAN SYLLABICS CO"
\u148E "CANADIAN SYLLABICS COO"
\u148F "CANADIAN SYLLABICS Y-CREE COO"
\u1490 "CANADIAN SYLLABICS CA"
\u1491 "CANADIAN SYLLABICS CAA"
\u1492 "CANADIAN SYLLABICS CWE"
\u1493 "CANADIAN SYLLABICS WEST-CREE CWE"
\u1494 "CANADIAN SYLLABICS CWI"
\u1495 "CANADIAN SYLLABICS WEST-CREE CWI"
\u1496 "CANADIAN SYLLABICS CWII"
\u1497 "CANADIAN SYLLABICS WEST-CREE CWII"
\u1498 "CANADIAN SYLLABICS CWO"
\u1499 "CANADIAN SYLLABICS WEST-CREE CWO"
\u149A "CANADIAN SYLLABICS CWOO"
\u149B "CANADIAN SYLLABICS WEST-CREE CWOO"
\u149C "CANADIAN SYLLABICS CWA"
\u149D "CANADIAN SYLLABICS WEST-CREE CWA"
\u149E "CANADIAN SYLLABICS CWAA"
\u149F "CANADIAN SYLLABICS WEST-CREE CWAA"
\u14A0 "CANADIAN SYLLABICS NASKAPI CWAA"
\u14A1 "CANADIAN SYLLABICS C"
\u14A2 "CANADIAN SYLLABICS SAYISI TH"
\u14A3 "CANADIAN SYLLABICS ME"
\u14A4 "CANADIAN SYLLABICS MAAI"
\u14A5 "CANADIAN SYLLABICS MI"
\u14A6 "CANADIAN SYLLABICS MII"
\u14A7 "CANADIAN SYLLABICS MO"
\u14A8 "CANADIAN SYLLABICS MOO"
\u14A9 "CANADIAN SYLLABICS Y-CREE MOO"
\u14AA "CANADIAN SYLLABICS MA"
\u14AB "CANADIAN SYLLABICS MAA"
\u14AC "CANADIAN SYLLABICS MWE"
\u14AD "CANADIAN SYLLABICS WEST-CREE MWE"
\u14AE "CANADIAN SYLLABICS MWI"
\u14AF "CANADIAN SYLLABICS WEST-CREE MWI"
\u14B0 "CANADIAN SYLLABICS MWII"
\u14B1 "CANADIAN SYLLABICS WEST-CREE MWII"
\u14B2 "CANADIAN SYLLABICS MWO"
\u14B3 "CANADIAN SYLLABICS WEST-CREE MWO"
\u14B4 "CANADIAN SYLLABICS MWOO"
\u14B5 "CANADIAN SYLLABICS WEST-CREE MWOO"
\u14B6 "CANADIAN SYLLABICS MWA"
\u14B7 "CANADIAN SYLLABICS WEST-CREE MWA"
\u14B8 "CANADIAN SYLLABICS MWAA"
\u14B9 "CANADIAN SYLLABICS WEST-CREE MWAA"
\u14BA "CANADIAN SYLLABICS NASKAPI MWAA"
\u14BB "CANADIAN SYLLABICS M"
\u14BC "CANADIAN SYLLABICS WEST-CREE M"
\u14BD "CANADIAN SYLLABICS MH"
\u14BE "CANADIAN SYLLABICS ATHAPASCAN M"
\u14BF "CANADIAN SYLLABICS SAYISI M"
\u14C0 "CANADIAN SYLLABICS NE"
\u14C1 "CANADIAN SYLLABICS NAAI"
\u14C2 "CANADIAN SYLLABICS NI"
\u14C3 "CANADIAN SYLLABICS NII"
\u14C4 "CANADIAN SYLLABICS NO"
\u14C5 "CANADIAN SYLLABICS NOO"
\u14C6 "CANADIAN SYLLABICS Y-CREE NOO"
\u14C7 "CANADIAN SYLLABICS NA"
\u14C8 "CANADIAN SYLLABICS NAA"
\u14C9 "CANADIAN SYLLABICS NWE"
\u14CA "CANADIAN SYLLABICS WEST-CREE NWE"
\u14CB "CANADIAN SYLLABICS NWA"
\u14CC "CANADIAN SYLLABICS WEST-CREE NWA"
\u14CD "CANADIAN SYLLABICS NWAA"
\u14CE "CANADIAN SYLLABICS WEST-CREE NWAA"
\u14CF "CANADIAN SYLLABICS NASKAPI NWAA"
\u14D0 "CANADIAN SYLLABICS N"
\u14D1 "CANADIAN SYLLABICS CARRIER NG"
\u14D2 "CANADIAN SYLLABICS NH"
\u14D3 "CANADIAN SYLLABICS LE"
\u14D4 "CANADIAN SYLLABICS LAAI"
\u14D5 "CANADIAN SYLLABICS LI"
\u14D6 "CANADIAN SYLLABICS LII"
\u14D7 "CANADIAN SYLLABICS LO"
\u14D8 "CANADIAN SYLLABICS LOO"
\u14D9 "CANADIAN SYLLABICS Y-CREE LOO"
\u14DA "CANADIAN SYLLABICS LA"
\u14DB "CANADIAN SYLLABICS LAA"
\u14DC "CANADIAN SYLLABICS LWE"
\u14DD "CANADIAN SYLLABICS WEST-CREE LWE"
\u14DE "CANADIAN SYLLABICS LWI"
\u14DF "CANADIAN SYLLABICS WEST-CREE LWI"
\u14E0 "CANADIAN SYLLABICS LWII"
\u14E1 "CANADIAN SYLLABICS WEST-CREE LWII"
\u14E2 "CANADIAN SYLLABICS LWO"
\u14E3 "CANADIAN SYLLABICS WEST-CREE LWO"
\u14E4 "CANADIAN SYLLABICS LWOO"
\u14E5 "CANADIAN SYLLABICS WEST-CREE LWOO"
\u14E6 "CANADIAN SYLLABICS LWA"
\u14E7 "CANADIAN SYLLABICS WEST-CREE LWA"
\u14E8 "CANADIAN SYLLABICS LWAA"
\u14E9 "CANADIAN SYLLABICS WEST-CREE LWAA"
\u14EA "CANADIAN SYLLABICS L"
\u14EB "CANADIAN SYLLABICS WEST-CREE L"
\u14EC "CANADIAN SYLLABICS MEDIAL L"
\u14ED "CANADIAN SYLLABICS SE"
\u14EE "CANADIAN SYLLABICS SAAI"
\u14EF "CANADIAN SYLLABICS SI"
\u14F0 "CANADIAN SYLLABICS SII"
\u14F1 "CANADIAN SYLLABICS SO"
\u14F2 "CANADIAN SYLLABICS SOO"
\u14F3 "CANADIAN SYLLABICS Y-CREE SOO"
\u14F4 "CANADIAN SYLLABICS SA"
\u14F5 "CANADIAN SYLLABICS SAA"
\u14F6 "CANADIAN SYLLABICS SWE"
\u14F7 "CANADIAN SYLLABICS WEST-CREE SWE"
\u14F8 "CANADIAN SYLLABICS SWI"
\u14F9 "CANADIAN SYLLABICS WEST-CREE SWI"
\u14FA "CANADIAN SYLLABICS SWII"
\u14FB "CANADIAN SYLLABICS WEST-CREE SWII"
\u14FC "CANADIAN SYLLABICS SWO"
\u14FD "CANADIAN SYLLABICS WEST-CREE SWO"
\u14FE "CANADIAN SYLLABICS SWOO"
\u14FF "CANADIAN SYLLABICS WEST-CREE SWOO"
\u1500 "CANADIAN SYLLABICS SWA"
\u1501 "CANADIAN SYLLABICS WEST-CREE SWA"
\u1502 "CANADIAN SYLLABICS SWAA"
\u1503 "CANADIAN SYLLABICS WEST-CREE SWAA"
\u1504 "CANADIAN SYLLABICS NASKAPI SWAA"
\u1505 "CANADIAN SYLLABICS S"
\u1506 "CANADIAN SYLLABICS ATHAPASCAN S"
\u1507 "CANADIAN SYLLABICS SW"
\u1508 "CANADIAN SYLLABICS BLACKFOOT S"
\u1509 "CANADIAN SYLLABICS MOOSE-CREE SK"
\u150A "CANADIAN SYLLABICS NASKAPI SKW"
\u150B "CANADIAN SYLLABICS NASKAPI S-W"
\u150C "CANADIAN SYLLABICS NASKAPI SPWA"
\u150D "CANADIAN SYLLABICS NASKAPI STWA"
\u150E "CANADIAN SYLLABICS NASKAPI SKWA"
\u150F "CANADIAN SYLLABICS NASKAPI SCWA"
\u1510 "CANADIAN SYLLABICS SHE"
\u1511 "CANADIAN SYLLABICS SHI"
\u1512 "CANADIAN SYLLABICS SHII"
\u1513 "CANADIAN SYLLABICS SHO"
\u1514 "CANADIAN SYLLABICS SHOO"
\u1515 "CANADIAN SYLLABICS SHA"
\u1516 "CANADIAN SYLLABICS SHAA"
\u1517 "CANADIAN SYLLABICS SHWE"
\u1518 "CANADIAN SYLLABICS WEST-CREE SHWE"
\u1519 "CANADIAN SYLLABICS SHWI"
\u151A "CANADIAN SYLLABICS WEST-CREE SHWI"
\u151B "CANADIAN SYLLABICS SHWII"
\u151C "CANADIAN SYLLABICS WEST-CREE SHWII"
\u151D "CANADIAN SYLLABICS SHWO"
\u151E "CANADIAN SYLLABICS WEST-CREE SHWO"
\u151F "CANADIAN SYLLABICS SHWOO"
\u1520 "CANADIAN SYLLABICS WEST-CREE SHWOO"
\u1521 "CANADIAN SYLLABICS SHWA"
\u1522 "CANADIAN SYLLABICS WEST-CREE SHWA"
\u1523 "CANADIAN SYLLABICS SHWAA"
\u1524 "CANADIAN SYLLABICS WEST-CREE SHWAA"
\u1525 "CANADIAN SYLLABICS SH"
\u1526 "CANADIAN SYLLABICS YE"
\u1527 "CANADIAN SYLLABICS YAAI"
\u1528 "CANADIAN SYLLABICS YI"
\u1529 "CANADIAN SYLLABICS YII"
\u152A "CANADIAN SYLLABICS YO"
\u152B "CANADIAN SYLLABICS YOO"
\u152C "CANADIAN SYLLABICS Y-CREE YOO"
\u152D "CANADIAN SYLLABICS YA"
\u152E "CANADIAN SYLLABICS YAA"
\u152F "CANADIAN SYLLABICS YWE"
\u1530 "CANADIAN SYLLABICS WEST-CREE YWE"
\u1531 "CANADIAN SYLLABICS YWI"
\u1532 "CANADIAN SYLLABICS WEST-CREE YWI"
\u1533 "CANADIAN SYLLABICS YWII"
\u1534 "CANADIAN SYLLABICS WEST-CREE YWII"
\u1535 "CANADIAN SYLLABICS YWO"
\u1536 "CANADIAN SYLLABICS WEST-CREE YWO"
\u1537 "CANADIAN SYLLABICS YWOO"
\u1538 "CANADIAN SYLLABICS WEST-CREE YWOO"
\u1539 "CANADIAN SYLLABICS YWA"
\u153A "CANADIAN SYLLABICS WEST-CREE YWA"
\u153B "CANADIAN SYLLABICS YWAA"
\u153C "CANADIAN SYLLABICS WEST-CREE YWAA"
\u153D "CANADIAN SYLLABICS NASKAPI YWAA"
\u153E "CANADIAN SYLLABICS Y"
\u153F "CANADIAN SYLLABICS BIBLE-CREE Y"
\u1540 "CANADIAN SYLLABICS WEST-CREE Y"
\u1541 "CANADIAN SYLLABICS SAYISI YI"
\u1542 "CANADIAN SYLLABICS RE"
\u1543 "CANADIAN SYLLABICS R-CREE RE"
\u1544 "CANADIAN SYLLABICS WEST-CREE LE"
\u1545 "CANADIAN SYLLABICS RAAI"
\u1546 "CANADIAN SYLLABICS RI"
\u1547 "CANADIAN SYLLABICS RII"
\u1548 "CANADIAN SYLLABICS RO"
\u1549 "CANADIAN SYLLABICS ROO"
\u154A "CANADIAN SYLLABICS WEST-CREE LO"
\u154B "CANADIAN SYLLABICS RA"
\u154C "CANADIAN SYLLABICS RAA"
\u154D "CANADIAN SYLLABICS WEST-CREE LA"
\u154E "CANADIAN SYLLABICS RWAA"
\u154F "CANADIAN SYLLABICS WEST-CREE RWAA"
\u1550 "CANADIAN SYLLABICS R"
\u1551 "CANADIAN SYLLABICS WEST-CREE R"
\u1552 "CANADIAN SYLLABICS MEDIAL R"
\u1553 "CANADIAN SYLLABICS FE"
\u1554 "CANADIAN SYLLABICS FAAI"
\u1555 "CANADIAN SYLLABICS FI"
\u1556 "CANADIAN SYLLABICS FII"
\u1557 "CANADIAN SYLLABICS FO"
\u1558 "CANADIAN SYLLABICS FOO"
\u1559 "CANADIAN SYLLABICS FA"
\u155A "CANADIAN SYLLABICS FAA"
\u155B "CANADIAN SYLLABICS FWAA"
\u155C "CANADIAN SYLLABICS WEST-CREE FWAA"
\u155D "CANADIAN SYLLABICS F"
\u155E "CANADIAN SYLLABICS THE"
\u155F "CANADIAN SYLLABICS N-CREE THE"
\u1560 "CANADIAN SYLLABICS THI"
\u1561 "CANADIAN SYLLABICS N-CREE THI"
\u1562 "CANADIAN SYLLABICS THII"
\u1563 "CANADIAN SYLLABICS N-CREE THII"
\u1564 "CANADIAN SYLLABICS THO"
\u1565 "CANADIAN SYLLABICS THOO"
\u1566 "CANADIAN SYLLABICS THA"
\u1567 "CANADIAN SYLLABICS THAA"
\u1568 "CANADIAN SYLLABICS THWAA"
\u1569 "CANADIAN SYLLABICS WEST-CREE THWAA"
\u156A "CANADIAN SYLLABICS TH"
\u156B "CANADIAN SYLLABICS TTHE"
\u156C "CANADIAN SYLLABICS TTHI"
\u156D "CANADIAN SYLLABICS TTHO"
\u156E "CANADIAN SYLLABICS TTHA"
\u156F "CANADIAN SYLLABICS TTH"
\u1570 "CANADIAN SYLLABICS TYE"
\u1571 "CANADIAN SYLLABICS TYI"
\u1572 "CANADIAN SYLLABICS TYO"
\u1573 "CANADIAN SYLLABICS TYA"
\u1574 "CANADIAN SYLLABICS NUNAVIK HE"
\u1575 "CANADIAN SYLLABICS NUNAVIK HI"
\u1576 "CANADIAN SYLLABICS NUNAVIK HII"
\u1577 "CANADIAN SYLLABICS NUNAVIK HO"
\u1578 "CANADIAN SYLLABICS NUNAVIK HOO"
\u1579 "CANADIAN SYLLABICS NUNAVIK HA"
\u157A "CANADIAN SYLLABICS NUNAVIK HAA"
\u157B "CANADIAN SYLLABICS NUNAVIK H"
\u157C "CANADIAN SYLLABICS NUNAVUT H"
\u157D "CANADIAN SYLLABICS HK"
\u157E "CANADIAN SYLLABICS QAAI"
\u157F "CANADIAN SYLLABICS QI"
\u1580 "CANADIAN SYLLABICS QII"
\u1581 "CANADIAN SYLLABICS QO"
\u1582 "CANADIAN SYLLABICS QOO"
\u1583 "CANADIAN SYLLABICS QA"
\u1584 "CANADIAN SYLLABICS QAA"
\u1585 "CANADIAN SYLLABICS Q"
\u1586 "CANADIAN SYLLABICS TLHE"
\u1587 "CANADIAN SYLLABICS TLHI"
\u1588 "CANADIAN SYLLABICS TLHO"
\u1589 "CANADIAN SYLLABICS TLHA"
\u158A "CANADIAN SYLLABICS WEST-CREE RE"
\u158B "CANADIAN SYLLABICS WEST-CREE RI"
\u158C "CANADIAN SYLLABICS WEST-CREE RO"
\u158D "CANADIAN SYLLABICS WEST-CREE RA"
\u158E "CANADIAN SYLLABICS NGAAI"
\u158F "CANADIAN SYLLABICS NGI"
\u1590 "CANADIAN SYLLABICS NGII"
\u1591 "CANADIAN SYLLABICS NGO"
\u1592 "CANADIAN SYLLABICS NGOO"
\u1593 "CANADIAN SYLLABICS NGA"
\u1594 "CANADIAN SYLLABICS NGAA"
\u1595 "CANADIAN SYLLABICS NG"
\u1596 "CANADIAN SYLLABICS NNG"
\u1597 "CANADIAN SYLLABICS SAYISI SHE"
\u1598 "CANADIAN SYLLABICS SAYISI SHI"
\u1599 "CANADIAN SYLLABICS SAYISI SHO"
\u159A "CANADIAN SYLLABICS SAYISI SHA"
\u159B "CANADIAN SYLLABICS WOODS-CREE THE"
\u159C "CANADIAN SYLLABICS WOODS-CREE THI"
\u159D "CANADIAN SYLLABICS WOODS-CREE THO"
\u159E "CANADIAN SYLLABICS WOODS-CREE THA"
\u159F "CANADIAN SYLLABICS WOODS-CREE TH"
\u15A0 "CANADIAN SYLLABICS LHI"
\u15A1 "CANADIAN SYLLABICS LHII"
\u15A2 "CANADIAN SYLLABICS LHO"
\u15A3 "CANADIAN SYLLABICS LHOO"
\u15A4 "CANADIAN SYLLABICS LHA"
\u15A5 "CANADIAN SYLLABICS LHAA"
\u15A6 "CANADIAN SYLLABICS LH"
\u15A7 "CANADIAN SYLLABICS TH-CREE THE"
\u15A8 "CANADIAN SYLLABICS TH-CREE THI"
\u15A9 "CANADIAN SYLLABICS TH-CREE THII"
\u15AA "CANADIAN SYLLABICS TH-CREE THO"
\u15AB "CANADIAN SYLLABICS TH-CREE THOO"
\u15AC "CANADIAN SYLLABICS TH-CREE THA"
\u15AD "CANADIAN SYLLABICS TH-CREE THAA"
\u15AE "CANADIAN SYLLABICS TH-CREE TH"
\u15AF "CANADIAN SYLLABICS AIVILIK B"
\u15B0 "CANADIAN SYLLABICS BLACKFOOT E"
\u15B1 "CANADIAN SYLLABICS BLACKFOOT I"
\u15B2 "CANADIAN SYLLABICS BLACKFOOT O"
\u15B3 "CANADIAN SYLLABICS BLACKFOOT A"
\u15B4 "CANADIAN SYLLABICS BLACKFOOT WE"
\u15B5 "CANADIAN SYLLABICS BLACKFOOT WI"
\u15B6 "CANADIAN SYLLABICS BLACKFOOT WO"
\u15B7 "CANADIAN SYLLABICS BLACKFOOT WA"
\u15B8 "CANADIAN SYLLABICS BLACKFOOT NE"
\u15B9 "CANADIAN SYLLABICS BLACKFOOT NI"
\u15BA "CANADIAN SYLLABICS BLACKFOOT NO"
\u15BB "CANADIAN SYLLABICS BLACKFOOT NA"
\u15BC "CANADIAN SYLLABICS BLACKFOOT KE"
\u15BD "CANADIAN SYLLABICS BLACKFOOT KI"
\u15BE "CANADIAN SYLLABICS BLACKFOOT KO"
\u15BF "CANADIAN SYLLABICS BLACKFOOT KA"
\u15C0 "CANADIAN SYLLABICS SAYISI HE"
\u15C1 "CANADIAN SYLLABICS SAYISI HI"
\u15C2 "CANADIAN SYLLABICS SAYISI HO"
\u15C3 "CANADIAN SYLLABICS SAYISI HA"
\u15C4 "CANADIAN SYLLABICS CARRIER GHU"
\u15C5 "CANADIAN SYLLABICS CARRIER GHO"
\u15C6 "CANADIAN SYLLABICS CARRIER GHE"
\u15C7 "CANADIAN SYLLABICS CARRIER GHEE"
\u15C8 "CANADIAN SYLLABICS CARRIER GHI"
\u15C9 "CANADIAN SYLLABICS CARRIER GHA"
\u15CA "CANADIAN SYLLABICS CARRIER RU"
\u15CB "CANADIAN SYLLABICS CARRIER RO"
\u15CC "CANADIAN SYLLABICS CARRIER RE"
\u15CD "CANADIAN SYLLABICS CARRIER REE"
\u15CE "CANADIAN SYLLABICS CARRIER RI"
\u15CF "CANADIAN SYLLABICS CARRIER RA"
\u15D0 "CANADIAN SYLLABICS CARRIER WU"
\u15D1 "CANADIAN SYLLABICS CARRIER WO"
\u15D2 "CANADIAN SYLLABICS CARRIER WE"
\u15D3 "CANADIAN SYLLABICS CARRIER WEE"
\u15D4 "CANADIAN SYLLABICS CARRIER WI"
\u15D5 "CANADIAN SYLLABICS CARRIER WA"
\u15D6 "CANADIAN SYLLABICS CARRIER HWU"
\u15D7 "CANADIAN SYLLABICS CARRIER HWO"
\u15D8 "CANADIAN SYLLABICS CARRIER HWE"
\u15D9 "CANADIAN SYLLABICS CARRIER HWEE"
\u15DA "CANADIAN SYLLABICS CARRIER HWI"
\u15DB "CANADIAN SYLLABICS CARRIER HWA"
\u15DC "CANADIAN SYLLABICS CARRIER THU"
\u15DD "CANADIAN SYLLABICS CARRIER THO"
\u15DE "CANADIAN SYLLABICS CARRIER THE"
\u15DF "CANADIAN SYLLABICS CARRIER THEE"
\u15E0 "CANADIAN SYLLABICS CARRIER THI"
\u15E1 "CANADIAN SYLLABICS CARRIER THA"
\u15E2 "CANADIAN SYLLABICS CARRIER TTU"
\u15E3 "CANADIAN SYLLABICS CARRIER TTO"
\u15E4 "CANADIAN SYLLABICS CARRIER TTE"
\u15E5 "CANADIAN SYLLABICS CARRIER TTEE"
\u15E6 "CANADIAN SYLLABICS CARRIER TTI"
\u15E7 "CANADIAN SYLLABICS CARRIER TTA"
\u15E8 "CANADIAN SYLLABICS CARRIER PU"
\u15E9 "CANADIAN SYLLABICS CARRIER PO"
\u15EA "CANADIAN SYLLABICS CARRIER PE"
\u15EB "CANADIAN SYLLABICS CARRIER PEE"
\u15EC "CANADIAN SYLLABICS CARRIER PI"
\u15ED "CANADIAN SYLLABICS CARRIER PA"
\u15EE "CANADIAN SYLLABICS CARRIER P"
\u15EF "CANADIAN SYLLABICS CARRIER GU"
\u15F0 "CANADIAN SYLLABICS CARRIER GO"
\u15F1 "CANADIAN SYLLABICS CARRIER GE"
\u15F2 "CANADIAN SYLLABICS CARRIER GEE"
\u15F3 "CANADIAN SYLLABICS CARRIER GI"
\u15F4 "CANADIAN SYLLABICS CARRIER GA"
\u15F5 "CANADIAN SYLLABICS CARRIER KHU"
\u15F6 "CANADIAN SYLLABICS CARRIER KHO"
\u15F7 "CANADIAN SYLLABICS CARRIER KHE"
\u15F8 "CANADIAN SYLLABICS CARRIER KHEE"
\u15F9 "CANADIAN SYLLABICS CARRIER KHI"
\u15FA "CANADIAN SYLLABICS CARRIER KHA"
\u15FB "CANADIAN SYLLABICS CARRIER KKU"
\u15FC "CANADIAN SYLLABICS CARRIER KKO"
\u15FD "CANADIAN SYLLABICS CARRIER KKE"
\u15FE "CANADIAN SYLLABICS CARRIER KKEE"
\u15FF "CANADIAN SYLLABICS CARRIER KKI"
\u1600 "CANADIAN SYLLABICS CARRIER KKA"
\u1601 "CANADIAN SYLLABICS CARRIER KK"
\u1602 "CANADIAN SYLLABICS CARRIER NU"
\u1603 "CANADIAN SYLLABICS CARRIER NO"
\u1604 "CANADIAN SYLLABICS CARRIER NE"
\u1605 "CANADIAN SYLLABICS CARRIER NEE"
\u1606 "CANADIAN SYLLABICS CARRIER NI"
\u1607 "CANADIAN SYLLABICS CARRIER NA"
\u1608 "CANADIAN SYLLABICS CARRIER MU"
\u1609 "CANADIAN SYLLABICS CARRIER MO"
\u160A "CANADIAN SYLLABICS CARRIER ME"
\u160B "CANADIAN SYLLABICS CARRIER MEE"
\u160C "CANADIAN SYLLABICS CARRIER MI"
\u160D "CANADIAN SYLLABICS CARRIER MA"
\u160E "CANADIAN SYLLABICS CARRIER YU"
\u160F "CANADIAN SYLLABICS CARRIER YO"
\u1610 "CANADIAN SYLLABICS CARRIER YE"
\u1611 "CANADIAN SYLLABICS CARRIER YEE"
\u1612 "CANADIAN SYLLABICS CARRIER YI"
\u1613 "CANADIAN SYLLABICS CARRIER YA"
\u1614 "CANADIAN SYLLABICS CARRIER JU"
\u1615 "CANADIAN SYLLABICS SAYISI JU"
\u1616 "CANADIAN SYLLABICS CARRIER JO"
\u1617 "CANADIAN SYLLABICS CARRIER JE"
\u1618 "CANADIAN SYLLABICS CARRIER JEE"
\u1619 "CANADIAN SYLLABICS CARRIER JI"
\u161A "CANADIAN SYLLABICS SAYISI JI"
\u161B "CANADIAN SYLLABICS CARRIER JA"
\u161C "CANADIAN SYLLABICS CARRIER JJU"
\u161D "CANADIAN SYLLABICS CARRIER JJO"
\u161E "CANADIAN SYLLABICS CARRIER JJE"
\u161F "CANADIAN SYLLABICS CARRIER JJEE"
\u1620 "CANADIAN SYLLABICS CARRIER JJI"
\u1621 "CANADIAN SYLLABICS CARRIER JJA"
\u1622 "CANADIAN SYLLABICS CARRIER LU"
\u1623 "CANADIAN SYLLABICS CARRIER LO"
\u1624 "CANADIAN SYLLABICS CARRIER LE"
\u1625 "CANADIAN SYLLABICS CARRIER LEE"
\u1626 "CANADIAN SYLLABICS CARRIER LI"
\u1627 "CANADIAN SYLLABICS CARRIER LA"
\u1628 "CANADIAN SYLLABICS CARRIER DLU"
\u1629 "CANADIAN SYLLABICS CARRIER DLO"
\u162A "CANADIAN SYLLABICS CARRIER DLE"
\u162B "CANADIAN SYLLABICS CARRIER DLEE"
\u162C "CANADIAN SYLLABICS CARRIER DLI"
\u162D "CANADIAN SYLLABICS CARRIER DLA"
\u162E "CANADIAN SYLLABICS CARRIER LHU"
\u162F "CANADIAN SYLLABICS CARRIER LHO"
\u1630 "CANADIAN SYLLABICS CARRIER LHE"
\u1631 "CANADIAN SYLLABICS CARRIER LHEE"
\u1632 "CANADIAN SYLLABICS CARRIER LHI"
\u1633 "CANADIAN SYLLABICS CARRIER LHA"
\u1634 "CANADIAN SYLLABICS CARRIER TLHU"
\u1635 "CANADIAN SYLLABICS CARRIER TLHO"
\u1636 "CANADIAN SYLLABICS CARRIER TLHE"
\u1637 "CANADIAN SYLLABICS CARRIER TLHEE"
\u1638 "CANADIAN SYLLABICS CARRIER TLHI"
\u1639 "CANADIAN SYLLABICS CARRIER TLHA"
\u163A "CANADIAN SYLLABICS CARRIER TLU"
\u163B "CANADIAN SYLLABICS CARRIER TLO"
\u163C "CANADIAN SYLLABICS CARRIER TLE"
\u163D "CANADIAN SYLLABICS CARRIER TLEE"
\u163E "CANADIAN SYLLABICS CARRIER TLI"
\u163F "CANADIAN SYLLABICS CARRIER TLA"
\u1640 "CANADIAN SYLLABICS CARRIER ZU"
\u1641 "CANADIAN SYLLABICS CARRIER ZO"
\u1642 "CANADIAN SYLLABICS CARRIER ZE"
\u1643 "CANADIAN SYLLABICS CARRIER ZEE"
\u1644 "CANADIAN SYLLABICS CARRIER ZI"
\u1645 "CANADIAN SYLLABICS CARRIER ZA"
\u1646 "CANADIAN SYLLABICS CARRIER Z"
\u1647 "CANADIAN SYLLABICS CARRIER INITIAL Z"
\u1648 "CANADIAN SYLLABICS CARRIER DZU"
\u1649 "CANADIAN SYLLABICS CARRIER DZO"
\u164A "CANADIAN SYLLABICS CARRIER DZE"
\u164B "CANADIAN SYLLABICS CARRIER DZEE"
\u164C "CANADIAN SYLLABICS CARRIER DZI"
\u164D "CANADIAN SYLLABICS CARRIER DZA"
\u164E "CANADIAN SYLLABICS CARRIER SU"
\u164F "CANADIAN SYLLABICS CARRIER SO"
\u1650 "CANADIAN SYLLABICS CARRIER SE"
\u1651 "CANADIAN SYLLABICS CARRIER SEE"
\u1652 "CANADIAN SYLLABICS CARRIER SI"
\u1653 "CANADIAN SYLLABICS CARRIER SA"
\u1654 "CANADIAN SYLLABICS CARRIER SHU"
\u1655 "CANADIAN SYLLABICS CARRIER SHO"
\u1656 "CANADIAN SYLLABICS CARRIER SHE"
\u1657 "CANADIAN SYLLABICS CARRIER SHEE"
\u1658 "CANADIAN SYLLABICS CARRIER SHI"
\u1659 "CANADIAN SYLLABICS CARRIER SHA"
\u165A "CANADIAN SYLLABICS CARRIER SH"
\u165B "CANADIAN SYLLABICS CARRIER TSU"
\u165C "CANADIAN SYLLABICS CARRIER TSO"
\u165D "CANADIAN SYLLABICS CARRIER TSE"
\u165E "CANADIAN SYLLABICS CARRIER TSEE"
\u165F "CANADIAN SYLLABICS CARRIER TSI"
\u1660 "CANADIAN SYLLABICS CARRIER TSA"
\u1661 "CANADIAN SYLLABICS CARRIER CHU"
\u1662 "CANADIAN SYLLABICS CARRIER CHO"
\u1663 "CANADIAN SYLLABICS CARRIER CHE"
\u1664 "CANADIAN SYLLABICS CARRIER CHEE"
\u1665 "CANADIAN SYLLABICS CARRIER CHI"
\u1666 "CANADIAN SYLLABICS CARRIER CHA"
\u1667 "CANADIAN SYLLABICS CARRIER TTSU"
\u1668 "CANADIAN SYLLABICS CARRIER TTSO"
\u1669 "CANADIAN SYLLABICS CARRIER TTSE"
\u166A "CANADIAN SYLLABICS CARRIER TTSEE"
\u166B "CANADIAN SYLLABICS CARRIER TTSI"
\u166C "CANADIAN SYLLABICS CARRIER TTSA"
\u166D "CANADIAN SYLLABICS CHI SIGN"
\u166E "CANADIAN SYLLABICS FULL STOP"
\u166F "CANADIAN SYLLABICS QAI"
\u1670 "CANADIAN SYLLABICS NGAI"
\u1671 "CANADIAN SYLLABICS NNGI"
\u1672 "CANADIAN SYLLABICS NNGII"
\u1673 "CANADIAN SYLLABICS NNGO"
\u1674 "CANADIAN SYLLABICS NNGOO"
\u1675 "CANADIAN SYLLABICS NNGA"
\u1676 "CANADIAN SYLLABICS NNGAA"
\u1680 "OGHAM SPACE MARK"
\u1681 "OGHAM LETTER BEITH"
\u1682 "OGHAM LETTER LUIS"
\u1683 "OGHAM LETTER FEARN"
\u1684 "OGHAM LETTER SAIL"
\u1685 "OGHAM LETTER NION"
\u1686 "OGHAM LETTER UATH"
\u1687 "OGHAM LETTER DAIR"
\u1688 "OGHAM LETTER TINNE"
\u1689 "OGHAM LETTER COLL"
\u168A "OGHAM LETTER CEIRT"
\u168B "OGHAM LETTER MUIN"
\u168C "OGHAM LETTER GORT"
\u168D "OGHAM LETTER NGEADAL"
\u168E "OGHAM LETTER STRAIF"
\u168F "OGHAM LETTER RUIS"
\u1690 "OGHAM LETTER AILM"
\u1691 "OGHAM LETTER ONN"
\u1692 "OGHAM LETTER UR"
\u1693 "OGHAM LETTER EADHADH"
\u1694 "OGHAM LETTER IODHADH"
\u1695 "OGHAM LETTER EABHADH"
\u1696 "OGHAM LETTER OR"
\u1697 "OGHAM LETTER UILLEANN"
\u1698 "OGHAM LETTER IFIN"
\u1699 "OGHAM LETTER EAMHANCHOLL"
\u169A "OGHAM LETTER PEITH"
\u169B "OGHAM FEATHER MARK"
\u169C "OGHAM REVERSED FEATHER MARK"
\u16A0 "RUNIC LETTER FEHU FEOH FE F"
\u16A1 "RUNIC LETTER V"
\u16A2 "RUNIC LETTER URUZ UR U"
\u16A3 "RUNIC LETTER YR"
\u16A4 "RUNIC LETTER Y"
\u16A5 "RUNIC LETTER W"
\u16A6 "RUNIC LETTER THURISAZ THURS THORN"
\u16A7 "RUNIC LETTER ETH"
\u16A8 "RUNIC LETTER ANSUZ A"
\u16A9 "RUNIC LETTER OS O"
\u16AA "RUNIC LETTER AC A"
\u16AB "RUNIC LETTER AESC"
\u16AC "RUNIC LETTER LONG-BRANCH-OSS O"
\u16AD "RUNIC LETTER SHORT-TWIG-OSS O"
\u16AE "RUNIC LETTER O"
\u16AF "RUNIC LETTER OE"
\u16B0 "RUNIC LETTER ON"
\u16B1 "RUNIC LETTER RAIDO RAD REID R"
\u16B2 "RUNIC LETTER KAUNA"
\u16B3 "RUNIC LETTER CEN"
\u16B4 "RUNIC LETTER KAUN K"
\u16B5 "RUNIC LETTER G"
\u16B6 "RUNIC LETTER ENG"
\u16B7 "RUNIC LETTER GEBO GYFU G"
\u16B8 "RUNIC LETTER GAR"
\u16B9 "RUNIC LETTER WUNJO WYNN W"
\u16BA "RUNIC LETTER HAGLAZ H"
\u16BB "RUNIC LETTER HAEGL H"
\u16BC "RUNIC LETTER LONG-BRANCH-HAGALL H"
\u16BD "RUNIC LETTER SHORT-TWIG-HAGALL H"
\u16BE "RUNIC LETTER NAUDIZ NYD NAUD N"
\u16BF "RUNIC LETTER SHORT-TWIG-NAUD N"
\u16C0 "RUNIC LETTER DOTTED-N"
\u16C1 "RUNIC LETTER ISAZ IS ISS I"
\u16C2 "RUNIC LETTER E"
\u16C3 "RUNIC LETTER JERAN J"
\u16C4 "RUNIC LETTER GER"
\u16C5 "RUNIC LETTER LONG-BRANCH-AR AE"
\u16C6 "RUNIC LETTER SHORT-TWIG-AR A"
\u16C7 "RUNIC LETTER IWAZ EOH"
\u16C8 "RUNIC LETTER PERTHO PEORTH P"
\u16C9 "RUNIC LETTER ALGIZ EOLHX"
\u16CA "RUNIC LETTER SOWILO S"
\u16CB "RUNIC LETTER SIGEL LONG-BRANCH-SOL S"
\u16CC "RUNIC LETTER SHORT-TWIG-SOL S"
\u16CD "RUNIC LETTER C"
\u16CE "RUNIC LETTER Z"
\u16CF "RUNIC LETTER TIWAZ TIR TYR T"
\u16D0 "RUNIC LETTER SHORT-TWIG-TYR T"
\u16D1 "RUNIC LETTER D"
\u16D2 "RUNIC LETTER BERKANAN BEORC BJARKAN B"
\u16D3 "RUNIC LETTER SHORT-TWIG-BJARKAN B"
\u16D4 "RUNIC LETTER DOTTED-P"
\u16D5 "RUNIC LETTER OPEN-P"
\u16D6 "RUNIC LETTER EHWAZ EH E"
\u16D7 "RUNIC LETTER MANNAZ MAN M"
\u16D8 "RUNIC LETTER LONG-BRANCH-MADR M"
\u16D9 "RUNIC LETTER SHORT-TWIG-MADR M"
\u16DA "RUNIC LETTER LAUKAZ LAGU LOGR L"
\u16DB "RUNIC LETTER DOTTED-L"
\u16DC "RUNIC LETTER INGWAZ"
\u16DD "RUNIC LETTER ING"
\u16DE "RUNIC LETTER DAGAZ DAEG D"
\u16DF "RUNIC LETTER OTHALAN ETHEL O"
\u16E0 "RUNIC LETTER EAR"
\u16E1 "RUNIC LETTER IOR"
\u16E2 "RUNIC LETTER CWEORTH"
\u16E3 "RUNIC LETTER CALC"
\u16E4 "RUNIC LETTER CEALC"
\u16E5 "RUNIC LETTER STAN"
\u16E6 "RUNIC LETTER LONG-BRANCH-YR"
\u16E7 "RUNIC LETTER SHORT-TWIG-YR"
\u16E8 "RUNIC LETTER ICELANDIC-YR"
\u16E9 "RUNIC LETTER Q"
\u16EA "RUNIC LETTER X"
\u16EB "RUNIC SINGLE PUNCTUATION"
\u16EC "RUNIC MULTIPLE PUNCTUATION"
\u16ED "RUNIC CROSS PUNCTUATION"
\u16EE "RUNIC ARLAUG SYMBOL"
\u16EF "RUNIC TVIMADUR SYMBOL"
\u16F0 "RUNIC BELGTHOR SYMBOL"
\u1700 "TAGALOG LETTER A"
\u1701 "TAGALOG LETTER I"
\u1702 "TAGALOG LETTER U"
\u1703 "TAGALOG LETTER KA"
\u1704 "TAGALOG LETTER GA"
\u1705 "TAGALOG LETTER NGA"
\u1706 "TAGALOG LETTER TA"
\u1707 "TAGALOG LETTER DA"
\u1708 "TAGALOG LETTER NA"
\u1709 "TAGALOG LETTER PA"
\u170A "TAGALOG LETTER BA"
\u170B "TAGALOG LETTER MA"
\u170C "TAGALOG LETTER YA"
\u170E "TAGALOG LETTER LA"
\u170F "TAGALOG LETTER WA"
\u1710 "TAGALOG LETTER SA"
\u1711 "TAGALOG LETTER HA"
\u1712 "TAGALOG VOWEL SIGN I"
\u1713 "TAGALOG VOWEL SIGN U"
\u1714 "TAGALOG SIGN VIRAMA"
\u1720 "HANUNOO LETTER A"
\u1721 "HANUNOO LETTER I"
\u1722 "HANUNOO LETTER U"
\u1723 "HANUNOO LETTER KA"
\u1724 "HANUNOO LETTER GA"
\u1725 "HANUNOO LETTER NGA"
\u1726 "HANUNOO LETTER TA"
\u1727 "HANUNOO LETTER DA"
\u1728 "HANUNOO LETTER NA"
\u1729 "HANUNOO LETTER PA"
\u172A "HANUNOO LETTER BA"
\u172B "HANUNOO LETTER MA"
\u172C "HANUNOO LETTER YA"
\u172D "HANUNOO LETTER RA"
\u172E "HANUNOO LETTER LA"
\u172F "HANUNOO LETTER WA"
\u1730 "HANUNOO LETTER SA"
\u1731 "HANUNOO LETTER HA"
\u1732 "HANUNOO VOWEL SIGN I"
\u1733 "HANUNOO VOWEL SIGN U"
\u1734 "HANUNOO SIGN PAMUDPOD"
\u1735 "PHILIPPINE SINGLE PUNCTUATION"
\u1736 "PHILIPPINE DOUBLE PUNCTUATION"
\u1740 "BUHID LETTER A"
\u1741 "BUHID LETTER I"
\u1742 "BUHID LETTER U"
\u1743 "BUHID LETTER KA"
\u1744 "BUHID LETTER GA"
\u1745 "BUHID LETTER NGA"
\u1746 "BUHID LETTER TA"
\u1747 "BUHID LETTER DA"
\u1748 "BUHID LETTER NA"
\u1749 "BUHID LETTER PA"
\u174A "BUHID LETTER BA"
\u174B "BUHID LETTER MA"
\u174C "BUHID LETTER YA"
\u174D "BUHID LETTER RA"
\u174E "BUHID LETTER LA"
\u174F "BUHID LETTER WA"
\u1750 "BUHID LETTER SA"
\u1751 "BUHID LETTER HA"
\u1752 "BUHID VOWEL SIGN I"
\u1753 "BUHID VOWEL SIGN U"
\u1760 "TAGBANWA LETTER A"
\u1761 "TAGBANWA LETTER I"
\u1762 "TAGBANWA LETTER U"
\u1763 "TAGBANWA LETTER KA"
\u1764 "TAGBANWA LETTER GA"
\u1765 "TAGBANWA LETTER NGA"
\u1766 "TAGBANWA LETTER TA"
\u1767 "TAGBANWA LETTER DA"
\u1768 "TAGBANWA LETTER NA"
\u1769 "TAGBANWA LETTER PA"
\u176A "TAGBANWA LETTER BA"
\u176B "TAGBANWA LETTER MA"
\u176C "TAGBANWA LETTER YA"
\u176E "TAGBANWA LETTER LA"
\u176F "TAGBANWA LETTER WA"
\u1770 "TAGBANWA LETTER SA"
\u1772 "TAGBANWA VOWEL SIGN I"
\u1773 "TAGBANWA VOWEL SIGN U"
\u1780 "KHMER LETTER KA"
\u1781 "KHMER LETTER KHA"
\u1782 "KHMER LETTER KO"
\u1783 "KHMER LETTER KHO"
\u1784 "KHMER LETTER NGO"
\u1785 "KHMER LETTER CA"
\u1786 "KHMER LETTER CHA"
\u1787 "KHMER LETTER CO"
\u1788 "KHMER LETTER CHO"
\u1789 "KHMER LETTER NYO"
\u178A "KHMER LETTER DA"
\u178B "KHMER LETTER TTHA"
\u178C "KHMER LETTER DO"
\u178D "KHMER LETTER TTHO"
\u178E "KHMER LETTER NNO"
\u178F "KHMER LETTER TA"
\u1790 "KHMER LETTER THA"
\u1791 "KHMER LETTER TO"
\u1792 "KHMER LETTER THO"
\u1793 "KHMER LETTER NO"
\u1794 "KHMER LETTER BA"
\u1795 "KHMER LETTER PHA"
\u1796 "KHMER LETTER PO"
\u1797 "KHMER LETTER PHO"
\u1798 "KHMER LETTER MO"
\u1799 "KHMER LETTER YO"
\u179A "KHMER LETTER RO"
\u179B "KHMER LETTER LO"
\u179C "KHMER LETTER VO"
\u179D "KHMER LETTER SHA"
\u179E "KHMER LETTER SSO"
\u179F "KHMER LETTER SA"
\u17A0 "KHMER LETTER HA"
\u17A1 "KHMER LETTER LA"
\u17A2 "KHMER LETTER QA"
\u17A3 "KHMER INDEPENDENT VOWEL QAQ"
\u17A4 "KHMER INDEPENDENT VOWEL QAA"
\u17A5 "KHMER INDEPENDENT VOWEL QI"
\u17A6 "KHMER INDEPENDENT VOWEL QII"
\u17A7 "KHMER INDEPENDENT VOWEL QU"
\u17A8 "KHMER INDEPENDENT VOWEL QUK"
\u17A9 "KHMER INDEPENDENT VOWEL QUU"
\u17AA "KHMER INDEPENDENT VOWEL QUUV"
\u17AB "KHMER INDEPENDENT VOWEL RY"
\u17AC "KHMER INDEPENDENT VOWEL RYY"
\u17AD "KHMER INDEPENDENT VOWEL LY"
\u17AE "KHMER INDEPENDENT VOWEL LYY"
\u17AF "KHMER INDEPENDENT VOWEL QE"
\u17B0 "KHMER INDEPENDENT VOWEL QAI"
\u17B1 "KHMER INDEPENDENT VOWEL QOO TYPE ONE"
\u17B2 "KHMER INDEPENDENT VOWEL QOO TYPE TWO"
\u17B3 "KHMER INDEPENDENT VOWEL QAU"
\u17B4 "KHMER VOWEL INHERENT AQ"
\u17B5 "KHMER VOWEL INHERENT AA"
\u17B6 "KHMER VOWEL SIGN AA"
\u17B7 "KHMER VOWEL SIGN I"
\u17B8 "KHMER VOWEL SIGN II"
\u17B9 "KHMER VOWEL SIGN Y"
\u17BA "KHMER VOWEL SIGN YY"
\u17BB "KHMER VOWEL SIGN U"
\u17BC "KHMER VOWEL SIGN UU"
\u17BD "KHMER VOWEL SIGN UA"
\u17BE "KHMER VOWEL SIGN OE"
\u17BF "KHMER VOWEL SIGN YA"
\u17C0 "KHMER VOWEL SIGN IE"
\u17C1 "KHMER VOWEL SIGN E"
\u17C2 "KHMER VOWEL SIGN AE"
\u17C3 "KHMER VOWEL SIGN AI"
\u17C4 "KHMER VOWEL SIGN OO"
\u17C5 "KHMER VOWEL SIGN AU"
\u17C6 "KHMER SIGN NIKAHIT"
\u17C7 "KHMER SIGN REAHMUK"
\u17C8 "KHMER SIGN YUUKALEAPINTU"
\u17C9 "KHMER SIGN MUUSIKATOAN"
\u17CA "KHMER SIGN TRIISAP"
\u17CB "KHMER SIGN BANTOC"
\u17CC "KHMER SIGN ROBAT"
\u17CD "KHMER SIGN TOANDAKHIAT"
\u17CE "KHMER SIGN KAKABAT"
\u17CF "KHMER SIGN AHSDA"
\u17D0 "KHMER SIGN SAMYOK SANNYA"
\u17D1 "KHMER SIGN VIRIAM"
\u17D2 "KHMER SIGN COENG"
\u17D3 "KHMER SIGN BATHAMASAT"
\u17D4 "KHMER SIGN KHAN"
\u17D5 "KHMER SIGN BARIYOOSAN"
\u17D6 "KHMER SIGN CAMNUC PII KUUH"
\u17D7 "KHMER SIGN LEK TOO"
\u17D8 "KHMER SIGN BEYYAL"
\u17D9 "KHMER SIGN PHNAEK MUAN"
\u17DA "KHMER SIGN KOOMUUT"
\u17DB "KHMER CURRENCY SYMBOL RIEL"
\u17DC "KHMER SIGN AVAKRAHASANYA"
\u17DD "KHMER SIGN ATTHACAN"
\u17E0 "KHMER DIGIT ZERO"
\u17E1 "KHMER DIGIT ONE"
\u17E2 "KHMER DIGIT TWO"
\u17E3 "KHMER DIGIT THREE"
\u17E4 "KHMER DIGIT FOUR"
\u17E5 "KHMER DIGIT FIVE"
\u17E6 "KHMER DIGIT SIX"
\u17E7 "KHMER DIGIT SEVEN"
\u17E8 "KHMER DIGIT EIGHT"
\u17E9 "KHMER DIGIT NINE"
\u17F0 "KHMER SYMBOL LEK ATTAK SON"
\u17F1 "KHMER SYMBOL LEK ATTAK MUOY"
\u17F2 "KHMER SYMBOL LEK ATTAK PII"
\u17F3 "KHMER SYMBOL LEK ATTAK BEI"
\u17F4 "KHMER SYMBOL LEK ATTAK BUON"
\u17F5 "KHMER SYMBOL LEK ATTAK PRAM"
\u17F6 "KHMER SYMBOL LEK ATTAK PRAM-MUOY"
\u17F7 "KHMER SYMBOL LEK ATTAK PRAM-PII"
\u17F8 "KHMER SYMBOL LEK ATTAK PRAM-BEI"
\u17F9 "KHMER SYMBOL LEK ATTAK PRAM-BUON"
\u1800 "MONGOLIAN BIRGA"
\u1801 "MONGOLIAN ELLIPSIS"
\u1802 "MONGOLIAN COMMA"
\u1803 "MONGOLIAN FULL STOP"
\u1804 "MONGOLIAN COLON"
\u1805 "MONGOLIAN FOUR DOTS"
\u1806 "MONGOLIAN TODO SOFT HYPHEN"
\u1807 "MONGOLIAN SIBE SYLLABLE BOUNDARY MARKER"
\u1808 "MONGOLIAN MANCHU COMMA"
\u1809 "MONGOLIAN MANCHU FULL STOP"
\u180A "MONGOLIAN NIRUGU"
\u180B "MONGOLIAN FREE VARIATION SELECTOR ONE"
\u180C "MONGOLIAN FREE VARIATION SELECTOR TWO"
\u180D "MONGOLIAN FREE VARIATION SELECTOR THREE"
\u180E "MONGOLIAN VOWEL SEPARATOR"
\u1810 "MONGOLIAN DIGIT ZERO"
\u1811 "MONGOLIAN DIGIT ONE"
\u1812 "MONGOLIAN DIGIT TWO"
\u1813 "MONGOLIAN DIGIT THREE"
\u1814 "MONGOLIAN DIGIT FOUR"
\u1815 "MONGOLIAN DIGIT FIVE"
\u1816 "MONGOLIAN DIGIT SIX"
\u1817 "MONGOLIAN DIGIT SEVEN"
\u1818 "MONGOLIAN DIGIT EIGHT"
\u1819 "MONGOLIAN DIGIT NINE"
\u1820 "MONGOLIAN LETTER A"
\u1821 "MONGOLIAN LETTER E"
\u1822 "MONGOLIAN LETTER I"
\u1823 "MONGOLIAN LETTER O"
\u1824 "MONGOLIAN LETTER U"
\u1825 "MONGOLIAN LETTER OE"
\u1826 "MONGOLIAN LETTER UE"
\u1827 "MONGOLIAN LETTER EE"
\u1828 "MONGOLIAN LETTER NA"
\u1829 "MONGOLIAN LETTER ANG"
\u182A "MONGOLIAN LETTER BA"
\u182B "MONGOLIAN LETTER PA"
\u182C "MONGOLIAN LETTER QA"
\u182D "MONGOLIAN LETTER GA"
\u182E "MONGOLIAN LETTER MA"
\u182F "MONGOLIAN LETTER LA"
\u1830 "MONGOLIAN LETTER SA"
\u1831 "MONGOLIAN LETTER SHA"
\u1832 "MONGOLIAN LETTER TA"
\u1833 "MONGOLIAN LETTER DA"
\u1834 "MONGOLIAN LETTER CHA"
\u1835 "MONGOLIAN LETTER JA"
\u1836 "MONGOLIAN LETTER YA"
\u1837 "MONGOLIAN LETTER RA"
\u1838 "MONGOLIAN LETTER WA"
\u1839 "MONGOLIAN LETTER FA"
\u183A "MONGOLIAN LETTER KA"
\u183B "MONGOLIAN LETTER KHA"
\u183C "MONGOLIAN LETTER TSA"
\u183D "MONGOLIAN LETTER ZA"
\u183E "MONGOLIAN LETTER HAA"
\u183F "MONGOLIAN LETTER ZRA"
\u1840 "MONGOLIAN LETTER LHA"
\u1841 "MONGOLIAN LETTER ZHI"
\u1842 "MONGOLIAN LETTER CHI"
\u1843 "MONGOLIAN LETTER TODO LONG VOWEL SIGN"
\u1844 "MONGOLIAN LETTER TODO E"
\u1845 "MONGOLIAN LETTER TODO I"
\u1846 "MONGOLIAN LETTER TODO O"
\u1847 "MONGOLIAN LETTER TODO U"
\u1848 "MONGOLIAN LETTER TODO OE"
\u1849 "MONGOLIAN LETTER TODO UE"
\u184A "MONGOLIAN LETTER TODO ANG"
\u184B "MONGOLIAN LETTER TODO BA"
\u184C "MONGOLIAN LETTER TODO PA"
\u184D "MONGOLIAN LETTER TODO QA"
\u184E "MONGOLIAN LETTER TODO GA"
\u184F "MONGOLIAN LETTER TODO MA"
\u1850 "MONGOLIAN LETTER TODO TA"
\u1851 "MONGOLIAN LETTER TODO DA"
\u1852 "MONGOLIAN LETTER TODO CHA"
\u1853 "MONGOLIAN LETTER TODO JA"
\u1854 "MONGOLIAN LETTER TODO TSA"
\u1855 "MONGOLIAN LETTER TODO YA"
\u1856 "MONGOLIAN LETTER TODO WA"
\u1857 "MONGOLIAN LETTER TODO KA"
\u1858 "MONGOLIAN LETTER TODO GAA"
\u1859 "MONGOLIAN LETTER TODO HAA"
\u185A "MONGOLIAN LETTER TODO JIA"
\u185B "MONGOLIAN LETTER TODO NIA"
\u185C "MONGOLIAN LETTER TODO DZA"
\u185D "MONGOLIAN LETTER SIBE E"
\u185E "MONGOLIAN LETTER SIBE I"
\u185F "MONGOLIAN LETTER SIBE IY"
\u1860 "MONGOLIAN LETTER SIBE UE"
\u1861 "MONGOLIAN LETTER SIBE U"
\u1862 "MONGOLIAN LETTER SIBE ANG"
\u1863 "MONGOLIAN LETTER SIBE KA"
\u1864 "MONGOLIAN LETTER SIBE GA"
\u1865 "MONGOLIAN LETTER SIBE HA"
\u1866 "MONGOLIAN LETTER SIBE PA"
\u1867 "MONGOLIAN LETTER SIBE SHA"
\u1868 "MONGOLIAN LETTER SIBE TA"
\u1869 "MONGOLIAN LETTER SIBE DA"
\u186A "MONGOLIAN LETTER SIBE JA"
\u186B "MONGOLIAN LETTER SIBE FA"
\u186C "MONGOLIAN LETTER SIBE GAA"
\u186D "MONGOLIAN LETTER SIBE HAA"
\u186E "MONGOLIAN LETTER SIBE TSA"
\u186F "MONGOLIAN LETTER SIBE ZA"
\u1870 "MONGOLIAN LETTER SIBE RAA"
\u1871 "MONGOLIAN LETTER SIBE CHA"
\u1872 "MONGOLIAN LETTER SIBE ZHA"
\u1873 "MONGOLIAN LETTER MANCHU I"
\u1874 "MONGOLIAN LETTER MANCHU KA"
\u1875 "MONGOLIAN LETTER MANCHU RA"
\u1876 "MONGOLIAN LETTER MANCHU FA"
\u1877 "MONGOLIAN LETTER MANCHU ZHA"
\u1880 "MONGOLIAN LETTER ALI GALI ANUSVARA ONE"
\u1881 "MONGOLIAN LETTER ALI GALI VISARGA ONE"
\u1882 "MONGOLIAN LETTER ALI GALI DAMARU"
\u1883 "MONGOLIAN LETTER ALI GALI UBADAMA"
\u1884 "MONGOLIAN LETTER ALI GALI INVERTED UBADAMA"
\u1885 "MONGOLIAN LETTER ALI GALI BALUDA"
\u1886 "MONGOLIAN LETTER ALI GALI THREE BALUDA"
\u1887 "MONGOLIAN LETTER ALI GALI A"
\u1888 "MONGOLIAN LETTER ALI GALI I"
\u1889 "MONGOLIAN LETTER ALI GALI KA"
\u188A "MONGOLIAN LETTER ALI GALI NGA"
\u188B "MONGOLIAN LETTER ALI GALI CA"
\u188C "MONGOLIAN LETTER ALI GALI TTA"
\u188D "MONGOLIAN LETTER ALI GALI TTHA"
\u188E "MONGOLIAN LETTER ALI GALI DDA"
\u188F "MONGOLIAN LETTER ALI GALI NNA"
\u1890 "MONGOLIAN LETTER ALI GALI TA"
\u1891 "MONGOLIAN LETTER ALI GALI DA"
\u1892 "MONGOLIAN LETTER ALI GALI PA"
\u1893 "MONGOLIAN LETTER ALI GALI PHA"
\u1894 "MONGOLIAN LETTER ALI GALI SSA"
\u1895 "MONGOLIAN LETTER ALI GALI ZHA"
\u1896 "MONGOLIAN LETTER ALI GALI ZA"
\u1897 "MONGOLIAN LETTER ALI GALI AH"
\u1898 "MONGOLIAN LETTER TODO ALI GALI TA"
\u1899 "MONGOLIAN LETTER TODO ALI GALI ZHA"
\u189A "MONGOLIAN LETTER MANCHU ALI GALI GHA"
\u189B "MONGOLIAN LETTER MANCHU ALI GALI NGA"
\u189C "MONGOLIAN LETTER MANCHU ALI GALI CA"
\u189D "MONGOLIAN LETTER MANCHU ALI GALI JHA"
\u189E "MONGOLIAN LETTER MANCHU ALI GALI TTA"
\u189F "MONGOLIAN LETTER MANCHU ALI GALI DDHA"
\u18A0 "MONGOLIAN LETTER MANCHU ALI GALI TA"
\u18A1 "MONGOLIAN LETTER MANCHU ALI GALI DHA"
\u18A2 "MONGOLIAN LETTER MANCHU ALI GALI SSA"
\u18A3 "MONGOLIAN LETTER MANCHU ALI GALI CYA"
\u18A4 "MONGOLIAN LETTER MANCHU ALI GALI ZHA"
\u18A5 "MONGOLIAN LETTER MANCHU ALI GALI ZA"
\u18A6 "MONGOLIAN LETTER ALI GALI HALF U"
\u18A7 "MONGOLIAN LETTER ALI GALI HALF YA"
\u18A8 "MONGOLIAN LETTER MANCHU ALI GALI BHA"
\u18A9 "MONGOLIAN LETTER ALI GALI DAGALGA"
\u18AA "MONGOLIAN LETTER MANCHU ALI GALI LHA"
\u1900 "LIMBU VOWEL-CARRIER LETTER"
\u1901 "LIMBU LETTER KA"
\u1902 "LIMBU LETTER KHA"
\u1903 "LIMBU LETTER GA"
\u1904 "LIMBU LETTER GHA"
\u1905 "LIMBU LETTER NGA"
\u1906 "LIMBU LETTER CA"
\u1907 "LIMBU LETTER CHA"
\u1908 "LIMBU LETTER JA"
\u1909 "LIMBU LETTER JHA"
\u190A "LIMBU LETTER YAN"
\u190B "LIMBU LETTER TA"
\u190C "LIMBU LETTER THA"
\u190D "LIMBU LETTER DA"
\u190E "LIMBU LETTER DHA"
\u190F "LIMBU LETTER NA"
\u1910 "LIMBU LETTER PA"
\u1911 "LIMBU LETTER PHA"
\u1912 "LIMBU LETTER BA"
\u1913 "LIMBU LETTER BHA"
\u1914 "LIMBU LETTER MA"
\u1915 "LIMBU LETTER YA"
\u1916 "LIMBU LETTER RA"
\u1917 "LIMBU LETTER LA"
\u1918 "LIMBU LETTER WA"
\u1919 "LIMBU LETTER SHA"
\u191A "LIMBU LETTER SSA"
\u191B "LIMBU LETTER SA"
\u191C "LIMBU LETTER HA"
\u1920 "LIMBU VOWEL SIGN A"
\u1921 "LIMBU VOWEL SIGN I"
\u1922 "LIMBU VOWEL SIGN U"
\u1923 "LIMBU VOWEL SIGN EE"
\u1924 "LIMBU VOWEL SIGN AI"
\u1925 "LIMBU VOWEL SIGN OO"
\u1926 "LIMBU VOWEL SIGN AU"
\u1927 "LIMBU VOWEL SIGN E"
\u1928 "LIMBU VOWEL SIGN O"
\u1929 "LIMBU SUBJOINED LETTER YA"
\u192A "LIMBU SUBJOINED LETTER RA"
\u192B "LIMBU SUBJOINED LETTER WA"
\u1930 "LIMBU SMALL LETTER KA"
\u1931 "LIMBU SMALL LETTER NGA"
\u1932 "LIMBU SMALL LETTER ANUSVARA"
\u1933 "LIMBU SMALL LETTER TA"
\u1934 "LIMBU SMALL LETTER NA"
\u1935 "LIMBU SMALL LETTER PA"
\u1936 "LIMBU SMALL LETTER MA"
\u1937 "LIMBU SMALL LETTER RA"
\u1938 "LIMBU SMALL LETTER LA"
\u1939 "LIMBU SIGN MUKPHRENG"
\u193A "LIMBU SIGN KEMPHRENG"
\u193B "LIMBU SIGN SA-I"
\u1940 "LIMBU SIGN LOO"
\u1944 "LIMBU EXCLAMATION MARK"
\u1945 "LIMBU QUESTION MARK"
\u1946 "LIMBU DIGIT ZERO"
\u1947 "LIMBU DIGIT ONE"
\u1948 "LIMBU DIGIT TWO"
\u1949 "LIMBU DIGIT THREE"
\u194A "LIMBU DIGIT FOUR"
\u194B "LIMBU DIGIT FIVE"
\u194C "LIMBU DIGIT SIX"
\u194D "LIMBU DIGIT SEVEN"
\u194E "LIMBU DIGIT EIGHT"
\u194F "LIMBU DIGIT NINE"
\u1950 "TAI LE LETTER KA"
\u1951 "TAI LE LETTER XA"
\u1952 "TAI LE LETTER NGA"
\u1953 "TAI LE LETTER TSA"
\u1954 "TAI LE LETTER SA"
\u1955 "TAI LE LETTER YA"
\u1956 "TAI LE LETTER TA"
\u1957 "TAI LE LETTER THA"
\u1958 "TAI LE LETTER LA"
\u1959 "TAI LE LETTER PA"
\u195A "TAI LE LETTER PHA"
\u195B "TAI LE LETTER MA"
\u195C "TAI LE LETTER FA"
\u195D "TAI LE LETTER VA"
\u195E "TAI LE LETTER HA"
\u195F "TAI LE LETTER QA"
\u1960 "TAI LE LETTER KHA"
\u1961 "TAI LE LETTER TSHA"
\u1962 "TAI LE LETTER NA"
\u1963 "TAI LE LETTER A"
\u1964 "TAI LE LETTER I"
\u1965 "TAI LE LETTER EE"
\u1966 "TAI LE LETTER EH"
\u1967 "TAI LE LETTER U"
\u1968 "TAI LE LETTER OO"
\u1969 "TAI LE LETTER O"
\u196A "TAI LE LETTER UE"
\u196B "TAI LE LETTER E"
\u196C "TAI LE LETTER AUE"
\u196D "TAI LE LETTER AI"
\u1970 "TAI LE LETTER TONE-2"
\u1971 "TAI LE LETTER TONE-3"
\u1972 "TAI LE LETTER TONE-4"
\u1973 "TAI LE LETTER TONE-5"
\u1974 "TAI LE LETTER TONE-6"
\u1980 "NEW TAI LUE LETTER HIGH QA"
\u1981 "NEW TAI LUE LETTER LOW QA"
\u1982 "NEW TAI LUE LETTER HIGH KA"
\u1983 "NEW TAI LUE LETTER HIGH XA"
\u1984 "NEW TAI LUE LETTER HIGH NGA"
\u1985 "NEW TAI LUE LETTER LOW KA"
\u1986 "NEW TAI LUE LETTER LOW XA"
\u1987 "NEW TAI LUE LETTER LOW NGA"
\u1988 "NEW TAI LUE LETTER HIGH TSA"
\u1989 "NEW TAI LUE LETTER HIGH SA"
\u198A "NEW TAI LUE LETTER HIGH YA"
\u198B "NEW TAI LUE LETTER LOW TSA"
\u198C "NEW TAI LUE LETTER LOW SA"
\u198D "NEW TAI LUE LETTER LOW YA"
\u198E "NEW TAI LUE LETTER HIGH TA"
\u198F "NEW TAI LUE LETTER HIGH THA"
\u1990 "NEW TAI LUE LETTER HIGH NA"
\u1991 "NEW TAI LUE LETTER LOW TA"
\u1992 "NEW TAI LUE LETTER LOW THA"
\u1993 "NEW TAI LUE LETTER LOW NA"
\u1994 "NEW TAI LUE LETTER HIGH PA"
\u1995 "NEW TAI LUE LETTER HIGH PHA"
\u1996 "NEW TAI LUE LETTER HIGH MA"
\u1997 "NEW TAI LUE LETTER LOW PA"
\u1998 "NEW TAI LUE LETTER LOW PHA"
\u1999 "NEW TAI LUE LETTER LOW MA"
\u199A "NEW TAI LUE LETTER HIGH FA"
\u199B "NEW TAI LUE LETTER HIGH VA"
\u199C "NEW TAI LUE LETTER HIGH LA"
\u199D "NEW TAI LUE LETTER LOW FA"
\u199E "NEW TAI LUE LETTER LOW VA"
\u199F "NEW TAI LUE LETTER LOW LA"
\u19A0 "NEW TAI LUE LETTER HIGH HA"
\u19A1 "NEW TAI LUE LETTER HIGH DA"
\u19A2 "NEW TAI LUE LETTER HIGH BA"
\u19A3 "NEW TAI LUE LETTER LOW HA"
\u19A4 "NEW TAI LUE LETTER LOW DA"
\u19A5 "NEW TAI LUE LETTER LOW BA"
\u19A6 "NEW TAI LUE LETTER HIGH KVA"
\u19A7 "NEW TAI LUE LETTER HIGH XVA"
\u19A8 "NEW TAI LUE LETTER LOW KVA"
\u19A9 "NEW TAI LUE LETTER LOW XVA"
\u19B0 "NEW TAI LUE VOWEL SIGN VOWEL SHORTENER"
\u19B1 "NEW TAI LUE VOWEL SIGN AA"
\u19B2 "NEW TAI LUE VOWEL SIGN II"
\u19B3 "NEW TAI LUE VOWEL SIGN U"
\u19B4 "NEW TAI LUE VOWEL SIGN UU"
\u19B5 "NEW TAI LUE VOWEL SIGN E"
\u19B6 "NEW TAI LUE VOWEL SIGN AE"
\u19B7 "NEW TAI LUE VOWEL SIGN O"
\u19B8 "NEW TAI LUE VOWEL SIGN OA"
\u19B9 "NEW TAI LUE VOWEL SIGN UE"
\u19BA "NEW TAI LUE VOWEL SIGN AY"
\u19BB "NEW TAI LUE VOWEL SIGN AAY"
\u19BC "NEW TAI LUE VOWEL SIGN UY"
\u19BD "NEW TAI LUE VOWEL SIGN OY"
\u19BE "NEW TAI LUE VOWEL SIGN OAY"
\u19BF "NEW TAI LUE VOWEL SIGN UEY"
\u19C0 "NEW TAI LUE VOWEL SIGN IY"
\u19C1 "NEW TAI LUE LETTER FINAL V"
\u19C2 "NEW TAI LUE LETTER FINAL NG"
\u19C3 "NEW TAI LUE LETTER FINAL N"
\u19C4 "NEW TAI LUE LETTER FINAL M"
\u19C5 "NEW TAI LUE LETTER FINAL K"
\u19C6 "NEW TAI LUE LETTER FINAL D"
\u19C7 "NEW TAI LUE LETTER FINAL B"
\u19C8 "NEW TAI LUE TONE MARK-1"
\u19C9 "NEW TAI LUE TONE MARK-2"
\u19D0 "NEW TAI LUE DIGIT ZERO"
\u19D1 "NEW TAI LUE DIGIT ONE"
\u19D2 "NEW TAI LUE DIGIT TWO"
\u19D3 "NEW TAI LUE DIGIT THREE"
\u19D4 "NEW TAI LUE DIGIT FOUR"
\u19D5 "NEW TAI LUE DIGIT FIVE"
\u19D6 "NEW TAI LUE DIGIT SIX"
\u19D7 "NEW TAI LUE DIGIT SEVEN"
\u19D8 "NEW TAI LUE DIGIT EIGHT"
\u19D9 "NEW TAI LUE DIGIT NINE"
\u19DE "NEW TAI LUE SIGN LAE"
\u19DF "NEW TAI LUE SIGN LAEV"
\u19E0 "KHMER SYMBOL PATHAMASAT"
\u19E1 "KHMER SYMBOL MUOY KOET"
\u19E2 "KHMER SYMBOL PII KOET"
\u19E3 "KHMER SYMBOL BEI KOET"
\u19E4 "KHMER SYMBOL BUON KOET"
\u19E5 "KHMER SYMBOL PRAM KOET"
\u19E6 "KHMER SYMBOL PRAM-MUOY KOET"
\u19E7 "KHMER SYMBOL PRAM-PII KOET"
\u19E8 "KHMER SYMBOL PRAM-BEI KOET"
\u19E9 "KHMER SYMBOL PRAM-BUON KOET"
\u19EA "KHMER SYMBOL DAP KOET"
\u19EB "KHMER SYMBOL DAP-MUOY KOET"
\u19EC "KHMER SYMBOL DAP-PII KOET"
\u19ED "KHMER SYMBOL DAP-BEI KOET"
\u19EE "KHMER SYMBOL DAP-BUON KOET"
\u19EF "KHMER SYMBOL DAP-PRAM KOET"
\u19F0 "KHMER SYMBOL TUTEYASAT"
\u19F1 "KHMER SYMBOL MUOY ROC"
\u19F2 "KHMER SYMBOL PII ROC"
\u19F3 "KHMER SYMBOL BEI ROC"
\u19F4 "KHMER SYMBOL BUON ROC"
\u19F5 "KHMER SYMBOL PRAM ROC"
\u19F6 "KHMER SYMBOL PRAM-MUOY ROC"
\u19F7 "KHMER SYMBOL PRAM-PII ROC"
\u19F8 "KHMER SYMBOL PRAM-BEI ROC"
\u19F9 "KHMER SYMBOL PRAM-BUON ROC"
\u19FA "KHMER SYMBOL DAP ROC"
\u19FB "KHMER SYMBOL DAP-MUOY ROC"
\u19FC "KHMER SYMBOL DAP-PII ROC"
\u19FD "KHMER SYMBOL DAP-BEI ROC"
\u19FE "KHMER SYMBOL DAP-BUON ROC"
\u19FF "KHMER SYMBOL DAP-PRAM ROC"
\u1A00 "BUGINESE LETTER KA"
\u1A01 "BUGINESE LETTER GA"
\u1A02 "BUGINESE LETTER NGA"
\u1A03 "BUGINESE LETTER NGKA"
\u1A04 "BUGINESE LETTER PA"
\u1A05 "BUGINESE LETTER BA"
\u1A06 "BUGINESE LETTER MA"
\u1A07 "BUGINESE LETTER MPA"
\u1A08 "BUGINESE LETTER TA"
\u1A09 "BUGINESE LETTER DA"
\u1A0A "BUGINESE LETTER NA"
\u1A0B "BUGINESE LETTER NRA"
\u1A0C "BUGINESE LETTER CA"
\u1A0D "BUGINESE LETTER JA"
\u1A0E "BUGINESE LETTER NYA"
\u1A0F "BUGINESE LETTER NYCA"
\u1A10 "BUGINESE LETTER YA"
\u1A11 "BUGINESE LETTER RA"
\u1A12 "BUGINESE LETTER LA"
\u1A13 "BUGINESE LETTER VA"
\u1A14 "BUGINESE LETTER SA"
\u1A15 "BUGINESE LETTER A"
\u1A16 "BUGINESE LETTER HA"
\u1A17 "BUGINESE VOWEL SIGN I"
\u1A18 "BUGINESE VOWEL SIGN U"
\u1A19 "BUGINESE VOWEL SIGN E"
\u1A1A "BUGINESE VOWEL SIGN O"
\u1A1B "BUGINESE VOWEL SIGN AE"
\u1A1E "BUGINESE PALLAWA"
\u1A1F "BUGINESE END OF SECTION"
\u1B00 "BALINESE SIGN ULU RICEM"
\u1B01 "BALINESE SIGN ULU CANDRA"
\u1B02 "BALINESE SIGN CECEK"
\u1B03 "BALINESE SIGN SURANG"
\u1B04 "BALINESE SIGN BISAH"
\u1B05 "BALINESE LETTER AKARA"
\u1B06 "BALINESE LETTER AKARA TEDUNG"
\u1B07 "BALINESE LETTER IKARA"
\u1B08 "BALINESE LETTER IKARA TEDUNG"
\u1B09 "BALINESE LETTER UKARA"
\u1B0A "BALINESE LETTER UKARA TEDUNG"
\u1B0B "BALINESE LETTER RA REPA"
\u1B0C "BALINESE LETTER RA REPA TEDUNG"
\u1B0D "BALINESE LETTER LA LENGA"
\u1B0E "BALINESE LETTER LA LENGA TEDUNG"
\u1B0F "BALINESE LETTER EKARA"
\u1B10 "BALINESE LETTER AIKARA"
\u1B11 "BALINESE LETTER OKARA"
\u1B12 "BALINESE LETTER OKARA TEDUNG"
\u1B13 "BALINESE LETTER KA"
\u1B14 "BALINESE LETTER KA MAHAPRANA"
\u1B15 "BALINESE LETTER GA"
\u1B16 "BALINESE LETTER GA GORA"
\u1B17 "BALINESE LETTER NGA"
\u1B18 "BALINESE LETTER CA"
\u1B19 "BALINESE LETTER CA LACA"
\u1B1A "BALINESE LETTER JA"
\u1B1B "BALINESE LETTER JA JERA"
\u1B1C "BALINESE LETTER NYA"
\u1B1D "BALINESE LETTER TA LATIK"
\u1B1E "BALINESE LETTER TA MURDA MAHAPRANA"
\u1B1F "BALINESE LETTER DA MURDA ALPAPRANA"
\u1B20 "BALINESE LETTER DA MURDA MAHAPRANA"
\u1B21 "BALINESE LETTER NA RAMBAT"
\u1B22 "BALINESE LETTER TA"
\u1B23 "BALINESE LETTER TA TAWA"
\u1B24 "BALINESE LETTER DA"
\u1B25 "BALINESE LETTER DA MADU"
\u1B26 "BALINESE LETTER NA"
\u1B27 "BALINESE LETTER PA"
\u1B28 "BALINESE LETTER PA KAPAL"
\u1B29 "BALINESE LETTER BA"
\u1B2A "BALINESE LETTER BA KEMBANG"
\u1B2B "BALINESE LETTER MA"
\u1B2C "BALINESE LETTER YA"
\u1B2D "BALINESE LETTER RA"
\u1B2E "BALINESE LETTER LA"
\u1B2F "BALINESE LETTER WA"
\u1B30 "BALINESE LETTER SA SAGA"
\u1B31 "BALINESE LETTER SA SAPA"
\u1B32 "BALINESE LETTER SA"
\u1B33 "BALINESE LETTER HA"
\u1B34 "BALINESE SIGN REREKAN"
\u1B35 "BALINESE VOWEL SIGN TEDUNG"
\u1B36 "BALINESE VOWEL SIGN ULU"
\u1B37 "BALINESE VOWEL SIGN ULU SARI"
\u1B38 "BALINESE VOWEL SIGN SUKU"
\u1B39 "BALINESE VOWEL SIGN SUKU ILUT"
\u1B3A "BALINESE VOWEL SIGN RA REPA"
\u1B3B "BALINESE VOWEL SIGN RA REPA TEDUNG"
\u1B3C "BALINESE VOWEL SIGN LA LENGA"
\u1B3D "BALINESE VOWEL SIGN LA LENGA TEDUNG"
\u1B3E "BALINESE VOWEL SIGN TALING"
\u1B3F "BALINESE VOWEL SIGN TALING REPA"
\u1B40 "BALINESE VOWEL SIGN TALING TEDUNG"
\u1B41 "BALINESE VOWEL SIGN TALING REPA TEDUNG"
\u1B42 "BALINESE VOWEL SIGN PEPET"
\u1B43 "BALINESE VOWEL SIGN PEPET TEDUNG"
\u1B44 "BALINESE ADEG ADEG"
\u1B45 "BALINESE LETTER KAF SASAK"
\u1B46 "BALINESE LETTER KHOT SASAK"
\u1B47 "BALINESE LETTER TZIR SASAK"
\u1B48 "BALINESE LETTER EF SASAK"
\u1B49 "BALINESE LETTER VE SASAK"
\u1B4A "BALINESE LETTER ZAL SASAK"
\u1B4B "BALINESE LETTER ASYURA SASAK"
\u1B50 "BALINESE DIGIT ZERO"
\u1B51 "BALINESE DIGIT ONE"
\u1B52 "BALINESE DIGIT TWO"
\u1B53 "BALINESE DIGIT THREE"
\u1B54 "BALINESE DIGIT FOUR"
\u1B55 "BALINESE DIGIT FIVE"
\u1B56 "BALINESE DIGIT SIX"
\u1B57 "BALINESE DIGIT SEVEN"
\u1B58 "BALINESE DIGIT EIGHT"
\u1B59 "BALINESE DIGIT NINE"
\u1B5A "BALINESE PANTI"
\u1B5B "BALINESE PAMADA"
\u1B5C "BALINESE WINDU"
\u1B5D "BALINESE CARIK PAMUNGKAH"
\u1B5E "BALINESE CARIK SIKI"
\u1B5F "BALINESE CARIK PAREREN"
\u1B60 "BALINESE PAMENENG"
\u1B61 "BALINESE MUSICAL SYMBOL DONG"
\u1B62 "BALINESE MUSICAL SYMBOL DENG"
\u1B63 "BALINESE MUSICAL SYMBOL DUNG"
\u1B64 "BALINESE MUSICAL SYMBOL DANG"
\u1B65 "BALINESE MUSICAL SYMBOL DANG SURANG"
\u1B66 "BALINESE MUSICAL SYMBOL DING"
\u1B67 "BALINESE MUSICAL SYMBOL DAENG"
\u1B68 "BALINESE MUSICAL SYMBOL DEUNG"
\u1B69 "BALINESE MUSICAL SYMBOL DAING"
\u1B6A "BALINESE MUSICAL SYMBOL DANG GEDE"
\u1B6B "BALINESE MUSICAL SYMBOL COMBINING TEGEH"
\u1B6C "BALINESE MUSICAL SYMBOL COMBINING ENDEP"
\u1B6D "BALINESE MUSICAL SYMBOL COMBINING KEMPUL"
\u1B6E "BALINESE MUSICAL SYMBOL COMBINING KEMPLI"
\u1B6F "BALINESE MUSICAL SYMBOL COMBINING JEGOGAN"
\u1B70 "BALINESE MUSICAL SYMBOL COMBINING KEMPUL WITH JEGOGAN"
\u1B71 "BALINESE MUSICAL SYMBOL COMBINING KEMPLI WITH JEGOGAN"
\u1B72 "BALINESE MUSICAL SYMBOL COMBINING BENDE"
\u1B73 "BALINESE MUSICAL SYMBOL COMBINING GONG"
\u1B74 "BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DUG"
\u1B75 "BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DAG"
\u1B76 "BALINESE MUSICAL SYMBOL RIGHT-HAND CLOSED TUK"
\u1B77 "BALINESE MUSICAL SYMBOL RIGHT-HAND CLOSED TAK"
\u1B78 "BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PANG"
\u1B79 "BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PUNG"
\u1B7A "BALINESE MUSICAL SYMBOL LEFT-HAND CLOSED PLAK"
\u1B7B "BALINESE MUSICAL SYMBOL LEFT-HAND CLOSED PLUK"
\u1B7C "BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PING"
\u1B80 "SUNDANESE SIGN PANYECEK"
\u1B81 "SUNDANESE SIGN PANGLAYAR"
\u1B82 "SUNDANESE SIGN PANGWISAD"
\u1B83 "SUNDANESE LETTER A"
\u1B84 "SUNDANESE LETTER I"
\u1B85 "SUNDANESE LETTER U"
\u1B86 "SUNDANESE LETTER AE"
\u1B87 "SUNDANESE LETTER O"
\u1B88 "SUNDANESE LETTER E"
\u1B89 "SUNDANESE LETTER EU"
\u1B8A "SUNDANESE LETTER KA"
\u1B8B "SUNDANESE LETTER QA"
\u1B8C "SUNDANESE LETTER GA"
\u1B8D "SUNDANESE LETTER NGA"
\u1B8E "SUNDANESE LETTER CA"
\u1B8F "SUNDANESE LETTER JA"
\u1B90 "SUNDANESE LETTER ZA"
\u1B91 "SUNDANESE LETTER NYA"
\u1B92 "SUNDANESE LETTER TA"
\u1B93 "SUNDANESE LETTER DA"
\u1B94 "SUNDANESE LETTER NA"
\u1B95 "SUNDANESE LETTER PA"
\u1B96 "SUNDANESE LETTER FA"
\u1B97 "SUNDANESE LETTER VA"
\u1B98 "SUNDANESE LETTER BA"
\u1B99 "SUNDANESE LETTER MA"
\u1B9A "SUNDANESE LETTER YA"
\u1B9B "SUNDANESE LETTER RA"
\u1B9C "SUNDANESE LETTER LA"
\u1B9D "SUNDANESE LETTER WA"
\u1B9E "SUNDANESE LETTER SA"
\u1B9F "SUNDANESE LETTER XA"
\u1BA0 "SUNDANESE LETTER HA"
\u1BA1 "SUNDANESE CONSONANT SIGN PAMINGKAL"
\u1BA2 "SUNDANESE CONSONANT SIGN PANYAKRA"
\u1BA3 "SUNDANESE CONSONANT SIGN PANYIKU"
\u1BA4 "SUNDANESE VOWEL SIGN PANGHULU"
\u1BA5 "SUNDANESE VOWEL SIGN PANYUKU"
\u1BA6 "SUNDANESE VOWEL SIGN PANAELAENG"
\u1BA7 "SUNDANESE VOWEL SIGN PANOLONG"
\u1BA8 "SUNDANESE VOWEL SIGN PAMEPET"
\u1BA9 "SUNDANESE VOWEL SIGN PANEULEUNG"
\u1BAA "SUNDANESE SIGN PAMAAEH"
\u1BAE "SUNDANESE LETTER KHA"
\u1BAF "SUNDANESE LETTER SYA"
\u1BB0 "SUNDANESE DIGIT ZERO"
\u1BB1 "SUNDANESE DIGIT ONE"
\u1BB2 "SUNDANESE DIGIT TWO"
\u1BB3 "SUNDANESE DIGIT THREE"
\u1BB4 "SUNDANESE DIGIT FOUR"
\u1BB5 "SUNDANESE DIGIT FIVE"
\u1BB6 "SUNDANESE DIGIT SIX"
\u1BB7 "SUNDANESE DIGIT SEVEN"
\u1BB8 "SUNDANESE DIGIT EIGHT"
\u1BB9 "SUNDANESE DIGIT NINE"
\u1C00 "LEPCHA LETTER KA"
\u1C01 "LEPCHA LETTER KLA"
\u1C02 "LEPCHA LETTER KHA"
\u1C03 "LEPCHA LETTER GA"
\u1C04 "LEPCHA LETTER GLA"
\u1C05 "LEPCHA LETTER NGA"
\u1C06 "LEPCHA LETTER CA"
\u1C07 "LEPCHA LETTER CHA"
\u1C08 "LEPCHA LETTER JA"
\u1C09 "LEPCHA LETTER NYA"
\u1C0A "LEPCHA LETTER TA"
\u1C0B "LEPCHA LETTER THA"
\u1C0C "LEPCHA LETTER DA"
\u1C0D "LEPCHA LETTER NA"
\u1C0E "LEPCHA LETTER PA"
\u1C0F "LEPCHA LETTER PLA"
\u1C10 "LEPCHA LETTER PHA"
\u1C11 "LEPCHA LETTER FA"
\u1C12 "LEPCHA LETTER FLA"
\u1C13 "LEPCHA LETTER BA"
\u1C14 "LEPCHA LETTER BLA"
\u1C15 "LEPCHA LETTER MA"
\u1C16 "LEPCHA LETTER MLA"
\u1C17 "LEPCHA LETTER TSA"
\u1C18 "LEPCHA LETTER TSHA"
\u1C19 "LEPCHA LETTER DZA"
\u1C1A "LEPCHA LETTER YA"
\u1C1B "LEPCHA LETTER RA"
\u1C1C "LEPCHA LETTER LA"
\u1C1D "LEPCHA LETTER HA"
\u1C1E "LEPCHA LETTER HLA"
\u1C1F "LEPCHA LETTER VA"
\u1C20 "LEPCHA LETTER SA"
\u1C21 "LEPCHA LETTER SHA"
\u1C22 "LEPCHA LETTER WA"
\u1C23 "LEPCHA LETTER A"
\u1C24 "LEPCHA SUBJOINED LETTER YA"
\u1C25 "LEPCHA SUBJOINED LETTER RA"
\u1C26 "LEPCHA VOWEL SIGN AA"
\u1C27 "LEPCHA VOWEL SIGN I"
\u1C28 "LEPCHA VOWEL SIGN O"
\u1C29 "LEPCHA VOWEL SIGN OO"
\u1C2A "LEPCHA VOWEL SIGN U"
\u1C2B "LEPCHA VOWEL SIGN UU"
\u1C2C "LEPCHA VOWEL SIGN E"
\u1C2D "LEPCHA CONSONANT SIGN K"
\u1C2E "LEPCHA CONSONANT SIGN M"
\u1C2F "LEPCHA CONSONANT SIGN L"
\u1C30 "LEPCHA CONSONANT SIGN N"
\u1C31 "LEPCHA CONSONANT SIGN P"
\u1C32 "LEPCHA CONSONANT SIGN R"
\u1C33 "LEPCHA CONSONANT SIGN T"
\u1C34 "LEPCHA CONSONANT SIGN NYIN-DO"
\u1C35 "LEPCHA CONSONANT SIGN KANG"
\u1C36 "LEPCHA SIGN RAN"
\u1C37 "LEPCHA SIGN NUKTA"
\u1C3B "LEPCHA PUNCTUATION TA-ROL"
\u1C3C "LEPCHA PUNCTUATION NYET THYOOM TA-ROL"
\u1C3D "LEPCHA PUNCTUATION CER-WA"
\u1C3E "LEPCHA PUNCTUATION TSHOOK CER-WA"
\u1C3F "LEPCHA PUNCTUATION TSHOOK"
\u1C40 "LEPCHA DIGIT ZERO"
\u1C41 "LEPCHA DIGIT ONE"
\u1C42 "LEPCHA DIGIT TWO"
\u1C43 "LEPCHA DIGIT THREE"
\u1C44 "LEPCHA DIGIT FOUR"
\u1C45 "LEPCHA DIGIT FIVE"
\u1C46 "LEPCHA DIGIT SIX"
\u1C47 "LEPCHA DIGIT SEVEN"
\u1C48 "LEPCHA DIGIT EIGHT"
\u1C49 "LEPCHA DIGIT NINE"
\u1C4D "LEPCHA LETTER TTA"
\u1C4E "LEPCHA LETTER TTHA"
\u1C4F "LEPCHA LETTER DDA"
\u1C50 "OL CHIKI DIGIT ZERO"
\u1C51 "OL CHIKI DIGIT ONE"
\u1C52 "OL CHIKI DIGIT TWO"
\u1C53 "OL CHIKI DIGIT THREE"
\u1C54 "OL CHIKI DIGIT FOUR"
\u1C55 "OL CHIKI DIGIT FIVE"
\u1C56 "OL CHIKI DIGIT SIX"
\u1C57 "OL CHIKI DIGIT SEVEN"
\u1C58 "OL CHIKI DIGIT EIGHT"
\u1C59 "OL CHIKI DIGIT NINE"
\u1C5A "OL CHIKI LETTER LA"
\u1C5B "OL CHIKI LETTER AT"
\u1C5C "OL CHIKI LETTER AG"
\u1C5D "OL CHIKI LETTER ANG"
\u1C5E "OL CHIKI LETTER AL"
\u1C5F "OL CHIKI LETTER LAA"
\u1C60 "OL CHIKI LETTER AAK"
\u1C61 "OL CHIKI LETTER AAJ"
\u1C62 "OL CHIKI LETTER AAM"
\u1C63 "OL CHIKI LETTER AAW"
\u1C64 "OL CHIKI LETTER LI"
\u1C65 "OL CHIKI LETTER IS"
\u1C66 "OL CHIKI LETTER IH"
\u1C67 "OL CHIKI LETTER INY"
\u1C68 "OL CHIKI LETTER IR"
\u1C69 "OL CHIKI LETTER LU"
\u1C6A "OL CHIKI LETTER UC"
\u1C6B "OL CHIKI LETTER UD"
\u1C6C "OL CHIKI LETTER UNN"
\u1C6D "OL CHIKI LETTER UY"
\u1C6E "OL CHIKI LETTER LE"
\u1C6F "OL CHIKI LETTER EP"
\u1C70 "OL CHIKI LETTER EDD"
\u1C71 "OL CHIKI LETTER EN"
\u1C72 "OL CHIKI LETTER ERR"
\u1C73 "OL CHIKI LETTER LO"
\u1C74 "OL CHIKI LETTER OTT"
\u1C75 "OL CHIKI LETTER OB"
\u1C76 "OL CHIKI LETTER OV"
\u1C77 "OL CHIKI LETTER OH"
\u1C78 "OL CHIKI MU TTUDDAG"
\u1C79 "OL CHIKI GAAHLAA TTUDDAAG"
\u1C7A "OL CHIKI MU-GAAHLAA TTUDDAAG"
\u1C7B "OL CHIKI RELAA"
\u1C7C "OL CHIKI PHAARKAA"
\u1C7D "OL CHIKI AHAD"
\u1C7E "OL CHIKI PUNCTUATION MUCAAD"
\u1C7F "OL CHIKI PUNCTUATION DOUBLE MUCAAD"
\u1D00 "LATIN LETTER SMALL CAPITAL A"
\u1D01 "LATIN LETTER SMALL CAPITAL AE"
\u1D02 "LATIN SMALL LETTER TURNED AE"
\u1D03 "LATIN LETTER SMALL CAPITAL BARRED B"
\u1D04 "LATIN LETTER SMALL CAPITAL C"
\u1D05 "LATIN LETTER SMALL CAPITAL D"
\u1D06 "LATIN LETTER SMALL CAPITAL ETH"
\u1D07 "LATIN LETTER SMALL CAPITAL E"
\u1D08 "LATIN SMALL LETTER TURNED OPEN E"
\u1D09 "LATIN SMALL LETTER TURNED I"
\u1D0A "LATIN LETTER SMALL CAPITAL J"
\u1D0B "LATIN LETTER SMALL CAPITAL K"
\u1D0C "LATIN LETTER SMALL CAPITAL L WITH STROKE"
\u1D0D "LATIN LETTER SMALL CAPITAL M"
\u1D0E "LATIN LETTER SMALL CAPITAL REVERSED N"
\u1D0F "LATIN LETTER SMALL CAPITAL O"
\u1D10 "LATIN LETTER SMALL CAPITAL OPEN O"
\u1D11 "LATIN SMALL LETTER SIDEWAYS O"
\u1D12 "LATIN SMALL LETTER SIDEWAYS OPEN O"
\u1D13 "LATIN SMALL LETTER SIDEWAYS O WITH STROKE"
\u1D14 "LATIN SMALL LETTER TURNED OE"
\u1D15 "LATIN LETTER SMALL CAPITAL OU"
\u1D16 "LATIN SMALL LETTER TOP HALF O"
\u1D17 "LATIN SMALL LETTER BOTTOM HALF O"
\u1D18 "LATIN LETTER SMALL CAPITAL P"
\u1D19 "LATIN LETTER SMALL CAPITAL REVERSED R"
\u1D1A "LATIN LETTER SMALL CAPITAL TURNED R"
\u1D1B "LATIN LETTER SMALL CAPITAL T"
\u1D1C "LATIN LETTER SMALL CAPITAL U"
\u1D1D "LATIN SMALL LETTER SIDEWAYS U"
\u1D1E "LATIN SMALL LETTER SIDEWAYS DIAERESIZED U"
\u1D1F "LATIN SMALL LETTER SIDEWAYS TURNED M"
\u1D20 "LATIN LETTER SMALL CAPITAL V"
\u1D21 "LATIN LETTER SMALL CAPITAL W"
\u1D22 "LATIN LETTER SMALL CAPITAL Z"
\u1D23 "LATIN LETTER SMALL CAPITAL EZH"
\u1D24 "LATIN LETTER VOICED LARYNGEAL SPIRANT"
\u1D25 "LATIN LETTER AIN"
\u1D26 "GREEK LETTER SMALL CAPITAL GAMMA"
\u1D27 "GREEK LETTER SMALL CAPITAL LAMDA"
\u1D28 "GREEK LETTER SMALL CAPITAL PI"
\u1D29 "GREEK LETTER SMALL CAPITAL RHO"
\u1D2A "GREEK LETTER SMALL CAPITAL PSI"
\u1D2B "CYRILLIC LETTER SMALL CAPITAL EL"
\u1D2C "MODIFIER LETTER CAPITAL A"
\u1D2D "MODIFIER LETTER CAPITAL AE"
\u1D2E "MODIFIER LETTER CAPITAL B"
\u1D2F "MODIFIER LETTER CAPITAL BARRED B"
\u1D30 "MODIFIER LETTER CAPITAL D"
\u1D31 "MODIFIER LETTER CAPITAL E"
\u1D32 "MODIFIER LETTER CAPITAL REVERSED E"
\u1D33 "MODIFIER LETTER CAPITAL G"
\u1D34 "MODIFIER LETTER CAPITAL H"
\u1D35 "MODIFIER LETTER CAPITAL I"
\u1D36 "MODIFIER LETTER CAPITAL J"
\u1D37 "MODIFIER LETTER CAPITAL K"
\u1D38 "MODIFIER LETTER CAPITAL L"
\u1D39 "MODIFIER LETTER CAPITAL M"
\u1D3A "MODIFIER LETTER CAPITAL N"
\u1D3B "MODIFIER LETTER CAPITAL REVERSED N"
\u1D3C "MODIFIER LETTER CAPITAL O"
\u1D3D "MODIFIER LETTER CAPITAL OU"
\u1D3E "MODIFIER LETTER CAPITAL P"
\u1D3F "MODIFIER LETTER CAPITAL R"
\u1D40 "MODIFIER LETTER CAPITAL T"
\u1D41 "MODIFIER LETTER CAPITAL U"
\u1D42 "MODIFIER LETTER CAPITAL W"
\u1D43 "MODIFIER LETTER SMALL A"
\u1D44 "MODIFIER LETTER SMALL TURNED A"
\u1D45 "MODIFIER LETTER SMALL ALPHA"
\u1D46 "MODIFIER LETTER SMALL TURNED AE"
\u1D47 "MODIFIER LETTER SMALL B"
\u1D48 "MODIFIER LETTER SMALL D"
\u1D49 "MODIFIER LETTER SMALL E"
\u1D4A "MODIFIER LETTER SMALL SCHWA"
\u1D4B "MODIFIER LETTER SMALL OPEN E"
\u1D4C "MODIFIER LETTER SMALL TURNED OPEN E"
\u1D4D "MODIFIER LETTER SMALL G"
\u1D4E "MODIFIER LETTER SMALL TURNED I"
\u1D4F "MODIFIER LETTER SMALL K"
\u1D50 "MODIFIER LETTER SMALL M"
\u1D51 "MODIFIER LETTER SMALL ENG"
\u1D52 "MODIFIER LETTER SMALL O"
\u1D53 "MODIFIER LETTER SMALL OPEN O"
\u1D54 "MODIFIER LETTER SMALL TOP HALF O"
\u1D55 "MODIFIER LETTER SMALL BOTTOM HALF O"
\u1D56 "MODIFIER LETTER SMALL P"
\u1D57 "MODIFIER LETTER SMALL T"
\u1D58 "MODIFIER LETTER SMALL U"
\u1D59 "MODIFIER LETTER SMALL SIDEWAYS U"
\u1D5A "MODIFIER LETTER SMALL TURNED M"
\u1D5B "MODIFIER LETTER SMALL V"
\u1D5C "MODIFIER LETTER SMALL AIN"
\u1D5D "MODIFIER LETTER SMALL BETA"
\u1D5E "MODIFIER LETTER SMALL GREEK GAMMA"
\u1D5F "MODIFIER LETTER SMALL DELTA"
\u1D60 "MODIFIER LETTER SMALL GREEK PHI"
\u1D61 "MODIFIER LETTER SMALL CHI"
\u1D62 "LATIN SUBSCRIPT SMALL LETTER I"
\u1D63 "LATIN SUBSCRIPT SMALL LETTER R"
\u1D64 "LATIN SUBSCRIPT SMALL LETTER U"
\u1D65 "LATIN SUBSCRIPT SMALL LETTER V"
\u1D66 "GREEK SUBSCRIPT SMALL LETTER BETA"
\u1D67 "GREEK SUBSCRIPT SMALL LETTER GAMMA"
\u1D68 "GREEK SUBSCRIPT SMALL LETTER RHO"
\u1D69 "GREEK SUBSCRIPT SMALL LETTER PHI"
\u1D6A "GREEK SUBSCRIPT SMALL LETTER CHI"
\u1D6B "LATIN SMALL LETTER UE"
\u1D6C "LATIN SMALL LETTER B WITH MIDDLE TILDE"
\u1D6D "LATIN SMALL LETTER D WITH MIDDLE TILDE"
\u1D6E "LATIN SMALL LETTER F WITH MIDDLE TILDE"
\u1D6F "LATIN SMALL LETTER M WITH MIDDLE TILDE"
\u1D70 "LATIN SMALL LETTER N WITH MIDDLE TILDE"
\u1D71 "LATIN SMALL LETTER P WITH MIDDLE TILDE"
\u1D72 "LATIN SMALL LETTER R WITH MIDDLE TILDE"
\u1D73 "LATIN SMALL LETTER R WITH FISHHOOK AND MIDDLE TILDE"
\u1D74 "LATIN SMALL LETTER S WITH MIDDLE TILDE"
\u1D75 "LATIN SMALL LETTER T WITH MIDDLE TILDE"
\u1D76 "LATIN SMALL LETTER Z WITH MIDDLE TILDE"
\u1D77 "LATIN SMALL LETTER TURNED G"
\u1D78 "MODIFIER LETTER CYRILLIC EN"
\u1D79 "LATIN SMALL LETTER INSULAR G"
\u1D7A "LATIN SMALL LETTER TH WITH STRIKETHROUGH"
\u1D7B "LATIN SMALL CAPITAL LETTER I WITH STROKE"
\u1D7C "LATIN SMALL LETTER IOTA WITH STROKE"
\u1D7D "LATIN SMALL LETTER P WITH STROKE"
\u1D7E "LATIN SMALL CAPITAL LETTER U WITH STROKE"
\u1D7F "LATIN SMALL LETTER UPSILON WITH STROKE"
\u1D80 "LATIN SMALL LETTER B WITH PALATAL HOOK"
\u1D81 "LATIN SMALL LETTER D WITH PALATAL HOOK"
\u1D82 "LATIN SMALL LETTER F WITH PALATAL HOOK"
\u1D83 "LATIN SMALL LETTER G WITH PALATAL HOOK"
\u1D84 "LATIN SMALL LETTER K WITH PALATAL HOOK"
\u1D85 "LATIN SMALL LETTER L WITH PALATAL HOOK"
\u1D86 "LATIN SMALL LETTER M WITH PALATAL HOOK"
\u1D87 "LATIN SMALL LETTER N WITH PALATAL HOOK"
\u1D88 "LATIN SMALL LETTER P WITH PALATAL HOOK"
\u1D89 "LATIN SMALL LETTER R WITH PALATAL HOOK"
\u1D8A "LATIN SMALL LETTER S WITH PALATAL HOOK"
\u1D8B "LATIN SMALL LETTER ESH WITH PALATAL HOOK"
\u1D8C "LATIN SMALL LETTER V WITH PALATAL HOOK"
\u1D8D "LATIN SMALL LETTER X WITH PALATAL HOOK"
\u1D8E "LATIN SMALL LETTER Z WITH PALATAL HOOK"
\u1D8F "LATIN SMALL LETTER A WITH RETROFLEX HOOK"
\u1D90 "LATIN SMALL LETTER ALPHA WITH RETROFLEX HOOK"
\u1D91 "LATIN SMALL LETTER D WITH HOOK AND TAIL"
\u1D92 "LATIN SMALL LETTER E WITH RETROFLEX HOOK"
\u1D93 "LATIN SMALL LETTER OPEN E WITH RETROFLEX HOOK"
\u1D94 "LATIN SMALL LETTER REVERSED OPEN E WITH RETROFLEX HOOK"
\u1D95 "LATIN SMALL LETTER SCHWA WITH RETROFLEX HOOK"
\u1D96 "LATIN SMALL LETTER I WITH RETROFLEX HOOK"
\u1D97 "LATIN SMALL LETTER OPEN O WITH RETROFLEX HOOK"
\u1D98 "LATIN SMALL LETTER ESH WITH RETROFLEX HOOK"
\u1D99 "LATIN SMALL LETTER U WITH RETROFLEX HOOK"
\u1D9A "LATIN SMALL LETTER EZH WITH RETROFLEX HOOK"
\u1D9B "MODIFIER LETTER SMALL TURNED ALPHA"
\u1D9C "MODIFIER LETTER SMALL C"
\u1D9D "MODIFIER LETTER SMALL C WITH CURL"
\u1D9E "MODIFIER LETTER SMALL ETH"
\u1D9F "MODIFIER LETTER SMALL REVERSED OPEN E"
\u1DA0 "MODIFIER LETTER SMALL F"
\u1DA1 "MODIFIER LETTER SMALL DOTLESS J WITH STROKE"
\u1DA2 "MODIFIER LETTER SMALL SCRIPT G"
\u1DA3 "MODIFIER LETTER SMALL TURNED H"
\u1DA4 "MODIFIER LETTER SMALL I WITH STROKE"
\u1DA5 "MODIFIER LETTER SMALL IOTA"
\u1DA6 "MODIFIER LETTER SMALL CAPITAL I"
\u1DA7 "MODIFIER LETTER SMALL CAPITAL I WITH STROKE"
\u1DA8 "MODIFIER LETTER SMALL J WITH CROSSED-TAIL"
\u1DA9 "MODIFIER LETTER SMALL L WITH RETROFLEX HOOK"
\u1DAA "MODIFIER LETTER SMALL L WITH PALATAL HOOK"
\u1DAB "MODIFIER LETTER SMALL CAPITAL L"
\u1DAC "MODIFIER LETTER SMALL M WITH HOOK"
\u1DAD "MODIFIER LETTER SMALL TURNED M WITH LONG LEG"
\u1DAE "MODIFIER LETTER SMALL N WITH LEFT HOOK"
\u1DAF "MODIFIER LETTER SMALL N WITH RETROFLEX HOOK"
\u1DB0 "MODIFIER LETTER SMALL CAPITAL N"
\u1DB1 "MODIFIER LETTER SMALL BARRED O"
\u1DB2 "MODIFIER LETTER SMALL PHI"
\u1DB3 "MODIFIER LETTER SMALL S WITH HOOK"
\u1DB4 "MODIFIER LETTER SMALL ESH"
\u1DB5 "MODIFIER LETTER SMALL T WITH PALATAL HOOK"
\u1DB6 "MODIFIER LETTER SMALL U BAR"
\u1DB7 "MODIFIER LETTER SMALL UPSILON"
\u1DB8 "MODIFIER LETTER SMALL CAPITAL U"
\u1DB9 "MODIFIER LETTER SMALL V WITH HOOK"
\u1DBA "MODIFIER LETTER SMALL TURNED V"
\u1DBB "MODIFIER LETTER SMALL Z"
\u1DBC "MODIFIER LETTER SMALL Z WITH RETROFLEX HOOK"
\u1DBD "MODIFIER LETTER SMALL Z WITH CURL"
\u1DBE "MODIFIER LETTER SMALL EZH"
\u1DBF "MODIFIER LETTER SMALL THETA"
\u1DC0 "COMBINING DOTTED GRAVE ACCENT"
\u1DC1 "COMBINING DOTTED ACUTE ACCENT"
\u1DC2 "COMBINING SNAKE BELOW"
\u1DC3 "COMBINING SUSPENSION MARK"
\u1DC4 "COMBINING MACRON-ACUTE"
\u1DC5 "COMBINING GRAVE-MACRON"
\u1DC6 "COMBINING MACRON-GRAVE"
\u1DC7 "COMBINING ACUTE-MACRON"
\u1DC8 "COMBINING GRAVE-ACUTE-GRAVE"
\u1DC9 "COMBINING ACUTE-GRAVE-ACUTE"
\u1DCA "COMBINING LATIN SMALL LETTER R BELOW"
\u1DCB "COMBINING BREVE-MACRON"
\u1DCC "COMBINING MACRON-BREVE"
\u1DCD "COMBINING DOUBLE CIRCUMFLEX ABOVE"
\u1DCE "COMBINING OGONEK ABOVE"
\u1DCF "COMBINING ZIGZAG BELOW"
\u1DD0 "COMBINING IS BELOW"
\u1DD1 "COMBINING UR ABOVE"
\u1DD2 "COMBINING US ABOVE"
\u1DD3 "COMBINING LATIN SMALL LETTER FLATTENED OPEN A ABOVE"
\u1DD4 "COMBINING LATIN SMALL LETTER AE"
\u1DD5 "COMBINING LATIN SMALL LETTER AO"
\u1DD6 "COMBINING LATIN SMALL LETTER AV"
\u1DD7 "COMBINING LATIN SMALL LETTER C CEDILLA"
\u1DD8 "COMBINING LATIN SMALL LETTER INSULAR D"
\u1DD9 "COMBINING LATIN SMALL LETTER ETH"
\u1DDA "COMBINING LATIN SMALL LETTER G"
\u1DDB "COMBINING LATIN LETTER SMALL CAPITAL G"
\u1DDC "COMBINING LATIN SMALL LETTER K"
\u1DDD "COMBINING LATIN SMALL LETTER L"
\u1DDE "COMBINING LATIN LETTER SMALL CAPITAL L"
\u1DDF "COMBINING LATIN LETTER SMALL CAPITAL M"
\u1DE0 "COMBINING LATIN SMALL LETTER N"
\u1DE1 "COMBINING LATIN LETTER SMALL CAPITAL N"
\u1DE2 "COMBINING LATIN LETTER SMALL CAPITAL R"
\u1DE3 "COMBINING LATIN SMALL LETTER R ROTUNDA"
\u1DE4 "COMBINING LATIN SMALL LETTER S"
\u1DE5 "COMBINING LATIN SMALL LETTER LONG S"
\u1DE6 "COMBINING LATIN SMALL LETTER Z"
\u1DFE "COMBINING LEFT ARROWHEAD ABOVE"
\u1DFF "COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW"
\u1E00 "LATIN CAPITAL LETTER A WITH RING BELOW"
\u1E01 "LATIN SMALL LETTER A WITH RING BELOW"
\u1E02 "LATIN CAPITAL LETTER B WITH DOT ABOVE"
\u1E03 "LATIN SMALL LETTER B WITH DOT ABOVE"
\u1E04 "LATIN CAPITAL LETTER B WITH DOT BELOW"
\u1E05 "LATIN SMALL LETTER B WITH DOT BELOW"
\u1E06 "LATIN CAPITAL LETTER B WITH LINE BELOW"
\u1E07 "LATIN SMALL LETTER B WITH LINE BELOW"
\u1E08 "LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE"
\u1E09 "LATIN SMALL LETTER C WITH CEDILLA AND ACUTE"
\u1E0A "LATIN CAPITAL LETTER D WITH DOT ABOVE"
\u1E0B "LATIN SMALL LETTER D WITH DOT ABOVE"
\u1E0C "LATIN CAPITAL LETTER D WITH DOT BELOW"
\u1E0D "LATIN SMALL LETTER D WITH DOT BELOW"
\u1E0E "LATIN CAPITAL LETTER D WITH LINE BELOW"
\u1E0F "LATIN SMALL LETTER D WITH LINE BELOW"
\u1E10 "LATIN CAPITAL LETTER D WITH CEDILLA"
\u1E11 "LATIN SMALL LETTER D WITH CEDILLA"
\u1E12 "LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW"
\u1E13 "LATIN SMALL LETTER D WITH CIRCUMFLEX BELOW"
\u1E14 "LATIN CAPITAL LETTER E WITH MACRON AND GRAVE"
\u1E15 "LATIN SMALL LETTER E WITH MACRON AND GRAVE"
\u1E16 "LATIN CAPITAL LETTER E WITH MACRON AND ACUTE"
\u1E17 "LATIN SMALL LETTER E WITH MACRON AND ACUTE"
\u1E18 "LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW"
\u1E19 "LATIN SMALL LETTER E WITH CIRCUMFLEX BELOW"
\u1E1A "LATIN CAPITAL LETTER E WITH TILDE BELOW"
\u1E1B "LATIN SMALL LETTER E WITH TILDE BELOW"
\u1E1C "LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE"
\u1E1D "LATIN SMALL LETTER E WITH CEDILLA AND BREVE"
\u1E1E "LATIN CAPITAL LETTER F WITH DOT ABOVE"
\u1E1F "LATIN SMALL LETTER F WITH DOT ABOVE"
\u1E20 "LATIN CAPITAL LETTER G WITH MACRON"
\u1E21 "LATIN SMALL LETTER G WITH MACRON"
\u1E22 "LATIN CAPITAL LETTER H WITH DOT ABOVE"
\u1E23 "LATIN SMALL LETTER H WITH DOT ABOVE"
\u1E24 "LATIN CAPITAL LETTER H WITH DOT BELOW"
\u1E25 "LATIN SMALL LETTER H WITH DOT BELOW"
\u1E26 "LATIN CAPITAL LETTER H WITH DIAERESIS"
\u1E27 "LATIN SMALL LETTER H WITH DIAERESIS"
\u1E28 "LATIN CAPITAL LETTER H WITH CEDILLA"
\u1E29 "LATIN SMALL LETTER H WITH CEDILLA"
\u1E2A "LATIN CAPITAL LETTER H WITH BREVE BELOW"
\u1E2B "LATIN SMALL LETTER H WITH BREVE BELOW"
\u1E2C "LATIN CAPITAL LETTER I WITH TILDE BELOW"
\u1E2D "LATIN SMALL LETTER I WITH TILDE BELOW"
\u1E2E "LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE"
\u1E2F "LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE"
\u1E30 "LATIN CAPITAL LETTER K WITH ACUTE"
\u1E31 "LATIN SMALL LETTER K WITH ACUTE"
\u1E32 "LATIN CAPITAL LETTER K WITH DOT BELOW"
\u1E33 "LATIN SMALL LETTER K WITH DOT BELOW"
\u1E34 "LATIN CAPITAL LETTER K WITH LINE BELOW"
\u1E35 "LATIN SMALL LETTER K WITH LINE BELOW"
\u1E36 "LATIN CAPITAL LETTER L WITH DOT BELOW"
\u1E37 "LATIN SMALL LETTER L WITH DOT BELOW"
\u1E38 "LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON"
\u1E39 "LATIN SMALL LETTER L WITH DOT BELOW AND MACRON"
\u1E3A "LATIN CAPITAL LETTER L WITH LINE BELOW"
\u1E3B "LATIN SMALL LETTER L WITH LINE BELOW"
\u1E3C "LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW"
\u1E3D "LATIN SMALL LETTER L WITH CIRCUMFLEX BELOW"
\u1E3E "LATIN CAPITAL LETTER M WITH ACUTE"
\u1E3F "LATIN SMALL LETTER M WITH ACUTE"
\u1E40 "LATIN CAPITAL LETTER M WITH DOT ABOVE"
\u1E41 "LATIN SMALL LETTER M WITH DOT ABOVE"
\u1E42 "LATIN CAPITAL LETTER M WITH DOT BELOW"
\u1E43 "LATIN SMALL LETTER M WITH DOT BELOW"
\u1E44 "LATIN CAPITAL LETTER N WITH DOT ABOVE"
\u1E45 "LATIN SMALL LETTER N WITH DOT ABOVE"
\u1E46 "LATIN CAPITAL LETTER N WITH DOT BELOW"
\u1E47 "LATIN SMALL LETTER N WITH DOT BELOW"
\u1E48 "LATIN CAPITAL LETTER N WITH LINE BELOW"
\u1E49 "LATIN SMALL LETTER N WITH LINE BELOW"
\u1E4A "LATIN CAPITAL LETTER N WITH CIRCUMFLEX BELOW"
\u1E4B "LATIN SMALL LETTER N WITH CIRCUMFLEX BELOW"
\u1E4C "LATIN CAPITAL LETTER O WITH TILDE AND ACUTE"
\u1E4D "LATIN SMALL LETTER O WITH TILDE AND ACUTE"
\u1E4E "LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS"
\u1E4F "LATIN SMALL LETTER O WITH TILDE AND DIAERESIS"
\u1E50 "LATIN CAPITAL LETTER O WITH MACRON AND GRAVE"
\u1E51 "LATIN SMALL LETTER O WITH MACRON AND GRAVE"
\u1E52 "LATIN CAPITAL LETTER O WITH MACRON AND ACUTE"
\u1E53 "LATIN SMALL LETTER O WITH MACRON AND ACUTE"
\u1E54 "LATIN CAPITAL LETTER P WITH ACUTE"
\u1E55 "LATIN SMALL LETTER P WITH ACUTE"
\u1E56 "LATIN CAPITAL LETTER P WITH DOT ABOVE"
\u1E57 "LATIN SMALL LETTER P WITH DOT ABOVE"
\u1E58 "LATIN CAPITAL LETTER R WITH DOT ABOVE"
\u1E59 "LATIN SMALL LETTER R WITH DOT ABOVE"
\u1E5A "LATIN CAPITAL LETTER R WITH DOT BELOW"
\u1E5B "LATIN SMALL LETTER R WITH DOT BELOW"
\u1E5C "LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON"
\u1E5D "LATIN SMALL LETTER R WITH DOT BELOW AND MACRON"
\u1E5E "LATIN CAPITAL LETTER R WITH LINE BELOW"
\u1E5F "LATIN SMALL LETTER R WITH LINE BELOW"
\u1E60 "LATIN CAPITAL LETTER S WITH DOT ABOVE"
\u1E61 "LATIN SMALL LETTER S WITH DOT ABOVE"
\u1E62 "LATIN CAPITAL LETTER S WITH DOT BELOW"
\u1E63 "LATIN SMALL LETTER S WITH DOT BELOW"
\u1E64 "LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE"
\u1E65 "LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE"
\u1E66 "LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE"
\u1E67 "LATIN SMALL LETTER S WITH CARON AND DOT ABOVE"
\u1E68 "LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE"
\u1E69 "LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE"
\u1E6A "LATIN CAPITAL LETTER T WITH DOT ABOVE"
\u1E6B "LATIN SMALL LETTER T WITH DOT ABOVE"
\u1E6C "LATIN CAPITAL LETTER T WITH DOT BELOW"
\u1E6D "LATIN SMALL LETTER T WITH DOT BELOW"
\u1E6E "LATIN CAPITAL LETTER T WITH LINE BELOW"
\u1E6F "LATIN SMALL LETTER T WITH LINE BELOW"
\u1E70 "LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW"
\u1E71 "LATIN SMALL LETTER T WITH CIRCUMFLEX BELOW"
\u1E72 "LATIN CAPITAL LETTER U WITH DIAERESIS BELOW"
\u1E73 "LATIN SMALL LETTER U WITH DIAERESIS BELOW"
\u1E74 "LATIN CAPITAL LETTER U WITH TILDE BELOW"
\u1E75 "LATIN SMALL LETTER U WITH TILDE BELOW"
\u1E76 "LATIN CAPITAL LETTER U WITH CIRCUMFLEX BELOW"
\u1E77 "LATIN SMALL LETTER U WITH CIRCUMFLEX BELOW"
\u1E78 "LATIN CAPITAL LETTER U WITH TILDE AND ACUTE"
\u1E79 "LATIN SMALL LETTER U WITH TILDE AND ACUTE"
\u1E7A "LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS"
\u1E7B "LATIN SMALL LETTER U WITH MACRON AND DIAERESIS"
\u1E7C "LATIN CAPITAL LETTER V WITH TILDE"
\u1E7D "LATIN SMALL LETTER V WITH TILDE"
\u1E7E "LATIN CAPITAL LETTER V WITH DOT BELOW"
\u1E7F "LATIN SMALL LETTER V WITH DOT BELOW"
\u1E80 "LATIN CAPITAL LETTER W WITH GRAVE"
\u1E81 "LATIN SMALL LETTER W WITH GRAVE"
\u1E82 "LATIN CAPITAL LETTER W WITH ACUTE"
\u1E83 "LATIN SMALL LETTER W WITH ACUTE"
\u1E84 "LATIN CAPITAL LETTER W WITH DIAERESIS"
\u1E85 "LATIN SMALL LETTER W WITH DIAERESIS"
\u1E86 "LATIN CAPITAL LETTER W WITH DOT ABOVE"
\u1E87 "LATIN SMALL LETTER W WITH DOT ABOVE"
\u1E88 "LATIN CAPITAL LETTER W WITH DOT BELOW"
\u1E89 "LATIN SMALL LETTER W WITH DOT BELOW"
\u1E8A "LATIN CAPITAL LETTER X WITH DOT ABOVE"
\u1E8B "LATIN SMALL LETTER X WITH DOT ABOVE"
\u1E8C "LATIN CAPITAL LETTER X WITH DIAERESIS"
\u1E8D "LATIN SMALL LETTER X WITH DIAERESIS"
\u1E8E "LATIN CAPITAL LETTER Y WITH DOT ABOVE"
\u1E8F "LATIN SMALL LETTER Y WITH DOT ABOVE"
\u1E90 "LATIN CAPITAL LETTER Z WITH CIRCUMFLEX"
\u1E91 "LATIN SMALL LETTER Z WITH CIRCUMFLEX"
\u1E92 "LATIN CAPITAL LETTER Z WITH DOT BELOW"
\u1E93 "LATIN SMALL LETTER Z WITH DOT BELOW"
\u1E94 "LATIN CAPITAL LETTER Z WITH LINE BELOW"
\u1E95 "LATIN SMALL LETTER Z WITH LINE BELOW"
\u1E96 "LATIN SMALL LETTER H WITH LINE BELOW"
\u1E97 "LATIN SMALL LETTER T WITH DIAERESIS"
\u1E98 "LATIN SMALL LETTER W WITH RING ABOVE"
\u1E99 "LATIN SMALL LETTER Y WITH RING ABOVE"
\u1E9A "LATIN SMALL LETTER A WITH RIGHT HALF RING"
\u1E9B "LATIN SMALL LETTER LONG S WITH DOT ABOVE"
\u1E9C "LATIN SMALL LETTER LONG S WITH DIAGONAL STROKE"
\u1E9D "LATIN SMALL LETTER LONG S WITH HIGH STROKE"
\u1E9E "LATIN CAPITAL LETTER SHARP S"
\u1E9F "LATIN SMALL LETTER DELTA"
\u1EA0 "LATIN CAPITAL LETTER A WITH DOT BELOW"
\u1EA1 "LATIN SMALL LETTER A WITH DOT BELOW"
\u1EA2 "LATIN CAPITAL LETTER A WITH HOOK ABOVE"
\u1EA3 "LATIN SMALL LETTER A WITH HOOK ABOVE"
\u1EA4 "LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE"
\u1EA5 "LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE"
\u1EA6 "LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE"
\u1EA7 "LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE"
\u1EA8 "LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE"
\u1EA9 "LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE"
\u1EAA "LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE"
\u1EAB "LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE"
\u1EAC "LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW"
\u1EAD "LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW"
\u1EAE "LATIN CAPITAL LETTER A WITH BREVE AND ACUTE"
\u1EAF "LATIN SMALL LETTER A WITH BREVE AND ACUTE"
\u1EB0 "LATIN CAPITAL LETTER A WITH BREVE AND GRAVE"
\u1EB1 "LATIN SMALL LETTER A WITH BREVE AND GRAVE"
\u1EB2 "LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE"
\u1EB3 "LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE"
\u1EB4 "LATIN CAPITAL LETTER A WITH BREVE AND TILDE"
\u1EB5 "LATIN SMALL LETTER A WITH BREVE AND TILDE"
\u1EB6 "LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW"
\u1EB7 "LATIN SMALL LETTER A WITH BREVE AND DOT BELOW"
\u1EB8 "LATIN CAPITAL LETTER E WITH DOT BELOW"
\u1EB9 "LATIN SMALL LETTER E WITH DOT BELOW"
\u1EBA "LATIN CAPITAL LETTER E WITH HOOK ABOVE"
\u1EBB "LATIN SMALL LETTER E WITH HOOK ABOVE"
\u1EBC "LATIN CAPITAL LETTER E WITH TILDE"
\u1EBD "LATIN SMALL LETTER E WITH TILDE"
\u1EBE "LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE"
\u1EBF "LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE"
\u1EC0 "LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE"
\u1EC1 "LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE"
\u1EC2 "LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE"
\u1EC3 "LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE"
\u1EC4 "LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE"
\u1EC5 "LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE"
\u1EC6 "LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW"
\u1EC7 "LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW"
\u1EC8 "LATIN CAPITAL LETTER I WITH HOOK ABOVE"
\u1EC9 "LATIN SMALL LETTER I WITH HOOK ABOVE"
\u1ECA "LATIN CAPITAL LETTER I WITH DOT BELOW"
\u1ECB "LATIN SMALL LETTER I WITH DOT BELOW"
\u1ECC "LATIN CAPITAL LETTER O WITH DOT BELOW"
\u1ECD "LATIN SMALL LETTER O WITH DOT BELOW"
\u1ECE "LATIN CAPITAL LETTER O WITH HOOK ABOVE"
\u1ECF "LATIN SMALL LETTER O WITH HOOK ABOVE"
\u1ED0 "LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE"
\u1ED1 "LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE"
\u1ED2 "LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE"
\u1ED3 "LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE"
\u1ED4 "LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE"
\u1ED5 "LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE"
\u1ED6 "LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE"
\u1ED7 "LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE"
\u1ED8 "LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW"
\u1ED9 "LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW"
\u1EDA "LATIN CAPITAL LETTER O WITH HORN AND ACUTE"
\u1EDB "LATIN SMALL LETTER O WITH HORN AND ACUTE"
\u1EDC "LATIN CAPITAL LETTER O WITH HORN AND GRAVE"
\u1EDD "LATIN SMALL LETTER O WITH HORN AND GRAVE"
\u1EDE "LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE"
\u1EDF "LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE"
\u1EE0 "LATIN CAPITAL LETTER O WITH HORN AND TILDE"
\u1EE1 "LATIN SMALL LETTER O WITH HORN AND TILDE"
\u1EE2 "LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW"
\u1EE3 "LATIN SMALL LETTER O WITH HORN AND DOT BELOW"
\u1EE4 "LATIN CAPITAL LETTER U WITH DOT BELOW"
\u1EE5 "LATIN SMALL LETTER U WITH DOT BELOW"
\u1EE6 "LATIN CAPITAL LETTER U WITH HOOK ABOVE"
\u1EE7 "LATIN SMALL LETTER U WITH HOOK ABOVE"
\u1EE8 "LATIN CAPITAL LETTER U WITH HORN AND ACUTE"
\u1EE9 "LATIN SMALL LETTER U WITH HORN AND ACUTE"
\u1EEA "LATIN CAPITAL LETTER U WITH HORN AND GRAVE"
\u1EEB "LATIN SMALL LETTER U WITH HORN AND GRAVE"
\u1EEC "LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE"
\u1EED "LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE"
\u1EEE "LATIN CAPITAL LETTER U WITH HORN AND TILDE"
\u1EEF "LATIN SMALL LETTER U WITH HORN AND TILDE"
\u1EF0 "LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW"
\u1EF1 "LATIN SMALL LETTER U WITH HORN AND DOT BELOW"
\u1EF2 "LATIN CAPITAL LETTER Y WITH GRAVE"
\u1EF3 "LATIN SMALL LETTER Y WITH GRAVE"
\u1EF4 "LATIN CAPITAL LETTER Y WITH DOT BELOW"
\u1EF5 "LATIN SMALL LETTER Y WITH DOT BELOW"
\u1EF6 "LATIN CAPITAL LETTER Y WITH HOOK ABOVE"
\u1EF7 "LATIN SMALL LETTER Y WITH HOOK ABOVE"
\u1EF8 "LATIN CAPITAL LETTER Y WITH TILDE"
\u1EF9 "LATIN SMALL LETTER Y WITH TILDE"
\u1EFA "LATIN CAPITAL LETTER MIDDLE-WELSH LL"
\u1EFB "LATIN SMALL LETTER MIDDLE-WELSH LL"
\u1EFC "LATIN CAPITAL LETTER MIDDLE-WELSH V"
\u1EFD "LATIN SMALL LETTER MIDDLE-WELSH V"
\u1EFE "LATIN CAPITAL LETTER Y WITH LOOP"
\u1EFF "LATIN SMALL LETTER Y WITH LOOP"
\u1F00 "GREEK SMALL LETTER ALPHA WITH PSILI"
\u1F01 "GREEK SMALL LETTER ALPHA WITH DASIA"
\u1F02 "GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA"
\u1F03 "GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA"
\u1F04 "GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA"
\u1F05 "GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA"
\u1F06 "GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI"
\u1F07 "GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI"
\u1F08 "GREEK CAPITAL LETTER ALPHA WITH PSILI"
\u1F09 "GREEK CAPITAL LETTER ALPHA WITH DASIA"
\u1F0A "GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA"
\u1F0B "GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA"
\u1F0C "GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA"
\u1F0D "GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA"
\u1F0E "GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI"
\u1F0F "GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI"
\u1F10 "GREEK SMALL LETTER EPSILON WITH PSILI"
\u1F11 "GREEK SMALL LETTER EPSILON WITH DASIA"
\u1F12 "GREEK SMALL LETTER EPSILON WITH PSILI AND VARIA"
\u1F13 "GREEK SMALL LETTER EPSILON WITH DASIA AND VARIA"
\u1F14 "GREEK SMALL LETTER EPSILON WITH PSILI AND OXIA"
\u1F15 "GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA"
\u1F18 "GREEK CAPITAL LETTER EPSILON WITH PSILI"
\u1F19 "GREEK CAPITAL LETTER EPSILON WITH DASIA"
\u1F1A "GREEK CAPITAL LETTER EPSILON WITH PSILI AND VARIA"
\u1F1B "GREEK CAPITAL LETTER EPSILON WITH DASIA AND VARIA"
\u1F1C "GREEK CAPITAL LETTER EPSILON WITH PSILI AND OXIA"
\u1F1D "GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA"
\u1F20 "GREEK SMALL LETTER ETA WITH PSILI"
\u1F21 "GREEK SMALL LETTER ETA WITH DASIA"
\u1F22 "GREEK SMALL LETTER ETA WITH PSILI AND VARIA"
\u1F23 "GREEK SMALL LETTER ETA WITH DASIA AND VARIA"
\u1F24 "GREEK SMALL LETTER ETA WITH PSILI AND OXIA"
\u1F25 "GREEK SMALL LETTER ETA WITH DASIA AND OXIA"
\u1F26 "GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI"
\u1F27 "GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI"
\u1F28 "GREEK CAPITAL LETTER ETA WITH PSILI"
\u1F29 "GREEK CAPITAL LETTER ETA WITH DASIA"
\u1F2A "GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA"
\u1F2B "GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA"
\u1F2C "GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA"
\u1F2D "GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA"
\u1F2E "GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI"
\u1F2F "GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI"
\u1F30 "GREEK SMALL LETTER IOTA WITH PSILI"
\u1F31 "GREEK SMALL LETTER IOTA WITH DASIA"
\u1F32 "GREEK SMALL LETTER IOTA WITH PSILI AND VARIA"
\u1F33 "GREEK SMALL LETTER IOTA WITH DASIA AND VARIA"
\u1F34 "GREEK SMALL LETTER IOTA WITH PSILI AND OXIA"
\u1F35 "GREEK SMALL LETTER IOTA WITH DASIA AND OXIA"
\u1F36 "GREEK SMALL LETTER IOTA WITH PSILI AND PERISPOMENI"
\u1F37 "GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI"
\u1F38 "GREEK CAPITAL LETTER IOTA WITH PSILI"
\u1F39 "GREEK CAPITAL LETTER IOTA WITH DASIA"
\u1F3A "GREEK CAPITAL LETTER IOTA WITH PSILI AND VARIA"
\u1F3B "GREEK CAPITAL LETTER IOTA WITH DASIA AND VARIA"
\u1F3C "GREEK CAPITAL LETTER IOTA WITH PSILI AND OXIA"
\u1F3D "GREEK CAPITAL LETTER IOTA WITH DASIA AND OXIA"
\u1F3E "GREEK CAPITAL LETTER IOTA WITH PSILI AND PERISPOMENI"
\u1F3F "GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI"
\u1F40 "GREEK SMALL LETTER OMICRON WITH PSILI"
\u1F41 "GREEK SMALL LETTER OMICRON WITH DASIA"
\u1F42 "GREEK SMALL LETTER OMICRON WITH PSILI AND VARIA"
\u1F43 "GREEK SMALL LETTER OMICRON WITH DASIA AND VARIA"
\u1F44 "GREEK SMALL LETTER OMICRON WITH PSILI AND OXIA"
\u1F45 "GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA"
\u1F48 "GREEK CAPITAL LETTER OMICRON WITH PSILI"
\u1F49 "GREEK CAPITAL LETTER OMICRON WITH DASIA"
\u1F4A "GREEK CAPITAL LETTER OMICRON WITH PSILI AND VARIA"
\u1F4B "GREEK CAPITAL LETTER OMICRON WITH DASIA AND VARIA"
\u1F4C "GREEK CAPITAL LETTER OMICRON WITH PSILI AND OXIA"
\u1F4D "GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA"
\u1F50 "GREEK SMALL LETTER UPSILON WITH PSILI"
\u1F51 "GREEK SMALL LETTER UPSILON WITH DASIA"
\u1F52 "GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA"
\u1F53 "GREEK SMALL LETTER UPSILON WITH DASIA AND VARIA"
\u1F54 "GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA"
\u1F55 "GREEK SMALL LETTER UPSILON WITH DASIA AND OXIA"
\u1F56 "GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI"
\u1F57 "GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI"
\u1F59 "GREEK CAPITAL LETTER UPSILON WITH DASIA"
\u1F5B "GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA"
\u1F5D "GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA"
\u1F5F "GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI"
\u1F60 "GREEK SMALL LETTER OMEGA WITH PSILI"
\u1F61 "GREEK SMALL LETTER OMEGA WITH DASIA"
\u1F62 "GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA"
\u1F63 "GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA"
\u1F64 "GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA"
\u1F65 "GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA"
\u1F66 "GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI"
\u1F67 "GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI"
\u1F68 "GREEK CAPITAL LETTER OMEGA WITH PSILI"
\u1F69 "GREEK CAPITAL LETTER OMEGA WITH DASIA"
\u1F6A "GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA"
\u1F6B "GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA"
\u1F6C "GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA"
\u1F6D "GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA"
\u1F6E "GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI"
\u1F6F "GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI"
\u1F70 "GREEK SMALL LETTER ALPHA WITH VARIA"
\u1F71 "GREEK SMALL LETTER ALPHA WITH OXIA"
\u1F72 "GREEK SMALL LETTER EPSILON WITH VARIA"
\u1F73 "GREEK SMALL LETTER EPSILON WITH OXIA"
\u1F74 "GREEK SMALL LETTER ETA WITH VARIA"
\u1F75 "GREEK SMALL LETTER ETA WITH OXIA"
\u1F76 "GREEK SMALL LETTER IOTA WITH VARIA"
\u1F77 "GREEK SMALL LETTER IOTA WITH OXIA"
\u1F78 "GREEK SMALL LETTER OMICRON WITH VARIA"
\u1F79 "GREEK SMALL LETTER OMICRON WITH OXIA"
\u1F7A "GREEK SMALL LETTER UPSILON WITH VARIA"
\u1F7B "GREEK SMALL LETTER UPSILON WITH OXIA"
\u1F7C "GREEK SMALL LETTER OMEGA WITH VARIA"
\u1F7D "GREEK SMALL LETTER OMEGA WITH OXIA"
\u1F80 "GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI"
\u1F81 "GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI"
\u1F82 "GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI"
\u1F83 "GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI"
\u1F84 "GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI"
\u1F85 "GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI"
\u1F86 "GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI"
\u1F87 "GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI"
\u1F88 "GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI"
\u1F89 "GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI"
\u1F8A "GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI"
\u1F8B "GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI"
\u1F8C "GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI"
\u1F8D "GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI"
\u1F8E "GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI"
\u1F8F "GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI"
\u1F90 "GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI"
\u1F91 "GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI"
\u1F92 "GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI"
\u1F93 "GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI"
\u1F94 "GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI"
\u1F95 "GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI"
\u1F96 "GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI"
\u1F97 "GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI"
\u1F98 "GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI"
\u1F99 "GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI"
\u1F9A "GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI"
\u1F9B "GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI"
\u1F9C "GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI"
\u1F9D "GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI"
\u1F9E "GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI"
\u1F9F "GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI"
\u1FA0 "GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI"
\u1FA1 "GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI"
\u1FA2 "GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI"
\u1FA3 "GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI"
\u1FA4 "GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI"
\u1FA5 "GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI"
\u1FA6 "GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI"
\u1FA7 "GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI"
\u1FA8 "GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI"
\u1FA9 "GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI"
\u1FAA "GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI"
\u1FAB "GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI"
\u1FAC "GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI"
\u1FAD "GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI"
\u1FAE "GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI"
\u1FAF "GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI"
\u1FB0 "GREEK SMALL LETTER ALPHA WITH VRACHY"
\u1FB1 "GREEK SMALL LETTER ALPHA WITH MACRON"
\u1FB2 "GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI"
\u1FB3 "GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI"
\u1FB4 "GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI"
\u1FB6 "GREEK SMALL LETTER ALPHA WITH PERISPOMENI"
\u1FB7 "GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI"
\u1FB8 "GREEK CAPITAL LETTER ALPHA WITH VRACHY"
\u1FB9 "GREEK CAPITAL LETTER ALPHA WITH MACRON"
\u1FBA "GREEK CAPITAL LETTER ALPHA WITH VARIA"
\u1FBB "GREEK CAPITAL LETTER ALPHA WITH OXIA"
\u1FBC "GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI"
\u1FBD "GREEK KORONIS"
\u1FBE "GREEK PROSGEGRAMMENI"
\u1FBF "GREEK PSILI"
\u1FC0 "GREEK PERISPOMENI"
\u1FC1 "GREEK DIALYTIKA AND PERISPOMENI"
\u1FC2 "GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI"
\u1FC3 "GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI"
\u1FC4 "GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI"
\u1FC6 "GREEK SMALL LETTER ETA WITH PERISPOMENI"
\u1FC7 "GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI"
\u1FC8 "GREEK CAPITAL LETTER EPSILON WITH VARIA"
\u1FC9 "GREEK CAPITAL LETTER EPSILON WITH OXIA"
\u1FCA "GREEK CAPITAL LETTER ETA WITH VARIA"
\u1FCB "GREEK CAPITAL LETTER ETA WITH OXIA"
\u1FCC "GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI"
\u1FCD "GREEK PSILI AND VARIA"
\u1FCE "GREEK PSILI AND OXIA"
\u1FCF "GREEK PSILI AND PERISPOMENI"
\u1FD0 "GREEK SMALL LETTER IOTA WITH VRACHY"
\u1FD1 "GREEK SMALL LETTER IOTA WITH MACRON"
\u1FD2 "GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA"
\u1FD3 "GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA"
\u1FD6 "GREEK SMALL LETTER IOTA WITH PERISPOMENI"
\u1FD7 "GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI"
\u1FD8 "GREEK CAPITAL LETTER IOTA WITH VRACHY"
\u1FD9 "GREEK CAPITAL LETTER IOTA WITH MACRON"
\u1FDA "GREEK CAPITAL LETTER IOTA WITH VARIA"
\u1FDB "GREEK CAPITAL LETTER IOTA WITH OXIA"
\u1FDD "GREEK DASIA AND VARIA"
\u1FDE "GREEK DASIA AND OXIA"
\u1FDF "GREEK DASIA AND PERISPOMENI"
\u1FE0 "GREEK SMALL LETTER UPSILON WITH VRACHY"
\u1FE1 "GREEK SMALL LETTER UPSILON WITH MACRON"
\u1FE2 "GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA"
\u1FE3 "GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA"
\u1FE4 "GREEK SMALL LETTER RHO WITH PSILI"
\u1FE5 "GREEK SMALL LETTER RHO WITH DASIA"
\u1FE6 "GREEK SMALL LETTER UPSILON WITH PERISPOMENI"
\u1FE7 "GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI"
\u1FE8 "GREEK CAPITAL LETTER UPSILON WITH VRACHY"
\u1FE9 "GREEK CAPITAL LETTER UPSILON WITH MACRON"
\u1FEA "GREEK CAPITAL LETTER UPSILON WITH VARIA"
\u1FEB "GREEK CAPITAL LETTER UPSILON WITH OXIA"
\u1FEC "GREEK CAPITAL LETTER RHO WITH DASIA"
\u1FED "GREEK DIALYTIKA AND VARIA"
\u1FEE "GREEK DIALYTIKA AND OXIA"
\u1FEF "GREEK VARIA"
\u1FF2 "GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI"
\u1FF3 "GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI"
\u1FF4 "GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI"
\u1FF6 "GREEK SMALL LETTER OMEGA WITH PERISPOMENI"
\u1FF7 "GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI"
\u1FF8 "GREEK CAPITAL LETTER OMICRON WITH VARIA"
\u1FF9 "GREEK CAPITAL LETTER OMICRON WITH OXIA"
\u1FFA "GREEK CAPITAL LETTER OMEGA WITH VARIA"
\u1FFB "GREEK CAPITAL LETTER OMEGA WITH OXIA"
\u1FFC "GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI"
\u1FFD "GREEK OXIA"
\u1FFE "GREEK DASIA"
\u2000 "EN QUAD"
\u2001 "EM QUAD"
\u2002 "EN SPACE"
\u2003 "EM SPACE"
\u2004 "THREE-PER-EM SPACE"
\u2005 "FOUR-PER-EM SPACE"
\u2006 "SIX-PER-EM SPACE"
\u2007 "FIGURE SPACE"
\u2008 "PUNCTUATION SPACE"
\u2009 "THIN SPACE"
\u200A "HAIR SPACE"
\u200B "ZERO WIDTH SPACE"
\u200C "ZERO WIDTH NON-JOINER"
\u200D "ZERO WIDTH JOINER"
\u200E "LEFT-TO-RIGHT MARK"
\u200F "RIGHT-TO-LEFT MARK"
\u2010 "HYPHEN"
\u2011 "NON-BREAKING HYPHEN"
\u2012 "FIGURE DASH"
\u2013 "EN DASH"
\u2014 "EM DASH"
\u2015 "HORIZONTAL BAR"
\u2016 "DOUBLE VERTICAL LINE"
\u2017 "DOUBLE LOW LINE"
\u2018 "LEFT SINGLE QUOTATION MARK"
\u2019 "RIGHT SINGLE QUOTATION MARK"
\u201A "SINGLE LOW-9 QUOTATION MARK"
\u201B "SINGLE HIGH-REVERSED-9 QUOTATION MARK"
\u201C "LEFT DOUBLE QUOTATION MARK"
\u201D "RIGHT DOUBLE QUOTATION MARK"
\u201E "DOUBLE LOW-9 QUOTATION MARK"
\u201F "DOUBLE HIGH-REVERSED-9 QUOTATION MARK"
\u2020 "DAGGER"
\u2021 "DOUBLE DAGGER"
\u2022 "BULLET"
\u2023 "TRIANGULAR BULLET"
\u2024 "ONE DOT LEADER"
\u2025 "TWO DOT LEADER"
\u2026 "HORIZONTAL ELLIPSIS"
\u2027 "HYPHENATION POINT"
\u2028 "LINE SEPARATOR"
\u2029 "PARAGRAPH SEPARATOR"
\u202A "LEFT-TO-RIGHT EMBEDDING"
\u202B "RIGHT-TO-LEFT EMBEDDING"
\u202C "POP DIRECTIONAL FORMATTING"
\u202D "LEFT-TO-RIGHT OVERRIDE"
\u202E "RIGHT-TO-LEFT OVERRIDE"
\u202F "NARROW NO-BREAK SPACE"
\u2030 "PER MILLE SIGN"
\u2031 "PER TEN THOUSAND SIGN"
\u2032 "PRIME"
\u2033 "DOUBLE PRIME"
\u2034 "TRIPLE PRIME"
\u2035 "REVERSED PRIME"
\u2036 "REVERSED DOUBLE PRIME"
\u2037 "REVERSED TRIPLE PRIME"
\u2038 "CARET"
\u2039 "SINGLE LEFT-POINTING ANGLE QUOTATION MARK"
\u203A "SINGLE RIGHT-POINTING ANGLE QUOTATION MARK"
\u203B "REFERENCE MARK"
\u203C "DOUBLE EXCLAMATION MARK"
\u203D "INTERROBANG"
\u203E "OVERLINE"
\u203F "UNDERTIE"
\u2040 "CHARACTER TIE"
\u2041 "CARET INSERTION POINT"
\u2042 "ASTERISM"
\u2043 "HYPHEN BULLET"
\u2044 "FRACTION SLASH"
\u2045 "LEFT SQUARE BRACKET WITH QUILL"
\u2046 "RIGHT SQUARE BRACKET WITH QUILL"
\u2047 "DOUBLE QUESTION MARK"
\u2048 "QUESTION EXCLAMATION MARK"
\u2049 "EXCLAMATION QUESTION MARK"
\u204A "TIRONIAN SIGN ET"
\u204B "REVERSED PILCROW SIGN"
\u204C "BLACK LEFTWARDS BULLET"
\u204D "BLACK RIGHTWARDS BULLET"
\u204E "LOW ASTERISK"
\u204F "REVERSED SEMICOLON"
\u2050 "CLOSE UP"
\u2051 "TWO ASTERISKS ALIGNED VERTICALLY"
\u2052 "COMMERCIAL MINUS SIGN"
\u2053 "SWUNG DASH"
\u2054 "INVERTED UNDERTIE"
\u2055 "FLOWER PUNCTUATION MARK"
\u2056 "THREE DOT PUNCTUATION"
\u2057 "QUADRUPLE PRIME"
\u2058 "FOUR DOT PUNCTUATION"
\u2059 "FIVE DOT PUNCTUATION"
\u205A "TWO DOT PUNCTUATION"
\u205B "FOUR DOT MARK"
\u205C "DOTTED CROSS"
\u205D "TRICOLON"
\u205E "VERTICAL FOUR DOTS"
\u205F "MEDIUM MATHEMATICAL SPACE"
\u2060 "WORD JOINER"
\u2061 "FUNCTION APPLICATION"
\u2062 "INVISIBLE TIMES"
\u2063 "INVISIBLE SEPARATOR"
\u2064 "INVISIBLE PLUS"
\u206A "INHIBIT SYMMETRIC SWAPPING"
\u206B "ACTIVATE SYMMETRIC SWAPPING"
\u206C "INHIBIT ARABIC FORM SHAPING"
\u206D "ACTIVATE ARABIC FORM SHAPING"
\u206E "NATIONAL DIGIT SHAPES"
\u206F "NOMINAL DIGIT SHAPES"
\u2070 "SUPERSCRIPT ZERO"
\u2071 "SUPERSCRIPT LATIN SMALL LETTER I"
\u2074 "SUPERSCRIPT FOUR"
\u2075 "SUPERSCRIPT FIVE"
\u2076 "SUPERSCRIPT SIX"
\u2077 "SUPERSCRIPT SEVEN"
\u2078 "SUPERSCRIPT EIGHT"
\u2079 "SUPERSCRIPT NINE"
\u207A "SUPERSCRIPT PLUS SIGN"
\u207B "SUPERSCRIPT MINUS"
\u207C "SUPERSCRIPT EQUALS SIGN"
\u207D "SUPERSCRIPT LEFT PARENTHESIS"
\u207E "SUPERSCRIPT RIGHT PARENTHESIS"
\u207F "SUPERSCRIPT LATIN SMALL LETTER N"
\u2080 "SUBSCRIPT ZERO"
\u2081 "SUBSCRIPT ONE"
\u2082 "SUBSCRIPT TWO"
\u2083 "SUBSCRIPT THREE"
\u2084 "SUBSCRIPT FOUR"
\u2085 "SUBSCRIPT FIVE"
\u2086 "SUBSCRIPT SIX"
\u2087 "SUBSCRIPT SEVEN"
\u2088 "SUBSCRIPT EIGHT"
\u2089 "SUBSCRIPT NINE"
\u208A "SUBSCRIPT PLUS SIGN"
\u208B "SUBSCRIPT MINUS"
\u208C "SUBSCRIPT EQUALS SIGN"
\u208D "SUBSCRIPT LEFT PARENTHESIS"
\u208E "SUBSCRIPT RIGHT PARENTHESIS"
\u2090 "LATIN SUBSCRIPT SMALL LETTER A"
\u2091 "LATIN SUBSCRIPT SMALL LETTER E"
\u2092 "LATIN SUBSCRIPT SMALL LETTER O"
\u2093 "LATIN SUBSCRIPT SMALL LETTER X"
\u2094 "LATIN SUBSCRIPT SMALL LETTER SCHWA"
\u20A0 "EURO-CURRENCY SIGN"
\u20A1 "COLON SIGN"
\u20A2 "CRUZEIRO SIGN"
\u20A3 "FRENCH FRANC SIGN"
\u20A4 "LIRA SIGN"
\u20A5 "MILL SIGN"
\u20A6 "NAIRA SIGN"
\u20A7 "PESETA SIGN"
\u20A8 "RUPEE SIGN"
\u20A9 "WON SIGN"
\u20AA "NEW SHEQEL SIGN"
\u20AB "DONG SIGN"
\u20AC "EURO SIGN"
\u20AD "KIP SIGN"
\u20AE "TUGRIK SIGN"
\u20AF "DRACHMA SIGN"
\u20B0 "GERMAN PENNY SIGN"
\u20B1 "PESO SIGN"
\u20B2 "GUARANI SIGN"
\u20B3 "AUSTRAL SIGN"
\u20B4 "HRYVNIA SIGN"
\u20B5 "CEDI SIGN"
\u20D0 "COMBINING LEFT HARPOON ABOVE"
\u20D1 "COMBINING RIGHT HARPOON ABOVE"
\u20D2 "COMBINING LONG VERTICAL LINE OVERLAY"
\u20D3 "COMBINING SHORT VERTICAL LINE OVERLAY"
\u20D4 "COMBINING ANTICLOCKWISE ARROW ABOVE"
\u20D5 "COMBINING CLOCKWISE ARROW ABOVE"
\u20D6 "COMBINING LEFT ARROW ABOVE"
\u20D7 "COMBINING RIGHT ARROW ABOVE"
\u20D8 "COMBINING RING OVERLAY"
\u20D9 "COMBINING CLOCKWISE RING OVERLAY"
\u20DA "COMBINING ANTICLOCKWISE RING OVERLAY"
\u20DB "COMBINING THREE DOTS ABOVE"
\u20DC "COMBINING FOUR DOTS ABOVE"
\u20DD "COMBINING ENCLOSING CIRCLE"
\u20DE "COMBINING ENCLOSING SQUARE"
\u20DF "COMBINING ENCLOSING DIAMOND"
\u20E0 "COMBINING ENCLOSING CIRCLE BACKSLASH"
\u20E1 "COMBINING LEFT RIGHT ARROW ABOVE"
\u20E2 "COMBINING ENCLOSING SCREEN"
\u20E3 "COMBINING ENCLOSING KEYCAP"
\u20E4 "COMBINING ENCLOSING UPWARD POINTING TRIANGLE"
\u20E5 "COMBINING REVERSE SOLIDUS OVERLAY"
\u20E6 "COMBINING DOUBLE VERTICAL STROKE OVERLAY"
\u20E7 "COMBINING ANNUITY SYMBOL"
\u20E8 "COMBINING TRIPLE UNDERDOT"
\u20E9 "COMBINING WIDE BRIDGE ABOVE"
\u20EA "COMBINING LEFTWARDS ARROW OVERLAY"
\u20EB "COMBINING LONG DOUBLE SOLIDUS OVERLAY"
\u20EC "COMBINING RIGHTWARDS HARPOON WITH BARB DOWNWARDS"
\u20ED "COMBINING LEFTWARDS HARPOON WITH BARB DOWNWARDS"
\u20EE "COMBINING LEFT ARROW BELOW"
\u20EF "COMBINING RIGHT ARROW BELOW"
\u20F0 "COMBINING ASTERISK ABOVE"
\u2100 "ACCOUNT OF"
\u2101 "ADDRESSED TO THE SUBJECT"
\u2102 "DOUBLE-STRUCK CAPITAL C"
\u2103 "DEGREE CELSIUS"
\u2104 "CENTRE LINE SYMBOL"
\u2105 "CARE OF"
\u2106 "CADA UNA"
\u2107 "EULER CONSTANT"
\u2108 "SCRUPLE"
\u2109 "DEGREE FAHRENHEIT"
\u210A "SCRIPT SMALL G"
\u210B "SCRIPT CAPITAL H"
\u210C "BLACK-LETTER CAPITAL H"
\u210D "DOUBLE-STRUCK CAPITAL H"
\u210E "PLANCK CONSTANT"
\u210F "PLANCK CONSTANT OVER TWO PI"
\u2110 "SCRIPT CAPITAL I"
\u2111 "BLACK-LETTER CAPITAL I"
\u2112 "SCRIPT CAPITAL L"
\u2113 "SCRIPT SMALL L"
\u2114 "L B BAR SYMBOL"
\u2115 "DOUBLE-STRUCK CAPITAL N"
\u2116 "NUMERO SIGN"
\u2117 "SOUND RECORDING COPYRIGHT"
\u2118 "SCRIPT CAPITAL P"
\u2119 "DOUBLE-STRUCK CAPITAL P"
\u211A "DOUBLE-STRUCK CAPITAL Q"
\u211B "SCRIPT CAPITAL R"
\u211C "BLACK-LETTER CAPITAL R"
\u211D "DOUBLE-STRUCK CAPITAL R"
\u211E "PRESCRIPTION TAKE"
\u211F "RESPONSE"
\u2120 "SERVICE MARK"
\u2121 "TELEPHONE SIGN"
\u2122 "TRADE MARK SIGN"
\u2123 "VERSICLE"
\u2124 "DOUBLE-STRUCK CAPITAL Z"
\u2125 "OUNCE SIGN"
\u2126 "OHM SIGN"
\u2127 "INVERTED OHM SIGN"
\u2128 "BLACK-LETTER CAPITAL Z"
\u2129 "TURNED GREEK SMALL LETTER IOTA"
\u212A "KELVIN SIGN"
\u212B "ANGSTROM SIGN"
\u212C "SCRIPT CAPITAL B"
\u212D "BLACK-LETTER CAPITAL C"
\u212E "ESTIMATED SYMBOL"
\u212F "SCRIPT SMALL E"
\u2130 "SCRIPT CAPITAL E"
\u2131 "SCRIPT CAPITAL F"
\u2132 "TURNED CAPITAL F"
\u2133 "SCRIPT CAPITAL M"
\u2134 "SCRIPT SMALL O"
\u2135 "ALEF SYMBOL"
\u2136 "BET SYMBOL"
\u2137 "GIMEL SYMBOL"
\u2138 "DALET SYMBOL"
\u2139 "INFORMATION SOURCE"
\u213A "ROTATED CAPITAL Q"
\u213B "FACSIMILE SIGN"
\u213C "DOUBLE-STRUCK SMALL PI"
\u213D "DOUBLE-STRUCK SMALL GAMMA"
\u213E "DOUBLE-STRUCK CAPITAL GAMMA"
\u213F "DOUBLE-STRUCK CAPITAL PI"
\u2140 "DOUBLE-STRUCK N-ARY SUMMATION"
\u2141 "TURNED SANS-SERIF CAPITAL G"
\u2142 "TURNED SANS-SERIF CAPITAL L"
\u2143 "REVERSED SANS-SERIF CAPITAL L"
\u2144 "TURNED SANS-SERIF CAPITAL Y"
\u2145 "DOUBLE-STRUCK ITALIC CAPITAL D"
\u2146 "DOUBLE-STRUCK ITALIC SMALL D"
\u2147 "DOUBLE-STRUCK ITALIC SMALL E"
\u2148 "DOUBLE-STRUCK ITALIC SMALL I"
\u2149 "DOUBLE-STRUCK ITALIC SMALL J"
\u214A "PROPERTY LINE"
\u214B "TURNED AMPERSAND"
\u214C "PER SIGN"
\u214D "AKTIESELSKAB"
\u214E "TURNED SMALL F"
\u214F "SYMBOL FOR SAMARITAN SOURCE"
\u2153 "VULGAR FRACTION ONE THIRD"
\u2154 "VULGAR FRACTION TWO THIRDS"
\u2155 "VULGAR FRACTION ONE FIFTH"
\u2156 "VULGAR FRACTION TWO FIFTHS"
\u2157 "VULGAR FRACTION THREE FIFTHS"
\u2158 "VULGAR FRACTION FOUR FIFTHS"
\u2159 "VULGAR FRACTION ONE SIXTH"
\u215A "VULGAR FRACTION FIVE SIXTHS"
\u215B "VULGAR FRACTION ONE EIGHTH"
\u215C "VULGAR FRACTION THREE EIGHTHS"
\u215D "VULGAR FRACTION FIVE EIGHTHS"
\u215E "VULGAR FRACTION SEVEN EIGHTHS"
\u215F "FRACTION NUMERATOR ONE"
\u2160 "ROMAN NUMERAL ONE"
\u2161 "ROMAN NUMERAL TWO"
\u2162 "ROMAN NUMERAL THREE"
\u2163 "ROMAN NUMERAL FOUR"
\u2164 "ROMAN NUMERAL FIVE"
\u2165 "ROMAN NUMERAL SIX"
\u2166 "ROMAN NUMERAL SEVEN"
\u2167 "ROMAN NUMERAL EIGHT"
\u2168 "ROMAN NUMERAL NINE"
\u2169 "ROMAN NUMERAL TEN"
\u216A "ROMAN NUMERAL ELEVEN"
\u216B "ROMAN NUMERAL TWELVE"
\u216C "ROMAN NUMERAL FIFTY"
\u216D "ROMAN NUMERAL ONE HUNDRED"
\u216E "ROMAN NUMERAL FIVE HUNDRED"
\u216F "ROMAN NUMERAL ONE THOUSAND"
\u2170 "SMALL ROMAN NUMERAL ONE"
\u2171 "SMALL ROMAN NUMERAL TWO"
\u2172 "SMALL ROMAN NUMERAL THREE"
\u2173 "SMALL ROMAN NUMERAL FOUR"
\u2174 "SMALL ROMAN NUMERAL FIVE"
\u2175 "SMALL ROMAN NUMERAL SIX"
\u2176 "SMALL ROMAN NUMERAL SEVEN"
\u2177 "SMALL ROMAN NUMERAL EIGHT"
\u2178 "SMALL ROMAN NUMERAL NINE"
\u2179 "SMALL ROMAN NUMERAL TEN"
\u217A "SMALL ROMAN NUMERAL ELEVEN"
\u217B "SMALL ROMAN NUMERAL TWELVE"
\u217C "SMALL ROMAN NUMERAL FIFTY"
\u217D "SMALL ROMAN NUMERAL ONE HUNDRED"
\u217E "SMALL ROMAN NUMERAL FIVE HUNDRED"
\u217F "SMALL ROMAN NUMERAL ONE THOUSAND"
\u2180 "ROMAN NUMERAL ONE THOUSAND C D"
\u2181 "ROMAN NUMERAL FIVE THOUSAND"
\u2182 "ROMAN NUMERAL TEN THOUSAND"
\u2183 "ROMAN NUMERAL REVERSED ONE HUNDRED"
\u2184 "LATIN SMALL LETTER REVERSED C"
\u2185 "ROMAN NUMERAL SIX LATE FORM"
\u2186 "ROMAN NUMERAL FIFTY EARLY FORM"
\u2187 "ROMAN NUMERAL FIFTY THOUSAND"
\u2188 "ROMAN NUMERAL ONE HUNDRED THOUSAND"
\u2190 "LEFTWARDS ARROW"
\u2191 "UPWARDS ARROW"
\u2192 "RIGHTWARDS ARROW"
\u2193 "DOWNWARDS ARROW"
\u2194 "LEFT RIGHT ARROW"
\u2195 "UP DOWN ARROW"
\u2196 "NORTH WEST ARROW"
\u2197 "NORTH EAST ARROW"
\u2198 "SOUTH EAST ARROW"
\u2199 "SOUTH WEST ARROW"
\u219A "LEFTWARDS ARROW WITH STROKE"
\u219B "RIGHTWARDS ARROW WITH STROKE"
\u219C "LEFTWARDS WAVE ARROW"
\u219D "RIGHTWARDS WAVE ARROW"
\u219E "LEFTWARDS TWO HEADED ARROW"
\u219F "UPWARDS TWO HEADED ARROW"
\u21A0 "RIGHTWARDS TWO HEADED ARROW"
\u21A1 "DOWNWARDS TWO HEADED ARROW"
\u21A2 "LEFTWARDS ARROW WITH TAIL"
\u21A3 "RIGHTWARDS ARROW WITH TAIL"
\u21A4 "LEFTWARDS ARROW FROM BAR"
\u21A5 "UPWARDS ARROW FROM BAR"
\u21A6 "RIGHTWARDS ARROW FROM BAR"
\u21A7 "DOWNWARDS ARROW FROM BAR"
\u21A8 "UP DOWN ARROW WITH BASE"
\u21A9 "LEFTWARDS ARROW WITH HOOK"
\u21AA "RIGHTWARDS ARROW WITH HOOK"
\u21AB "LEFTWARDS ARROW WITH LOOP"
\u21AC "RIGHTWARDS ARROW WITH LOOP"
\u21AD "LEFT RIGHT WAVE ARROW"
\u21AE "LEFT RIGHT ARROW WITH STROKE"
\u21AF "DOWNWARDS ZIGZAG ARROW"
\u21B0 "UPWARDS ARROW WITH TIP LEFTWARDS"
\u21B1 "UPWARDS ARROW WITH TIP RIGHTWARDS"
\u21B2 "DOWNWARDS ARROW WITH TIP LEFTWARDS"
\u21B3 "DOWNWARDS ARROW WITH TIP RIGHTWARDS"
\u21B4 "RIGHTWARDS ARROW WITH CORNER DOWNWARDS"
\u21B5 "DOWNWARDS ARROW WITH CORNER LEFTWARDS"
\u21B6 "ANTICLOCKWISE TOP SEMICIRCLE ARROW"
\u21B7 "CLOCKWISE TOP SEMICIRCLE ARROW"
\u21B8 "NORTH WEST ARROW TO LONG BAR"
\u21B9 "LEFTWARDS ARROW TO BAR OVER RIGHTWARDS ARROW TO BAR"
\u21BA "ANTICLOCKWISE OPEN CIRCLE ARROW"
\u21BB "CLOCKWISE OPEN CIRCLE ARROW"
\u21BC "LEFTWARDS HARPOON WITH BARB UPWARDS"
\u21BD "LEFTWARDS HARPOON WITH BARB DOWNWARDS"
\u21BE "UPWARDS HARPOON WITH BARB RIGHTWARDS"
\u21BF "UPWARDS HARPOON WITH BARB LEFTWARDS"
\u21C0 "RIGHTWARDS HARPOON WITH BARB UPWARDS"
\u21C1 "RIGHTWARDS HARPOON WITH BARB DOWNWARDS"
\u21C2 "DOWNWARDS HARPOON WITH BARB RIGHTWARDS"
\u21C3 "DOWNWARDS HARPOON WITH BARB LEFTWARDS"
\u21C4 "RIGHTWARDS ARROW OVER LEFTWARDS ARROW"
\u21C5 "UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW"
\u21C6 "LEFTWARDS ARROW OVER RIGHTWARDS ARROW"
\u21C7 "LEFTWARDS PAIRED ARROWS"
\u21C8 "UPWARDS PAIRED ARROWS"
\u21C9 "RIGHTWARDS PAIRED ARROWS"
\u21CA "DOWNWARDS PAIRED ARROWS"
\u21CB "LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON"
\u21CC "RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON"
\u21CD "LEFTWARDS DOUBLE ARROW WITH STROKE"
\u21CE "LEFT RIGHT DOUBLE ARROW WITH STROKE"
\u21CF "RIGHTWARDS DOUBLE ARROW WITH STROKE"
\u21D0 "LEFTWARDS DOUBLE ARROW"
\u21D1 "UPWARDS DOUBLE ARROW"
\u21D2 "RIGHTWARDS DOUBLE ARROW"
\u21D3 "DOWNWARDS DOUBLE ARROW"
\u21D4 "LEFT RIGHT DOUBLE ARROW"
\u21D5 "UP DOWN DOUBLE ARROW"
\u21D6 "NORTH WEST DOUBLE ARROW"
\u21D7 "NORTH EAST DOUBLE ARROW"
\u21D8 "SOUTH EAST DOUBLE ARROW"
\u21D9 "SOUTH WEST DOUBLE ARROW"
\u21DA "LEFTWARDS TRIPLE ARROW"
\u21DB "RIGHTWARDS TRIPLE ARROW"
\u21DC "LEFTWARDS SQUIGGLE ARROW"
\u21DD "RIGHTWARDS SQUIGGLE ARROW"
\u21DE "UPWARDS ARROW WITH DOUBLE STROKE"
\u21DF "DOWNWARDS ARROW WITH DOUBLE STROKE"
\u21E0 "LEFTWARDS DASHED ARROW"
\u21E1 "UPWARDS DASHED ARROW"
\u21E2 "RIGHTWARDS DASHED ARROW"
\u21E3 "DOWNWARDS DASHED ARROW"
\u21E4 "LEFTWARDS ARROW TO BAR"
\u21E5 "RIGHTWARDS ARROW TO BAR"
\u21E6 "LEFTWARDS WHITE ARROW"
\u21E7 "UPWARDS WHITE ARROW"
\u21E8 "RIGHTWARDS WHITE ARROW"
\u21E9 "DOWNWARDS WHITE ARROW"
\u21EA "UPWARDS WHITE ARROW FROM BAR"
\u21EB "UPWARDS WHITE ARROW ON PEDESTAL"
\u21EC "UPWARDS WHITE ARROW ON PEDESTAL WITH HORIZONTAL BAR"
\u21ED "UPWARDS WHITE ARROW ON PEDESTAL WITH VERTICAL BAR"
\u21EE "UPWARDS WHITE DOUBLE ARROW"
\u21EF "UPWARDS WHITE DOUBLE ARROW ON PEDESTAL"
\u21F0 "RIGHTWARDS WHITE ARROW FROM WALL"
\u21F1 "NORTH WEST ARROW TO CORNER"
\u21F2 "SOUTH EAST ARROW TO CORNER"
\u21F3 "UP DOWN WHITE ARROW"
\u21F4 "RIGHT ARROW WITH SMALL CIRCLE"
\u21F5 "DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW"
\u21F6 "THREE RIGHTWARDS ARROWS"
\u21F7 "LEFTWARDS ARROW WITH VERTICAL STROKE"
\u21F8 "RIGHTWARDS ARROW WITH VERTICAL STROKE"
\u21F9 "LEFT RIGHT ARROW WITH VERTICAL STROKE"
\u21FA "LEFTWARDS ARROW WITH DOUBLE VERTICAL STROKE"
\u21FB "RIGHTWARDS ARROW WITH DOUBLE VERTICAL STROKE"
\u21FC "LEFT RIGHT ARROW WITH DOUBLE VERTICAL STROKE"
\u21FD "LEFTWARDS OPEN-HEADED ARROW"
\u21FE "RIGHTWARDS OPEN-HEADED ARROW"
\u21FF "LEFT RIGHT OPEN-HEADED ARROW"
\u2200 "FOR ALL"
\u2201 "COMPLEMENT"
\u2202 "PARTIAL DIFFERENTIAL"
\u2203 "THERE EXISTS"
\u2204 "THERE DOES NOT EXIST"
\u2205 "EMPTY SET"
\u2206 "INCREMENT"
\u2207 "NABLA"
\u2208 "ELEMENT OF"
\u2209 "NOT AN ELEMENT OF"
\u220A "SMALL ELEMENT OF"
\u220B "CONTAINS AS MEMBER"
\u220C "DOES NOT CONTAIN AS MEMBER"
\u220D "SMALL CONTAINS AS MEMBER"
\u220E "END OF PROOF"
\u220F "N-ARY PRODUCT"
\u2210 "N-ARY COPRODUCT"
\u2211 "N-ARY SUMMATION"
\u2212 "MINUS SIGN"
\u2213 "MINUS-OR-PLUS SIGN"
\u2214 "DOT PLUS"
\u2215 "DIVISION SLASH"
\u2216 "SET MINUS"
\u2217 "ASTERISK OPERATOR"
\u2218 "RING OPERATOR"
\u2219 "BULLET OPERATOR"
\u221A "SQUARE ROOT"
\u221B "CUBE ROOT"
\u221C "FOURTH ROOT"
\u221D "PROPORTIONAL TO"
\u221E "INFINITY"
\u221F "RIGHT ANGLE"
\u2220 "ANGLE"
\u2221 "MEASURED ANGLE"
\u2222 "SPHERICAL ANGLE"
\u2223 "DIVIDES"
\u2224 "DOES NOT DIVIDE"
\u2225 "PARALLEL TO"
\u2226 "NOT PARALLEL TO"
\u2227 "LOGICAL AND"
\u2228 "LOGICAL OR"
\u2229 "INTERSECTION"
\u222A "UNION"
\u222B "INTEGRAL"
\u222C "DOUBLE INTEGRAL"
\u222D "TRIPLE INTEGRAL"
\u222E "CONTOUR INTEGRAL"
\u222F "SURFACE INTEGRAL"
\u2230 "VOLUME INTEGRAL"
\u2231 "CLOCKWISE INTEGRAL"
\u2232 "CLOCKWISE CONTOUR INTEGRAL"
\u2233 "ANTICLOCKWISE CONTOUR INTEGRAL"
\u2234 "THEREFORE"
\u2235 "BECAUSE"
\u2236 "RATIO"
\u2237 "PROPORTION"
\u2238 "DOT MINUS"
\u2239 "EXCESS"
\u223A "GEOMETRIC PROPORTION"
\u223B "HOMOTHETIC"
\u223C "TILDE OPERATOR"
\u223D "REVERSED TILDE"
\u223E "INVERTED LAZY S"
\u223F "SINE WAVE"
\u2240 "WREATH PRODUCT"
\u2241 "NOT TILDE"
\u2242 "MINUS TILDE"
\u2243 "ASYMPTOTICALLY EQUAL TO"
\u2244 "NOT ASYMPTOTICALLY EQUAL TO"
\u2245 "APPROXIMATELY EQUAL TO"
\u2246 "APPROXIMATELY BUT NOT ACTUALLY EQUAL TO"
\u2247 "NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO"
\u2248 "ALMOST EQUAL TO"
\u2249 "NOT ALMOST EQUAL TO"
\u224A "ALMOST EQUAL OR EQUAL TO"
\u224B "TRIPLE TILDE"
\u224C "ALL EQUAL TO"
\u224D "EQUIVALENT TO"
\u224E "GEOMETRICALLY EQUIVALENT TO"
\u224F "DIFFERENCE BETWEEN"
\u2250 "APPROACHES THE LIMIT"
\u2251 "GEOMETRICALLY EQUAL TO"
\u2252 "APPROXIMATELY EQUAL TO OR THE IMAGE OF"
\u2253 "IMAGE OF OR APPROXIMATELY EQUAL TO"
\u2254 "COLON EQUALS"
\u2255 "EQUALS COLON"
\u2256 "RING IN EQUAL TO"
\u2257 "RING EQUAL TO"
\u2258 "CORRESPONDS TO"
\u2259 "ESTIMATES"
\u225A "EQUIANGULAR TO"
\u225B "STAR EQUALS"
\u225C "DELTA EQUAL TO"
\u225D "EQUAL TO BY DEFINITION"
\u225E "MEASURED BY"
\u225F "QUESTIONED EQUAL TO"
\u2260 "NOT EQUAL TO"
\u2261 "IDENTICAL TO"
\u2262 "NOT IDENTICAL TO"
\u2263 "STRICTLY EQUIVALENT TO"
\u2264 "LESS-THAN OR EQUAL TO"
\u2265 "GREATER-THAN OR EQUAL TO"
\u2266 "LESS-THAN OVER EQUAL TO"
\u2267 "GREATER-THAN OVER EQUAL TO"
\u2268 "LESS-THAN BUT NOT EQUAL TO"
\u2269 "GREATER-THAN BUT NOT EQUAL TO"
\u226A "MUCH LESS-THAN"
\u226B "MUCH GREATER-THAN"
\u226C "BETWEEN"
\u226D "NOT EQUIVALENT TO"
\u226E "NOT LESS-THAN"
\u226F "NOT GREATER-THAN"
\u2270 "NEITHER LESS-THAN NOR EQUAL TO"
\u2271 "NEITHER GREATER-THAN NOR EQUAL TO"
\u2272 "LESS-THAN OR EQUIVALENT TO"
\u2273 "GREATER-THAN OR EQUIVALENT TO"
\u2274 "NEITHER LESS-THAN NOR EQUIVALENT TO"
\u2275 "NEITHER GREATER-THAN NOR EQUIVALENT TO"
\u2276 "LESS-THAN OR GREATER-THAN"
\u2277 "GREATER-THAN OR LESS-THAN"
\u2278 "NEITHER LESS-THAN NOR GREATER-THAN"
\u2279 "NEITHER GREATER-THAN NOR LESS-THAN"
\u227A "PRECEDES"
\u227B "SUCCEEDS"
\u227C "PRECEDES OR EQUAL TO"
\u227D "SUCCEEDS OR EQUAL TO"
\u227E "PRECEDES OR EQUIVALENT TO"
\u227F "SUCCEEDS OR EQUIVALENT TO"
\u2280 "DOES NOT PRECEDE"
\u2281 "DOES NOT SUCCEED"
\u2282 "SUBSET OF"
\u2283 "SUPERSET OF"
\u2284 "NOT A SUBSET OF"
\u2285 "NOT A SUPERSET OF"
\u2286 "SUBSET OF OR EQUAL TO"
\u2287 "SUPERSET OF OR EQUAL TO"
\u2288 "NEITHER A SUBSET OF NOR EQUAL TO"
\u2289 "NEITHER A SUPERSET OF NOR EQUAL TO"
\u228A "SUBSET OF WITH NOT EQUAL TO"
\u228B "SUPERSET OF WITH NOT EQUAL TO"
\u228C "MULTISET"
\u228D "MULTISET MULTIPLICATION"
\u228E "MULTISET UNION"
\u228F "SQUARE IMAGE OF"
\u2290 "SQUARE ORIGINAL OF"
\u2291 "SQUARE IMAGE OF OR EQUAL TO"
\u2292 "SQUARE ORIGINAL OF OR EQUAL TO"
\u2293 "SQUARE CAP"
\u2294 "SQUARE CUP"
\u2295 "CIRCLED PLUS"
\u2296 "CIRCLED MINUS"
\u2297 "CIRCLED TIMES"
\u2298 "CIRCLED DIVISION SLASH"
\u2299 "CIRCLED DOT OPERATOR"
\u229A "CIRCLED RING OPERATOR"
\u229B "CIRCLED ASTERISK OPERATOR"
\u229C "CIRCLED EQUALS"
\u229D "CIRCLED DASH"
\u229E "SQUARED PLUS"
\u229F "SQUARED MINUS"
\u22A0 "SQUARED TIMES"
\u22A1 "SQUARED DOT OPERATOR"
\u22A2 "RIGHT TACK"
\u22A3 "LEFT TACK"
\u22A4 "DOWN TACK"
\u22A5 "UP TACK"
\u22A6 "ASSERTION"
\u22A7 "MODELS"
\u22A8 "TRUE"
\u22A9 "FORCES"
\u22AA "TRIPLE VERTICAL BAR RIGHT TURNSTILE"
\u22AB "DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE"
\u22AC "DOES NOT PROVE"
\u22AD "NOT TRUE"
\u22AE "DOES NOT FORCE"
\u22AF "NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE"
\u22B0 "PRECEDES UNDER RELATION"
\u22B1 "SUCCEEDS UNDER RELATION"
\u22B2 "NORMAL SUBGROUP OF"
\u22B3 "CONTAINS AS NORMAL SUBGROUP"
\u22B4 "NORMAL SUBGROUP OF OR EQUAL TO"
\u22B5 "CONTAINS AS NORMAL SUBGROUP OR EQUAL TO"
\u22B6 "ORIGINAL OF"
\u22B7 "IMAGE OF"
\u22B8 "MULTIMAP"
\u22B9 "HERMITIAN CONJUGATE MATRIX"
\u22BA "INTERCALATE"
\u22BB "XOR"
\u22BC "NAND"
\u22BD "NOR"
\u22BE "RIGHT ANGLE WITH ARC"
\u22BF "RIGHT TRIANGLE"
\u22C0 "N-ARY LOGICAL AND"
\u22C1 "N-ARY LOGICAL OR"
\u22C2 "N-ARY INTERSECTION"
\u22C3 "N-ARY UNION"
\u22C4 "DIAMOND OPERATOR"
\u22C5 "DOT OPERATOR"
\u22C6 "STAR OPERATOR"
\u22C7 "DIVISION TIMES"
\u22C8 "BOWTIE"
\u22C9 "LEFT NORMAL FACTOR SEMIDIRECT PRODUCT"
\u22CA "RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT"
\u22CB "LEFT SEMIDIRECT PRODUCT"
\u22CC "RIGHT SEMIDIRECT PRODUCT"
\u22CD "REVERSED TILDE EQUALS"
\u22CE "CURLY LOGICAL OR"
\u22CF "CURLY LOGICAL AND"
\u22D0 "DOUBLE SUBSET"
\u22D1 "DOUBLE SUPERSET"
\u22D2 "DOUBLE INTERSECTION"
\u22D3 "DOUBLE UNION"
\u22D4 "PITCHFORK"
\u22D5 "EQUAL AND PARALLEL TO"
\u22D6 "LESS-THAN WITH DOT"
\u22D7 "GREATER-THAN WITH DOT"
\u22D8 "VERY MUCH LESS-THAN"
\u22D9 "VERY MUCH GREATER-THAN"
\u22DA "LESS-THAN EQUAL TO OR GREATER-THAN"
\u22DB "GREATER-THAN EQUAL TO OR LESS-THAN"
\u22DC "EQUAL TO OR LESS-THAN"
\u22DD "EQUAL TO OR GREATER-THAN"
\u22DE "EQUAL TO OR PRECEDES"
\u22DF "EQUAL TO OR SUCCEEDS"
\u22E0 "DOES NOT PRECEDE OR EQUAL"
\u22E1 "DOES NOT SUCCEED OR EQUAL"
\u22E2 "NOT SQUARE IMAGE OF OR EQUAL TO"
\u22E3 "NOT SQUARE ORIGINAL OF OR EQUAL TO"
\u22E4 "SQUARE IMAGE OF OR NOT EQUAL TO"
\u22E5 "SQUARE ORIGINAL OF OR NOT EQUAL TO"
\u22E6 "LESS-THAN BUT NOT EQUIVALENT TO"
\u22E7 "GREATER-THAN BUT NOT EQUIVALENT TO"
\u22E8 "PRECEDES BUT NOT EQUIVALENT TO"
\u22E9 "SUCCEEDS BUT NOT EQUIVALENT TO"
\u22EA "NOT NORMAL SUBGROUP OF"
\u22EB "DOES NOT CONTAIN AS NORMAL SUBGROUP"
\u22EC "NOT NORMAL SUBGROUP OF OR EQUAL TO"
\u22ED "DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL"
\u22EE "VERTICAL ELLIPSIS"
\u22EF "MIDLINE HORIZONTAL ELLIPSIS"
\u22F0 "UP RIGHT DIAGONAL ELLIPSIS"
\u22F1 "DOWN RIGHT DIAGONAL ELLIPSIS"
\u22F2 "ELEMENT OF WITH LONG HORIZONTAL STROKE"
\u22F3 "ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE"
\u22F4 "SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE"
\u22F5 "ELEMENT OF WITH DOT ABOVE"
\u22F6 "ELEMENT OF WITH OVERBAR"
\u22F7 "SMALL ELEMENT OF WITH OVERBAR"
\u22F8 "ELEMENT OF WITH UNDERBAR"
\u22F9 "ELEMENT OF WITH TWO HORIZONTAL STROKES"
\u22FA "CONTAINS WITH LONG HORIZONTAL STROKE"
\u22FB "CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE"
\u22FC "SMALL CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE"
\u22FD "CONTAINS WITH OVERBAR"
\u22FE "SMALL CONTAINS WITH OVERBAR"
\u22FF "Z NOTATION BAG MEMBERSHIP"
\u2300 "DIAMETER SIGN"
\u2301 "ELECTRIC ARROW"
\u2302 "HOUSE"
\u2303 "UP ARROWHEAD"
\u2304 "DOWN ARROWHEAD"
\u2305 "PROJECTIVE"
\u2306 "PERSPECTIVE"
\u2307 "WAVY LINE"
\u2308 "LEFT CEILING"
\u2309 "RIGHT CEILING"
\u230A "LEFT FLOOR"
\u230B "RIGHT FLOOR"
\u230C "BOTTOM RIGHT CROP"
\u230D "BOTTOM LEFT CROP"
\u230E "TOP RIGHT CROP"
\u230F "TOP LEFT CROP"
\u2310 "REVERSED NOT SIGN"
\u2311 "SQUARE LOZENGE"
\u2312 "ARC"
\u2313 "SEGMENT"
\u2314 "SECTOR"
\u2315 "TELEPHONE RECORDER"
\u2316 "POSITION INDICATOR"
\u2317 "VIEWDATA SQUARE"
\u2318 "PLACE OF INTEREST SIGN"
\u2319 "TURNED NOT SIGN"
\u231A "WATCH"
\u231B "HOURGLASS"
\u231C "TOP LEFT CORNER"
\u231D "TOP RIGHT CORNER"
\u231E "BOTTOM LEFT CORNER"
\u231F "BOTTOM RIGHT CORNER"
\u2320 "TOP HALF INTEGRAL"
\u2321 "BOTTOM HALF INTEGRAL"
\u2322 "FROWN"
\u2323 "SMILE"
\u2324 "UP ARROWHEAD BETWEEN TWO HORIZONTAL BARS"
\u2325 "OPTION KEY"
\u2326 "ERASE TO THE RIGHT"
\u2327 "X IN A RECTANGLE BOX"
\u2328 "KEYBOARD"
\u2329 "LEFT-POINTING ANGLE BRACKET"
\u232A "RIGHT-POINTING ANGLE BRACKET"
\u232B "ERASE TO THE LEFT"
\u232C "BENZENE RING"
\u232D "CYLINDRICITY"
\u232E "ALL AROUND-PROFILE"
\u232F "SYMMETRY"
\u2330 "TOTAL RUNOUT"
\u2331 "DIMENSION ORIGIN"
\u2332 "CONICAL TAPER"
\u2333 "SLOPE"
\u2334 "COUNTERBORE"
\u2335 "COUNTERSINK"
\u2336 "APL FUNCTIONAL SYMBOL I-BEAM"
\u2337 "APL FUNCTIONAL SYMBOL SQUISH QUAD"
\u2338 "APL FUNCTIONAL SYMBOL QUAD EQUAL"
\u2339 "APL FUNCTIONAL SYMBOL QUAD DIVIDE"
\u233A "APL FUNCTIONAL SYMBOL QUAD DIAMOND"
\u233B "APL FUNCTIONAL SYMBOL QUAD JOT"
\u233C "APL FUNCTIONAL SYMBOL QUAD CIRCLE"
\u233D "APL FUNCTIONAL SYMBOL CIRCLE STILE"
\u233E "APL FUNCTIONAL SYMBOL CIRCLE JOT"
\u233F "APL FUNCTIONAL SYMBOL SLASH BAR"
\u2340 "APL FUNCTIONAL SYMBOL BACKSLASH BAR"
\u2341 "APL FUNCTIONAL SYMBOL QUAD SLASH"
\u2342 "APL FUNCTIONAL SYMBOL QUAD BACKSLASH"
\u2343 "APL FUNCTIONAL SYMBOL QUAD LESS-THAN"
\u2344 "APL FUNCTIONAL SYMBOL QUAD GREATER-THAN"
\u2345 "APL FUNCTIONAL SYMBOL LEFTWARDS VANE"
\u2346 "APL FUNCTIONAL SYMBOL RIGHTWARDS VANE"
\u2347 "APL FUNCTIONAL SYMBOL QUAD LEFTWARDS ARROW"
\u2348 "APL FUNCTIONAL SYMBOL QUAD RIGHTWARDS ARROW"
\u2349 "APL FUNCTIONAL SYMBOL CIRCLE BACKSLASH"
\u234A "APL FUNCTIONAL SYMBOL DOWN TACK UNDERBAR"
\u234B "APL FUNCTIONAL SYMBOL DELTA STILE"
\u234C "APL FUNCTIONAL SYMBOL QUAD DOWN CARET"
\u234D "APL FUNCTIONAL SYMBOL QUAD DELTA"
\u234E "APL FUNCTIONAL SYMBOL DOWN TACK JOT"
\u234F "APL FUNCTIONAL SYMBOL UPWARDS VANE"
\u2350 "APL FUNCTIONAL SYMBOL QUAD UPWARDS ARROW"
\u2351 "APL FUNCTIONAL SYMBOL UP TACK OVERBAR"
\u2352 "APL FUNCTIONAL SYMBOL DEL STILE"
\u2353 "APL FUNCTIONAL SYMBOL QUAD UP CARET"
\u2354 "APL FUNCTIONAL SYMBOL QUAD DEL"
\u2355 "APL FUNCTIONAL SYMBOL UP TACK JOT"
\u2356 "APL FUNCTIONAL SYMBOL DOWNWARDS VANE"
\u2357 "APL FUNCTIONAL SYMBOL QUAD DOWNWARDS ARROW"
\u2358 "APL FUNCTIONAL SYMBOL QUOTE UNDERBAR"
\u2359 "APL FUNCTIONAL SYMBOL DELTA UNDERBAR"
\u235A "APL FUNCTIONAL SYMBOL DIAMOND UNDERBAR"
\u235B "APL FUNCTIONAL SYMBOL JOT UNDERBAR"
\u235C "APL FUNCTIONAL SYMBOL CIRCLE UNDERBAR"
\u235D "APL FUNCTIONAL SYMBOL UP SHOE JOT"
\u235E "APL FUNCTIONAL SYMBOL QUOTE QUAD"
\u235F "APL FUNCTIONAL SYMBOL CIRCLE STAR"
\u2360 "APL FUNCTIONAL SYMBOL QUAD COLON"
\u2361 "APL FUNCTIONAL SYMBOL UP TACK DIAERESIS"
\u2362 "APL FUNCTIONAL SYMBOL DEL DIAERESIS"
\u2363 "APL FUNCTIONAL SYMBOL STAR DIAERESIS"
\u2364 "APL FUNCTIONAL SYMBOL JOT DIAERESIS"
\u2365 "APL FUNCTIONAL SYMBOL CIRCLE DIAERESIS"
\u2366 "APL FUNCTIONAL SYMBOL DOWN SHOE STILE"
\u2367 "APL FUNCTIONAL SYMBOL LEFT SHOE STILE"
\u2368 "APL FUNCTIONAL SYMBOL TILDE DIAERESIS"
\u2369 "APL FUNCTIONAL SYMBOL GREATER-THAN DIAERESIS"
\u236A "APL FUNCTIONAL SYMBOL COMMA BAR"
\u236B "APL FUNCTIONAL SYMBOL DEL TILDE"
\u236C "APL FUNCTIONAL SYMBOL ZILDE"
\u236D "APL FUNCTIONAL SYMBOL STILE TILDE"
\u236E "APL FUNCTIONAL SYMBOL SEMICOLON UNDERBAR"
\u236F "APL FUNCTIONAL SYMBOL QUAD NOT EQUAL"
\u2370 "APL FUNCTIONAL SYMBOL QUAD QUESTION"
\u2371 "APL FUNCTIONAL SYMBOL DOWN CARET TILDE"
\u2372 "APL FUNCTIONAL SYMBOL UP CARET TILDE"
\u2373 "APL FUNCTIONAL SYMBOL IOTA"
\u2374 "APL FUNCTIONAL SYMBOL RHO"
\u2375 "APL FUNCTIONAL SYMBOL OMEGA"
\u2376 "APL FUNCTIONAL SYMBOL ALPHA UNDERBAR"
\u2377 "APL FUNCTIONAL SYMBOL EPSILON UNDERBAR"
\u2378 "APL FUNCTIONAL SYMBOL IOTA UNDERBAR"
\u2379 "APL FUNCTIONAL SYMBOL OMEGA UNDERBAR"
\u237A "APL FUNCTIONAL SYMBOL ALPHA"
\u237B "NOT CHECK MARK"
\u237C "RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW"
\u237D "SHOULDERED OPEN BOX"
\u237E "BELL SYMBOL"
\u237F "VERTICAL LINE WITH MIDDLE DOT"
\u2380 "INSERTION SYMBOL"
\u2381 "CONTINUOUS UNDERLINE SYMBOL"
\u2382 "DISCONTINUOUS UNDERLINE SYMBOL"
\u2383 "EMPHASIS SYMBOL"
\u2384 "COMPOSITION SYMBOL"
\u2385 "WHITE SQUARE WITH CENTRE VERTICAL LINE"
\u2386 "ENTER SYMBOL"
\u2387 "ALTERNATIVE KEY SYMBOL"
\u2388 "HELM SYMBOL"
\u2389 "CIRCLED HORIZONTAL BAR WITH NOTCH"
\u238A "CIRCLED TRIANGLE DOWN"
\u238B "BROKEN CIRCLE WITH NORTHWEST ARROW"
\u238C "UNDO SYMBOL"
\u238D "MONOSTABLE SYMBOL"
\u238E "HYSTERESIS SYMBOL"
\u238F "OPEN-CIRCUIT-OUTPUT H-TYPE SYMBOL"
\u2390 "OPEN-CIRCUIT-OUTPUT L-TYPE SYMBOL"
\u2391 "PASSIVE-PULL-DOWN-OUTPUT SYMBOL"
\u2392 "PASSIVE-PULL-UP-OUTPUT SYMBOL"
\u2393 "DIRECT CURRENT SYMBOL FORM TWO"
\u2394 "SOFTWARE-FUNCTION SYMBOL"
\u2395 "APL FUNCTIONAL SYMBOL QUAD"
\u2396 "DECIMAL SEPARATOR KEY SYMBOL"
\u2397 "PREVIOUS PAGE"
\u2398 "NEXT PAGE"
\u2399 "PRINT SCREEN SYMBOL"
\u239A "CLEAR SCREEN SYMBOL"
\u239B "LEFT PARENTHESIS UPPER HOOK"
\u239C "LEFT PARENTHESIS EXTENSION"
\u239D "LEFT PARENTHESIS LOWER HOOK"
\u239E "RIGHT PARENTHESIS UPPER HOOK"
\u239F "RIGHT PARENTHESIS EXTENSION"
\u23A0 "RIGHT PARENTHESIS LOWER HOOK"
\u23A1 "LEFT SQUARE BRACKET UPPER CORNER"
\u23A2 "LEFT SQUARE BRACKET EXTENSION"
\u23A3 "LEFT SQUARE BRACKET LOWER CORNER"
\u23A4 "RIGHT SQUARE BRACKET UPPER CORNER"
\u23A5 "RIGHT SQUARE BRACKET EXTENSION"
\u23A6 "RIGHT SQUARE BRACKET LOWER CORNER"
\u23A7 "LEFT CURLY BRACKET UPPER HOOK"
\u23A8 "LEFT CURLY BRACKET MIDDLE PIECE"
\u23A9 "LEFT CURLY BRACKET LOWER HOOK"
\u23AA "CURLY BRACKET EXTENSION"
\u23AB "RIGHT CURLY BRACKET UPPER HOOK"
\u23AC "RIGHT CURLY BRACKET MIDDLE PIECE"
\u23AD "RIGHT CURLY BRACKET LOWER HOOK"
\u23AE "INTEGRAL EXTENSION"
\u23AF "HORIZONTAL LINE EXTENSION"
\u23B0 "UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION"
\u23B1 "UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION"
\u23B2 "SUMMATION TOP"
\u23B3 "SUMMATION BOTTOM"
\u23B4 "TOP SQUARE BRACKET"
\u23B5 "BOTTOM SQUARE BRACKET"
\u23B6 "BOTTOM SQUARE BRACKET OVER TOP SQUARE BRACKET"
\u23B7 "RADICAL SYMBOL BOTTOM"
\u23B8 "LEFT VERTICAL BOX LINE"
\u23B9 "RIGHT VERTICAL BOX LINE"
\u23BA "HORIZONTAL SCAN LINE-1"
\u23BB "HORIZONTAL SCAN LINE-3"
\u23BC "HORIZONTAL SCAN LINE-7"
\u23BD "HORIZONTAL SCAN LINE-9"
\u23BE "DENTISTRY SYMBOL LIGHT VERTICAL AND TOP RIGHT"
\u23BF "DENTISTRY SYMBOL LIGHT VERTICAL AND BOTTOM RIGHT"
\u23C0 "DENTISTRY SYMBOL LIGHT VERTICAL WITH CIRCLE"
\u23C1 "DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH CIRCLE"
\u23C2 "DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH CIRCLE"
\u23C3 "DENTISTRY SYMBOL LIGHT VERTICAL WITH TRIANGLE"
\u23C4 "DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH TRIANGLE"
\u23C5 "DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH TRIANGLE"
\u23C6 "DENTISTRY SYMBOL LIGHT VERTICAL AND WAVE"
\u23C7 "DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL WITH WAVE"
\u23C8 "DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL WITH WAVE"
\u23C9 "DENTISTRY SYMBOL LIGHT DOWN AND HORIZONTAL"
\u23CA "DENTISTRY SYMBOL LIGHT UP AND HORIZONTAL"
\u23CB "DENTISTRY SYMBOL LIGHT VERTICAL AND TOP LEFT"
\u23CC "DENTISTRY SYMBOL LIGHT VERTICAL AND BOTTOM LEFT"
\u23CD "SQUARE FOOT"
\u23CE "RETURN SYMBOL"
\u23CF "EJECT SYMBOL"
\u23D0 "VERTICAL LINE EXTENSION"
\u23D1 "METRICAL BREVE"
\u23D2 "METRICAL LONG OVER SHORT"
\u23D3 "METRICAL SHORT OVER LONG"
\u23D4 "METRICAL LONG OVER TWO SHORTS"
\u23D5 "METRICAL TWO SHORTS OVER LONG"
\u23D6 "METRICAL TWO SHORTS JOINED"
\u23D7 "METRICAL TRISEME"
\u23D8 "METRICAL TETRASEME"
\u23D9 "METRICAL PENTASEME"
\u23DA "EARTH GROUND"
\u23DB "FUSE"
\u23DC "TOP PARENTHESIS"
\u23DD "BOTTOM PARENTHESIS"
\u23DE "TOP CURLY BRACKET"
\u23DF "BOTTOM CURLY BRACKET"
\u23E0 "TOP TORTOISE SHELL BRACKET"
\u23E1 "BOTTOM TORTOISE SHELL BRACKET"
\u23E2 "WHITE TRAPEZIUM"
\u23E3 "BENZENE RING WITH CIRCLE"
\u23E4 "STRAIGHTNESS"
\u23E5 "FLATNESS"
\u23E6 "AC CURRENT"
\u23E7 "ELECTRICAL INTERSECTION"
\u2400 "SYMBOL FOR NULL"
\u2401 "SYMBOL FOR START OF HEADING"
\u2402 "SYMBOL FOR START OF TEXT"
\u2403 "SYMBOL FOR END OF TEXT"
\u2404 "SYMBOL FOR END OF TRANSMISSION"
\u2405 "SYMBOL FOR ENQUIRY"
\u2406 "SYMBOL FOR ACKNOWLEDGE"
\u2407 "SYMBOL FOR BELL"
\u2408 "SYMBOL FOR BACKSPACE"
\u2409 "SYMBOL FOR HORIZONTAL TABULATION"
\u240A "SYMBOL FOR LINE FEED"
\u240B "SYMBOL FOR VERTICAL TABULATION"
\u240C "SYMBOL FOR FORM FEED"
\u240D "SYMBOL FOR CARRIAGE RETURN"
\u240E "SYMBOL FOR SHIFT OUT"
\u240F "SYMBOL FOR SHIFT IN"
\u2410 "SYMBOL FOR DATA LINK ESCAPE"
\u2411 "SYMBOL FOR DEVICE CONTROL ONE"
\u2412 "SYMBOL FOR DEVICE CONTROL TWO"
\u2413 "SYMBOL FOR DEVICE CONTROL THREE"
\u2414 "SYMBOL FOR DEVICE CONTROL FOUR"
\u2415 "SYMBOL FOR NEGATIVE ACKNOWLEDGE"
\u2416 "SYMBOL FOR SYNCHRONOUS IDLE"
\u2417 "SYMBOL FOR END OF TRANSMISSION BLOCK"
\u2418 "SYMBOL FOR CANCEL"
\u2419 "SYMBOL FOR END OF MEDIUM"
\u241A "SYMBOL FOR SUBSTITUTE"
\u241B "SYMBOL FOR ESCAPE"
\u241C "SYMBOL FOR FILE SEPARATOR"
\u241D "SYMBOL FOR GROUP SEPARATOR"
\u241E "SYMBOL FOR RECORD SEPARATOR"
\u241F "SYMBOL FOR UNIT SEPARATOR"
\u2420 "SYMBOL FOR SPACE"
\u2421 "SYMBOL FOR DELETE"
\u2422 "BLANK SYMBOL"
\u2423 "OPEN BOX"
\u2424 "SYMBOL FOR NEWLINE"
\u2425 "SYMBOL FOR DELETE FORM TWO"
\u2426 "SYMBOL FOR SUBSTITUTE FORM TWO"
\u2440 "OCR HOOK"
\u2441 "OCR CHAIR"
\u2442 "OCR FORK"
\u2443 "OCR INVERTED FORK"
\u2444 "OCR BELT BUCKLE"
\u2445 "OCR BOW TIE"
\u2446 "OCR BRANCH BANK IDENTIFICATION"
\u2447 "OCR AMOUNT OF CHECK"
\u2448 "OCR DASH"
\u2449 "OCR CUSTOMER ACCOUNT NUMBER"
\u244A "OCR DOUBLE BACKSLASH"
\u2460 "CIRCLED DIGIT ONE"
\u2461 "CIRCLED DIGIT TWO"
\u2462 "CIRCLED DIGIT THREE"
\u2463 "CIRCLED DIGIT FOUR"
\u2464 "CIRCLED DIGIT FIVE"
\u2465 "CIRCLED DIGIT SIX"
\u2466 "CIRCLED DIGIT SEVEN"
\u2467 "CIRCLED DIGIT EIGHT"
\u2468 "CIRCLED DIGIT NINE"
\u2469 "CIRCLED NUMBER TEN"
\u246A "CIRCLED NUMBER ELEVEN"
\u246B "CIRCLED NUMBER TWELVE"
\u246C "CIRCLED NUMBER THIRTEEN"
\u246D "CIRCLED NUMBER FOURTEEN"
\u246E "CIRCLED NUMBER FIFTEEN"
\u246F "CIRCLED NUMBER SIXTEEN"
\u2470 "CIRCLED NUMBER SEVENTEEN"
\u2471 "CIRCLED NUMBER EIGHTEEN"
\u2472 "CIRCLED NUMBER NINETEEN"
\u2473 "CIRCLED NUMBER TWENTY"
\u2474 "PARENTHESIZED DIGIT ONE"
\u2475 "PARENTHESIZED DIGIT TWO"
\u2476 "PARENTHESIZED DIGIT THREE"
\u2477 "PARENTHESIZED DIGIT FOUR"
\u2478 "PARENTHESIZED DIGIT FIVE"
\u2479 "PARENTHESIZED DIGIT SIX"
\u247A "PARENTHESIZED DIGIT SEVEN"
\u247B "PARENTHESIZED DIGIT EIGHT"
\u247C "PARENTHESIZED DIGIT NINE"
\u247D "PARENTHESIZED NUMBER TEN"
\u247E "PARENTHESIZED NUMBER ELEVEN"
\u247F "PARENTHESIZED NUMBER TWELVE"
\u2480 "PARENTHESIZED NUMBER THIRTEEN"
\u2481 "PARENTHESIZED NUMBER FOURTEEN"
\u2482 "PARENTHESIZED NUMBER FIFTEEN"
\u2483 "PARENTHESIZED NUMBER SIXTEEN"
\u2484 "PARENTHESIZED NUMBER SEVENTEEN"
\u2485 "PARENTHESIZED NUMBER EIGHTEEN"
\u2486 "PARENTHESIZED NUMBER NINETEEN"
\u2487 "PARENTHESIZED NUMBER TWENTY"
\u2488 "DIGIT ONE FULL STOP"
\u2489 "DIGIT TWO FULL STOP"
\u248A "DIGIT THREE FULL STOP"
\u248B "DIGIT FOUR FULL STOP"
\u248C "DIGIT FIVE FULL STOP"
\u248D "DIGIT SIX FULL STOP"
\u248E "DIGIT SEVEN FULL STOP"
\u248F "DIGIT EIGHT FULL STOP"
\u2490 "DIGIT NINE FULL STOP"
\u2491 "NUMBER TEN FULL STOP"
\u2492 "NUMBER ELEVEN FULL STOP"
\u2493 "NUMBER TWELVE FULL STOP"
\u2494 "NUMBER THIRTEEN FULL STOP"
\u2495 "NUMBER FOURTEEN FULL STOP"
\u2496 "NUMBER FIFTEEN FULL STOP"
\u2497 "NUMBER SIXTEEN FULL STOP"
\u2498 "NUMBER SEVENTEEN FULL STOP"
\u2499 "NUMBER EIGHTEEN FULL STOP"
\u249A "NUMBER NINETEEN FULL STOP"
\u249B "NUMBER TWENTY FULL STOP"
\u249C "PARENTHESIZED LATIN SMALL LETTER A"
\u249D "PARENTHESIZED LATIN SMALL LETTER B"
\u249E "PARENTHESIZED LATIN SMALL LETTER C"
\u249F "PARENTHESIZED LATIN SMALL LETTER D"
\u24A0 "PARENTHESIZED LATIN SMALL LETTER E"
\u24A1 "PARENTHESIZED LATIN SMALL LETTER F"
\u24A2 "PARENTHESIZED LATIN SMALL LETTER G"
\u24A3 "PARENTHESIZED LATIN SMALL LETTER H"
\u24A4 "PARENTHESIZED LATIN SMALL LETTER I"
\u24A5 "PARENTHESIZED LATIN SMALL LETTER J"
\u24A6 "PARENTHESIZED LATIN SMALL LETTER K"
\u24A7 "PARENTHESIZED LATIN SMALL LETTER L"
\u24A8 "PARENTHESIZED LATIN SMALL LETTER M"
\u24A9 "PARENTHESIZED LATIN SMALL LETTER N"
\u24AA "PARENTHESIZED LATIN SMALL LETTER O"
\u24AB "PARENTHESIZED LATIN SMALL LETTER P"
\u24AC "PARENTHESIZED LATIN SMALL LETTER Q"
\u24AD "PARENTHESIZED LATIN SMALL LETTER R"
\u24AE "PARENTHESIZED LATIN SMALL LETTER S"
\u24AF "PARENTHESIZED LATIN SMALL LETTER T"
\u24B0 "PARENTHESIZED LATIN SMALL LETTER U"
\u24B1 "PARENTHESIZED LATIN SMALL LETTER V"
\u24B2 "PARENTHESIZED LATIN SMALL LETTER W"
\u24B3 "PARENTHESIZED LATIN SMALL LETTER X"
\u24B4 "PARENTHESIZED LATIN SMALL LETTER Y"
\u24B5 "PARENTHESIZED LATIN SMALL LETTER Z"
\u24B6 "CIRCLED LATIN CAPITAL LETTER A"
\u24B7 "CIRCLED LATIN CAPITAL LETTER B"
\u24B8 "CIRCLED LATIN CAPITAL LETTER C"
\u24B9 "CIRCLED LATIN CAPITAL LETTER D"
\u24BA "CIRCLED LATIN CAPITAL LETTER E"
\u24BB "CIRCLED LATIN CAPITAL LETTER F"
\u24BC "CIRCLED LATIN CAPITAL LETTER G"
\u24BD "CIRCLED LATIN CAPITAL LETTER H"
\u24BE "CIRCLED LATIN CAPITAL LETTER I"
\u24BF "CIRCLED LATIN CAPITAL LETTER J"
\u24C0 "CIRCLED LATIN CAPITAL LETTER K"
\u24C1 "CIRCLED LATIN CAPITAL LETTER L"
\u24C2 "CIRCLED LATIN CAPITAL LETTER M"
\u24C3 "CIRCLED LATIN CAPITAL LETTER N"
\u24C4 "CIRCLED LATIN CAPITAL LETTER O"
\u24C5 "CIRCLED LATIN CAPITAL LETTER P"
\u24C6 "CIRCLED LATIN CAPITAL LETTER Q"
\u24C7 "CIRCLED LATIN CAPITAL LETTER R"
\u24C8 "CIRCLED LATIN CAPITAL LETTER S"
\u24C9 "CIRCLED LATIN CAPITAL LETTER T"
\u24CA "CIRCLED LATIN CAPITAL LETTER U"
\u24CB "CIRCLED LATIN CAPITAL LETTER V"
\u24CC "CIRCLED LATIN CAPITAL LETTER W"
\u24CD "CIRCLED LATIN CAPITAL LETTER X"
\u24CE "CIRCLED LATIN CAPITAL LETTER Y"
\u24CF "CIRCLED LATIN CAPITAL LETTER Z"
\u24D0 "CIRCLED LATIN SMALL LETTER A"
\u24D1 "CIRCLED LATIN SMALL LETTER B"
\u24D2 "CIRCLED LATIN SMALL LETTER C"
\u24D3 "CIRCLED LATIN SMALL LETTER D"
\u24D4 "CIRCLED LATIN SMALL LETTER E"
\u24D5 "CIRCLED LATIN SMALL LETTER F"
\u24D6 "CIRCLED LATIN SMALL LETTER G"
\u24D7 "CIRCLED LATIN SMALL LETTER H"
\u24D8 "CIRCLED LATIN SMALL LETTER I"
\u24D9 "CIRCLED LATIN SMALL LETTER J"
\u24DA "CIRCLED LATIN SMALL LETTER K"
\u24DB "CIRCLED LATIN SMALL LETTER L"
\u24DC "CIRCLED LATIN SMALL LETTER M"
\u24DD "CIRCLED LATIN SMALL LETTER N"
\u24DE "CIRCLED LATIN SMALL LETTER O"
\u24DF "CIRCLED LATIN SMALL LETTER P"
\u24E0 "CIRCLED LATIN SMALL LETTER Q"
\u24E1 "CIRCLED LATIN SMALL LETTER R"
\u24E2 "CIRCLED LATIN SMALL LETTER S"
\u24E3 "CIRCLED LATIN SMALL LETTER T"
\u24E4 "CIRCLED LATIN SMALL LETTER U"
\u24E5 "CIRCLED LATIN SMALL LETTER V"
\u24E6 "CIRCLED LATIN SMALL LETTER W"
\u24E7 "CIRCLED LATIN SMALL LETTER X"
\u24E8 "CIRCLED LATIN SMALL LETTER Y"
\u24E9 "CIRCLED LATIN SMALL LETTER Z"
\u24EA "CIRCLED DIGIT ZERO"
\u24EB "NEGATIVE CIRCLED NUMBER ELEVEN"
\u24EC "NEGATIVE CIRCLED NUMBER TWELVE"
\u24ED "NEGATIVE CIRCLED NUMBER THIRTEEN"
\u24EE "NEGATIVE CIRCLED NUMBER FOURTEEN"
\u24EF "NEGATIVE CIRCLED NUMBER FIFTEEN"
\u24F0 "NEGATIVE CIRCLED NUMBER SIXTEEN"
\u24F1 "NEGATIVE CIRCLED NUMBER SEVENTEEN"
\u24F2 "NEGATIVE CIRCLED NUMBER EIGHTEEN"
\u24F3 "NEGATIVE CIRCLED NUMBER NINETEEN"
\u24F4 "NEGATIVE CIRCLED NUMBER TWENTY"
\u24F5 "DOUBLE CIRCLED DIGIT ONE"
\u24F6 "DOUBLE CIRCLED DIGIT TWO"
\u24F7 "DOUBLE CIRCLED DIGIT THREE"
\u24F8 "DOUBLE CIRCLED DIGIT FOUR"
\u24F9 "DOUBLE CIRCLED DIGIT FIVE"
\u24FA "DOUBLE CIRCLED DIGIT SIX"
\u24FB "DOUBLE CIRCLED DIGIT SEVEN"
\u24FC "DOUBLE CIRCLED DIGIT EIGHT"
\u24FD "DOUBLE CIRCLED DIGIT NINE"
\u24FE "DOUBLE CIRCLED NUMBER TEN"
\u24FF "NEGATIVE CIRCLED DIGIT ZERO"
\u2500 "BOX DRAWINGS LIGHT HORIZONTAL"
\u2501 "BOX DRAWINGS HEAVY HORIZONTAL"
\u2502 "BOX DRAWINGS LIGHT VERTICAL"
\u2503 "BOX DRAWINGS HEAVY VERTICAL"
\u2504 "BOX DRAWINGS LIGHT TRIPLE DASH HORIZONTAL"
\u2505 "BOX DRAWINGS HEAVY TRIPLE DASH HORIZONTAL"
\u2506 "BOX DRAWINGS LIGHT TRIPLE DASH VERTICAL"
\u2507 "BOX DRAWINGS HEAVY TRIPLE DASH VERTICAL"
\u2508 "BOX DRAWINGS LIGHT QUADRUPLE DASH HORIZONTAL"
\u2509 "BOX DRAWINGS HEAVY QUADRUPLE DASH HORIZONTAL"
\u250A "BOX DRAWINGS LIGHT QUADRUPLE DASH VERTICAL"
\u250B "BOX DRAWINGS HEAVY QUADRUPLE DASH VERTICAL"
\u250C "BOX DRAWINGS LIGHT DOWN AND RIGHT"
\u250D "BOX DRAWINGS DOWN LIGHT AND RIGHT HEAVY"
\u250E "BOX DRAWINGS DOWN HEAVY AND RIGHT LIGHT"
\u250F "BOX DRAWINGS HEAVY DOWN AND RIGHT"
\u2510 "BOX DRAWINGS LIGHT DOWN AND LEFT"
\u2511 "BOX DRAWINGS DOWN LIGHT AND LEFT HEAVY"
\u2512 "BOX DRAWINGS DOWN HEAVY AND LEFT LIGHT"
\u2513 "BOX DRAWINGS HEAVY DOWN AND LEFT"
\u2514 "BOX DRAWINGS LIGHT UP AND RIGHT"
\u2515 "BOX DRAWINGS UP LIGHT AND RIGHT HEAVY"
\u2516 "BOX DRAWINGS UP HEAVY AND RIGHT LIGHT"
\u2517 "BOX DRAWINGS HEAVY UP AND RIGHT"
\u2518 "BOX DRAWINGS LIGHT UP AND LEFT"
\u2519 "BOX DRAWINGS UP LIGHT AND LEFT HEAVY"
\u251A "BOX DRAWINGS UP HEAVY AND LEFT LIGHT"
\u251B "BOX DRAWINGS HEAVY UP AND LEFT"
\u251C "BOX DRAWINGS LIGHT VERTICAL AND RIGHT"
\u251D "BOX DRAWINGS VERTICAL LIGHT AND RIGHT HEAVY"
\u251E "BOX DRAWINGS UP HEAVY AND RIGHT DOWN LIGHT"
\u251F "BOX DRAWINGS DOWN HEAVY AND RIGHT UP LIGHT"
\u2520 "BOX DRAWINGS VERTICAL HEAVY AND RIGHT LIGHT"
\u2521 "BOX DRAWINGS DOWN LIGHT AND RIGHT UP HEAVY"
\u2522 "BOX DRAWINGS UP LIGHT AND RIGHT DOWN HEAVY"
\u2523 "BOX DRAWINGS HEAVY VERTICAL AND RIGHT"
\u2524 "BOX DRAWINGS LIGHT VERTICAL AND LEFT"
\u2525 "BOX DRAWINGS VERTICAL LIGHT AND LEFT HEAVY"
\u2526 "BOX DRAWINGS UP HEAVY AND LEFT DOWN LIGHT"
\u2527 "BOX DRAWINGS DOWN HEAVY AND LEFT UP LIGHT"
\u2528 "BOX DRAWINGS VERTICAL HEAVY AND LEFT LIGHT"
\u2529 "BOX DRAWINGS DOWN LIGHT AND LEFT UP HEAVY"
\u252A "BOX DRAWINGS UP LIGHT AND LEFT DOWN HEAVY"
\u252B "BOX DRAWINGS HEAVY VERTICAL AND LEFT"
\u252C "BOX DRAWINGS LIGHT DOWN AND HORIZONTAL"
\u252D "BOX DRAWINGS LEFT HEAVY AND RIGHT DOWN LIGHT"
\u252E "BOX DRAWINGS RIGHT HEAVY AND LEFT DOWN LIGHT"
\u252F "BOX DRAWINGS DOWN LIGHT AND HORIZONTAL HEAVY"
\u2530 "BOX DRAWINGS DOWN HEAVY AND HORIZONTAL LIGHT"
\u2531 "BOX DRAWINGS RIGHT LIGHT AND LEFT DOWN HEAVY"
\u2532 "BOX DRAWINGS LEFT LIGHT AND RIGHT DOWN HEAVY"
\u2533 "BOX DRAWINGS HEAVY DOWN AND HORIZONTAL"
\u2534 "BOX DRAWINGS LIGHT UP AND HORIZONTAL"
\u2535 "BOX DRAWINGS LEFT HEAVY AND RIGHT UP LIGHT"
\u2536 "BOX DRAWINGS RIGHT HEAVY AND LEFT UP LIGHT"
\u2537 "BOX DRAWINGS UP LIGHT AND HORIZONTAL HEAVY"
\u2538 "BOX DRAWINGS UP HEAVY AND HORIZONTAL LIGHT"
\u2539 "BOX DRAWINGS RIGHT LIGHT AND LEFT UP HEAVY"
\u253A "BOX DRAWINGS LEFT LIGHT AND RIGHT UP HEAVY"
\u253B "BOX DRAWINGS HEAVY UP AND HORIZONTAL"
\u253C "BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL"
\u253D "BOX DRAWINGS LEFT HEAVY AND RIGHT VERTICAL LIGHT"
\u253E "BOX DRAWINGS RIGHT HEAVY AND LEFT VERTICAL LIGHT"
\u253F "BOX DRAWINGS VERTICAL LIGHT AND HORIZONTAL HEAVY"
\u2540 "BOX DRAWINGS UP HEAVY AND DOWN HORIZONTAL LIGHT"
\u2541 "BOX DRAWINGS DOWN HEAVY AND UP HORIZONTAL LIGHT"
\u2542 "BOX DRAWINGS VERTICAL HEAVY AND HORIZONTAL LIGHT"
\u2543 "BOX DRAWINGS LEFT UP HEAVY AND RIGHT DOWN LIGHT"
\u2544 "BOX DRAWINGS RIGHT UP HEAVY AND LEFT DOWN LIGHT"
\u2545 "BOX DRAWINGS LEFT DOWN HEAVY AND RIGHT UP LIGHT"
\u2546 "BOX DRAWINGS RIGHT DOWN HEAVY AND LEFT UP LIGHT"
\u2547 "BOX DRAWINGS DOWN LIGHT AND UP HORIZONTAL HEAVY"
\u2548 "BOX DRAWINGS UP LIGHT AND DOWN HORIZONTAL HEAVY"
\u2549 "BOX DRAWINGS RIGHT LIGHT AND LEFT VERTICAL HEAVY"
\u254A "BOX DRAWINGS LEFT LIGHT AND RIGHT VERTICAL HEAVY"
\u254B "BOX DRAWINGS HEAVY VERTICAL AND HORIZONTAL"
\u254C "BOX DRAWINGS LIGHT DOUBLE DASH HORIZONTAL"
\u254D "BOX DRAWINGS HEAVY DOUBLE DASH HORIZONTAL"
\u254E "BOX DRAWINGS LIGHT DOUBLE DASH VERTICAL"
\u254F "BOX DRAWINGS HEAVY DOUBLE DASH VERTICAL"
\u2550 "BOX DRAWINGS DOUBLE HORIZONTAL"
\u2551 "BOX DRAWINGS DOUBLE VERTICAL"
\u2552 "BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE"
\u2553 "BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE"
\u2554 "BOX DRAWINGS DOUBLE DOWN AND RIGHT"
\u2555 "BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE"
\u2556 "BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE"
\u2557 "BOX DRAWINGS DOUBLE DOWN AND LEFT"
\u2558 "BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE"
\u2559 "BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE"
\u255A "BOX DRAWINGS DOUBLE UP AND RIGHT"
\u255B "BOX DRAWINGS UP SINGLE AND LEFT DOUBLE"
\u255C "BOX DRAWINGS UP DOUBLE AND LEFT SINGLE"
\u255D "BOX DRAWINGS DOUBLE UP AND LEFT"
\u255E "BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE"
\u255F "BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE"
\u2560 "BOX DRAWINGS DOUBLE VERTICAL AND RIGHT"
\u2561 "BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE"
\u2562 "BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE"
\u2563 "BOX DRAWINGS DOUBLE VERTICAL AND LEFT"
\u2564 "BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE"
\u2565 "BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE"
\u2566 "BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL"
\u2567 "BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE"
\u2568 "BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE"
\u2569 "BOX DRAWINGS DOUBLE UP AND HORIZONTAL"
\u256A "BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE"
\u256B "BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE"
\u256C "BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL"
\u256D "BOX DRAWINGS LIGHT ARC DOWN AND RIGHT"
\u256E "BOX DRAWINGS LIGHT ARC DOWN AND LEFT"
\u256F "BOX DRAWINGS LIGHT ARC UP AND LEFT"
\u2570 "BOX DRAWINGS LIGHT ARC UP AND RIGHT"
\u2571 "BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT"
\u2572 "BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT"
\u2573 "BOX DRAWINGS LIGHT DIAGONAL CROSS"
\u2574 "BOX DRAWINGS LIGHT LEFT"
\u2575 "BOX DRAWINGS LIGHT UP"
\u2576 "BOX DRAWINGS LIGHT RIGHT"
\u2577 "BOX DRAWINGS LIGHT DOWN"
\u2578 "BOX DRAWINGS HEAVY LEFT"
\u2579 "BOX DRAWINGS HEAVY UP"
\u257A "BOX DRAWINGS HEAVY RIGHT"
\u257B "BOX DRAWINGS HEAVY DOWN"
\u257C "BOX DRAWINGS LIGHT LEFT AND HEAVY RIGHT"
\u257D "BOX DRAWINGS LIGHT UP AND HEAVY DOWN"
\u257E "BOX DRAWINGS HEAVY LEFT AND LIGHT RIGHT"
\u257F "BOX DRAWINGS HEAVY UP AND LIGHT DOWN"
\u2580 "UPPER HALF BLOCK"
\u2581 "LOWER ONE EIGHTH BLOCK"
\u2582 "LOWER ONE QUARTER BLOCK"
\u2583 "LOWER THREE EIGHTHS BLOCK"
\u2584 "LOWER HALF BLOCK"
\u2585 "LOWER FIVE EIGHTHS BLOCK"
\u2586 "LOWER THREE QUARTERS BLOCK"
\u2587 "LOWER SEVEN EIGHTHS BLOCK"
\u2588 "FULL BLOCK"
\u2589 "LEFT SEVEN EIGHTHS BLOCK"
\u258A "LEFT THREE QUARTERS BLOCK"
\u258B "LEFT FIVE EIGHTHS BLOCK"
\u258C "LEFT HALF BLOCK"
\u258D "LEFT THREE EIGHTHS BLOCK"
\u258E "LEFT ONE QUARTER BLOCK"
\u258F "LEFT ONE EIGHTH BLOCK"
\u2590 "RIGHT HALF BLOCK"
\u2591 "LIGHT SHADE"
\u2592 "MEDIUM SHADE"
\u2593 "DARK SHADE"
\u2594 "UPPER ONE EIGHTH BLOCK"
\u2595 "RIGHT ONE EIGHTH BLOCK"
\u2596 "QUADRANT LOWER LEFT"
\u2597 "QUADRANT LOWER RIGHT"
\u2598 "QUADRANT UPPER LEFT"
\u2599 "QUADRANT UPPER LEFT AND LOWER LEFT AND LOWER RIGHT"
\u259A "QUADRANT UPPER LEFT AND LOWER RIGHT"
\u259B "QUADRANT UPPER LEFT AND UPPER RIGHT AND LOWER LEFT"
\u259C "QUADRANT UPPER LEFT AND UPPER RIGHT AND LOWER RIGHT"
\u259D "QUADRANT UPPER RIGHT"
\u259E "QUADRANT UPPER RIGHT AND LOWER LEFT"
\u259F "QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT"
\u25A0 "BLACK SQUARE"
\u25A1 "WHITE SQUARE"
\u25A2 "WHITE SQUARE WITH ROUNDED CORNERS"
\u25A3 "WHITE SQUARE CONTAINING BLACK SMALL SQUARE"
\u25A4 "SQUARE WITH HORIZONTAL FILL"
\u25A5 "SQUARE WITH VERTICAL FILL"
\u25A6 "SQUARE WITH ORTHOGONAL CROSSHATCH FILL"
\u25A7 "SQUARE WITH UPPER LEFT TO LOWER RIGHT FILL"
\u25A8 "SQUARE WITH UPPER RIGHT TO LOWER LEFT FILL"
\u25A9 "SQUARE WITH DIAGONAL CROSSHATCH FILL"
\u25AA "BLACK SMALL SQUARE"
\u25AB "WHITE SMALL SQUARE"
\u25AC "BLACK RECTANGLE"
\u25AD "WHITE RECTANGLE"
\u25AE "BLACK VERTICAL RECTANGLE"
\u25AF "WHITE VERTICAL RECTANGLE"
\u25B0 "BLACK PARALLELOGRAM"
\u25B1 "WHITE PARALLELOGRAM"
\u25B2 "BLACK UP-POINTING TRIANGLE"
\u25B3 "WHITE UP-POINTING TRIANGLE"
\u25B4 "BLACK UP-POINTING SMALL TRIANGLE"
\u25B5 "WHITE UP-POINTING SMALL TRIANGLE"
\u25B6 "BLACK RIGHT-POINTING TRIANGLE"
\u25B7 "WHITE RIGHT-POINTING TRIANGLE"
\u25B8 "BLACK RIGHT-POINTING SMALL TRIANGLE"
\u25B9 "WHITE RIGHT-POINTING SMALL TRIANGLE"
\u25BA "BLACK RIGHT-POINTING POINTER"
\u25BB "WHITE RIGHT-POINTING POINTER"
\u25BC "BLACK DOWN-POINTING TRIANGLE"
\u25BD "WHITE DOWN-POINTING TRIANGLE"
\u25BE "BLACK DOWN-POINTING SMALL TRIANGLE"
\u25BF "WHITE DOWN-POINTING SMALL TRIANGLE"
\u25C0 "BLACK LEFT-POINTING TRIANGLE"
\u25C1 "WHITE LEFT-POINTING TRIANGLE"
\u25C2 "BLACK LEFT-POINTING SMALL TRIANGLE"
\u25C3 "WHITE LEFT-POINTING SMALL TRIANGLE"
\u25C4 "BLACK LEFT-POINTING POINTER"
\u25C5 "WHITE LEFT-POINTING POINTER"
\u25C6 "BLACK DIAMOND"
\u25C7 "WHITE DIAMOND"
\u25C8 "WHITE DIAMOND CONTAINING BLACK SMALL DIAMOND"
\u25C9 "FISHEYE"
\u25CA "LOZENGE"
\u25CB "WHITE CIRCLE"
\u25CC "DOTTED CIRCLE"
\u25CD "CIRCLE WITH VERTICAL FILL"
\u25CE "BULLSEYE"
\u25CF "BLACK CIRCLE"
\u25D0 "CIRCLE WITH LEFT HALF BLACK"
\u25D1 "CIRCLE WITH RIGHT HALF BLACK"
\u25D2 "CIRCLE WITH LOWER HALF BLACK"
\u25D3 "CIRCLE WITH UPPER HALF BLACK"
\u25D4 "CIRCLE WITH UPPER RIGHT QUADRANT BLACK"
\u25D5 "CIRCLE WITH ALL BUT UPPER LEFT QUADRANT BLACK"
\u25D6 "LEFT HALF BLACK CIRCLE"
\u25D7 "RIGHT HALF BLACK CIRCLE"
\u25D8 "INVERSE BULLET"
\u25D9 "INVERSE WHITE CIRCLE"
\u25DA "UPPER HALF INVERSE WHITE CIRCLE"
\u25DB "LOWER HALF INVERSE WHITE CIRCLE"
\u25DC "UPPER LEFT QUADRANT CIRCULAR ARC"
\u25DD "UPPER RIGHT QUADRANT CIRCULAR ARC"
\u25DE "LOWER RIGHT QUADRANT CIRCULAR ARC"
\u25DF "LOWER LEFT QUADRANT CIRCULAR ARC"
\u25E0 "UPPER HALF CIRCLE"
\u25E1 "LOWER HALF CIRCLE"
\u25E2 "BLACK LOWER RIGHT TRIANGLE"
\u25E3 "BLACK LOWER LEFT TRIANGLE"
\u25E4 "BLACK UPPER LEFT TRIANGLE"
\u25E5 "BLACK UPPER RIGHT TRIANGLE"
\u25E6 "WHITE BULLET"
\u25E7 "SQUARE WITH LEFT HALF BLACK"
\u25E8 "SQUARE WITH RIGHT HALF BLACK"
\u25E9 "SQUARE WITH UPPER LEFT DIAGONAL HALF BLACK"
\u25EA "SQUARE WITH LOWER RIGHT DIAGONAL HALF BLACK"
\u25EB "WHITE SQUARE WITH VERTICAL BISECTING LINE"
\u25EC "WHITE UP-POINTING TRIANGLE WITH DOT"
\u25ED "UP-POINTING TRIANGLE WITH LEFT HALF BLACK"
\u25EE "UP-POINTING TRIANGLE WITH RIGHT HALF BLACK"
\u25EF "LARGE CIRCLE"
\u25F0 "WHITE SQUARE WITH UPPER LEFT QUADRANT"
\u25F1 "WHITE SQUARE WITH LOWER LEFT QUADRANT"
\u25F2 "WHITE SQUARE WITH LOWER RIGHT QUADRANT"
\u25F3 "WHITE SQUARE WITH UPPER RIGHT QUADRANT"
\u25F4 "WHITE CIRCLE WITH UPPER LEFT QUADRANT"
\u25F5 "WHITE CIRCLE WITH LOWER LEFT QUADRANT"
\u25F6 "WHITE CIRCLE WITH LOWER RIGHT QUADRANT"
\u25F7 "WHITE CIRCLE WITH UPPER RIGHT QUADRANT"
\u25F8 "UPPER LEFT TRIANGLE"
\u25F9 "UPPER RIGHT TRIANGLE"
\u25FA "LOWER LEFT TRIANGLE"
\u25FB "WHITE MEDIUM SQUARE"
\u25FC "BLACK MEDIUM SQUARE"
\u25FD "WHITE MEDIUM SMALL SQUARE"
\u25FE "BLACK MEDIUM SMALL SQUARE"
\u25FF "LOWER RIGHT TRIANGLE"
\u2600 "BLACK SUN WITH RAYS"
\u2601 "CLOUD"
\u2602 "UMBRELLA"
\u2603 "SNOWMAN"
\u2604 "COMET"
\u2605 "BLACK STAR"
\u2606 "WHITE STAR"
\u2607 "LIGHTNING"
\u2608 "THUNDERSTORM"
\u2609 "SUN"
\u260A "ASCENDING NODE"
\u260B "DESCENDING NODE"
\u260C "CONJUNCTION"
\u260D "OPPOSITION"
\u260E "BLACK TELEPHONE"
\u260F "WHITE TELEPHONE"
\u2610 "BALLOT BOX"
\u2611 "BALLOT BOX WITH CHECK"
\u2612 "BALLOT BOX WITH X"
\u2613 "SALTIRE"
\u2614 "UMBRELLA WITH RAIN DROPS"
\u2615 "HOT BEVERAGE"
\u2616 "WHITE SHOGI PIECE"
\u2617 "BLACK SHOGI PIECE"
\u2618 "SHAMROCK"
\u2619 "REVERSED ROTATED FLORAL HEART BULLET"
\u261A "BLACK LEFT POINTING INDEX"
\u261B "BLACK RIGHT POINTING INDEX"
\u261C "WHITE LEFT POINTING INDEX"
\u261D "WHITE UP POINTING INDEX"
\u261E "WHITE RIGHT POINTING INDEX"
\u261F "WHITE DOWN POINTING INDEX"
\u2620 "SKULL AND CROSSBONES"
\u2621 "CAUTION SIGN"
\u2622 "RADIOACTIVE SIGN"
\u2623 "BIOHAZARD SIGN"
\u2624 "CADUCEUS"
\u2625 "ANKH"
\u2626 "ORTHODOX CROSS"
\u2627 "CHI RHO"
\u2628 "CROSS OF LORRAINE"
\u2629 "CROSS OF JERUSALEM"
\u262A "STAR AND CRESCENT"
\u262B "FARSI SYMBOL"
\u262C "ADI SHAKTI"
\u262D "HAMMER AND SICKLE"
\u262E "PEACE SYMBOL"
\u262F "YIN YANG"
\u2630 "TRIGRAM FOR HEAVEN"
\u2631 "TRIGRAM FOR LAKE"
\u2632 "TRIGRAM FOR FIRE"
\u2633 "TRIGRAM FOR THUNDER"
\u2634 "TRIGRAM FOR WIND"
\u2635 "TRIGRAM FOR WATER"
\u2636 "TRIGRAM FOR MOUNTAIN"
\u2637 "TRIGRAM FOR EARTH"
\u2638 "WHEEL OF DHARMA"
\u2639 "WHITE FROWNING FACE"
\u263A "WHITE SMILING FACE"
\u263B "BLACK SMILING FACE"
\u263C "WHITE SUN WITH RAYS"
\u263D "FIRST QUARTER MOON"
\u263E "LAST QUARTER MOON"
\u263F "MERCURY"
\u2640 "FEMALE SIGN"
\u2641 "EARTH"
\u2642 "MALE SIGN"
\u2643 "JUPITER"
\u2644 "SATURN"
\u2645 "URANUS"
\u2646 "NEPTUNE"
\u2647 "PLUTO"
\u2648 "ARIES"
\u2649 "TAURUS"
\u264A "GEMINI"
\u264B "CANCER"
\u264C "LEO"
\u264D "VIRGO"
\u264E "LIBRA"
\u264F "SCORPIUS"
\u2650 "SAGITTARIUS"
\u2651 "CAPRICORN"
\u2652 "AQUARIUS"
\u2653 "PISCES"
\u2654 "WHITE CHESS KING"
\u2655 "WHITE CHESS QUEEN"
\u2656 "WHITE CHESS ROOK"
\u2657 "WHITE CHESS BISHOP"
\u2658 "WHITE CHESS KNIGHT"
\u2659 "WHITE CHESS PAWN"
\u265A "BLACK CHESS KING"
\u265B "BLACK CHESS QUEEN"
\u265C "BLACK CHESS ROOK"
\u265D "BLACK CHESS BISHOP"
\u265E "BLACK CHESS KNIGHT"
\u265F "BLACK CHESS PAWN"
\u2660 "BLACK SPADE SUIT"
\u2661 "WHITE HEART SUIT"
\u2662 "WHITE DIAMOND SUIT"
\u2663 "BLACK CLUB SUIT"
\u2664 "WHITE SPADE SUIT"
\u2665 "BLACK HEART SUIT"
\u2666 "BLACK DIAMOND SUIT"
\u2667 "WHITE CLUB SUIT"
\u2668 "HOT SPRINGS"
\u2669 "QUARTER NOTE"
\u266A "EIGHTH NOTE"
\u266B "BEAMED EIGHTH NOTES"
\u266C "BEAMED SIXTEENTH NOTES"
\u266D "MUSIC FLAT SIGN"
\u266E "MUSIC NATURAL SIGN"
\u266F "MUSIC SHARP SIGN"
\u2670 "WEST SYRIAC CROSS"
\u2671 "EAST SYRIAC CROSS"
\u2672 "UNIVERSAL RECYCLING SYMBOL"
\u2673 "RECYCLING SYMBOL FOR TYPE-1 PLASTICS"
\u2674 "RECYCLING SYMBOL FOR TYPE-2 PLASTICS"
\u2675 "RECYCLING SYMBOL FOR TYPE-3 PLASTICS"
\u2676 "RECYCLING SYMBOL FOR TYPE-4 PLASTICS"
\u2677 "RECYCLING SYMBOL FOR TYPE-5 PLASTICS"
\u2678 "RECYCLING SYMBOL FOR TYPE-6 PLASTICS"
\u2679 "RECYCLING SYMBOL FOR TYPE-7 PLASTICS"
\u267A "RECYCLING SYMBOL FOR GENERIC MATERIALS"
\u267B "BLACK UNIVERSAL RECYCLING SYMBOL"
\u267C "RECYCLED PAPER SYMBOL"
\u267D "PARTIALLY-RECYCLED PAPER SYMBOL"
\u267E "PERMANENT PAPER SIGN"
\u267F "WHEELCHAIR SYMBOL"
\u2680 "DIE FACE-1"
\u2681 "DIE FACE-2"
\u2682 "DIE FACE-3"
\u2683 "DIE FACE-4"
\u2684 "DIE FACE-5"
\u2685 "DIE FACE-6"
\u2686 "WHITE CIRCLE WITH DOT RIGHT"
\u2687 "WHITE CIRCLE WITH TWO DOTS"
\u2688 "BLACK CIRCLE WITH WHITE DOT RIGHT"
\u2689 "BLACK CIRCLE WITH TWO WHITE DOTS"
\u268A "MONOGRAM FOR YANG"
\u268B "MONOGRAM FOR YIN"
\u268C "DIGRAM FOR GREATER YANG"
\u268D "DIGRAM FOR LESSER YIN"
\u268E "DIGRAM FOR LESSER YANG"
\u268F "DIGRAM FOR GREATER YIN"
\u2690 "WHITE FLAG"
\u2691 "BLACK FLAG"
\u2692 "HAMMER AND PICK"
\u2693 "ANCHOR"
\u2694 "CROSSED SWORDS"
\u2695 "STAFF OF AESCULAPIUS"
\u2696 "SCALES"
\u2697 "ALEMBIC"
\u2698 "FLOWER"
\u2699 "GEAR"
\u269A "STAFF OF HERMES"
\u269B "ATOM SYMBOL"
\u269C "FLEUR-DE-LIS"
\u269D "OUTLINED WHITE STAR"
\u26A0 "WARNING SIGN"
\u26A1 "HIGH VOLTAGE SIGN"
\u26A2 "DOUBLED FEMALE SIGN"
\u26A3 "DOUBLED MALE SIGN"
\u26A4 "INTERLOCKED FEMALE AND MALE SIGN"
\u26A5 "MALE AND FEMALE SIGN"
\u26A6 "MALE WITH STROKE SIGN"
\u26A7 "MALE WITH STROKE AND MALE AND FEMALE SIGN"
\u26A8 "VERTICAL MALE WITH STROKE SIGN"
\u26A9 "HORIZONTAL MALE WITH STROKE SIGN"
\u26AA "MEDIUM WHITE CIRCLE"
\u26AB "MEDIUM BLACK CIRCLE"
\u26AC "MEDIUM SMALL WHITE CIRCLE"
\u26AD "MARRIAGE SYMBOL"
\u26AE "DIVORCE SYMBOL"
\u26AF "UNMARRIED PARTNERSHIP SYMBOL"
\u26B0 "COFFIN"
\u26B1 "FUNERAL URN"
\u26B2 "NEUTER"
\u26B3 "CERES"
\u26B4 "PALLAS"
\u26B5 "JUNO"
\u26B6 "VESTA"
\u26B7 "CHIRON"
\u26B8 "BLACK MOON LILITH"
\u26B9 "SEXTILE"
\u26BA "SEMISEXTILE"
\u26BB "QUINCUNX"
\u26BC "SESQUIQUADRATE"
\u26C0 "WHITE DRAUGHTS MAN"
\u26C1 "WHITE DRAUGHTS KING"
\u26C2 "BLACK DRAUGHTS MAN"
\u26C3 "BLACK DRAUGHTS KING"
\u2701 "UPPER BLADE SCISSORS"
\u2702 "BLACK SCISSORS"
\u2703 "LOWER BLADE SCISSORS"
\u2704 "WHITE SCISSORS"
\u2706 "TELEPHONE LOCATION SIGN"
\u2707 "TAPE DRIVE"
\u2708 "AIRPLANE"
\u2709 "ENVELOPE"
\u270C "VICTORY HAND"
\u270D "WRITING HAND"
\u270E "LOWER RIGHT PENCIL"
\u270F "PENCIL"
\u2710 "UPPER RIGHT PENCIL"
\u2711 "WHITE NIB"
\u2712 "BLACK NIB"
\u2713 "CHECK MARK"
\u2714 "HEAVY CHECK MARK"
\u2715 "MULTIPLICATION X"
\u2716 "HEAVY MULTIPLICATION X"
\u2717 "BALLOT X"
\u2718 "HEAVY BALLOT X"
\u2719 "OUTLINED GREEK CROSS"
\u271A "HEAVY GREEK CROSS"
\u271B "OPEN CENTRE CROSS"
\u271C "HEAVY OPEN CENTRE CROSS"
\u271D "LATIN CROSS"
\u271E "SHADOWED WHITE LATIN CROSS"
\u271F "OUTLINED LATIN CROSS"
\u2720 "MALTESE CROSS"
\u2721 "STAR OF DAVID"
\u2722 "FOUR TEARDROP-SPOKED ASTERISK"
\u2723 "FOUR BALLOON-SPOKED ASTERISK"
\u2724 "HEAVY FOUR BALLOON-SPOKED ASTERISK"
\u2725 "FOUR CLUB-SPOKED ASTERISK"
\u2726 "BLACK FOUR POINTED STAR"
\u2727 "WHITE FOUR POINTED STAR"
\u2729 "STRESS OUTLINED WHITE STAR"
\u272A "CIRCLED WHITE STAR"
\u272B "OPEN CENTRE BLACK STAR"
\u272C "BLACK CENTRE WHITE STAR"
\u272D "OUTLINED BLACK STAR"
\u272E "HEAVY OUTLINED BLACK STAR"
\u272F "PINWHEEL STAR"
\u2730 "SHADOWED WHITE STAR"
\u2731 "HEAVY ASTERISK"
\u2732 "OPEN CENTRE ASTERISK"
\u2733 "EIGHT SPOKED ASTERISK"
\u2734 "EIGHT POINTED BLACK STAR"
\u2735 "EIGHT POINTED PINWHEEL STAR"
\u2736 "SIX POINTED BLACK STAR"
\u2737 "EIGHT POINTED RECTILINEAR BLACK STAR"
\u2738 "HEAVY EIGHT POINTED RECTILINEAR BLACK STAR"
\u2739 "TWELVE POINTED BLACK STAR"
\u273A "SIXTEEN POINTED ASTERISK"
\u273B "TEARDROP-SPOKED ASTERISK"
\u273C "OPEN CENTRE TEARDROP-SPOKED ASTERISK"
\u273D "HEAVY TEARDROP-SPOKED ASTERISK"
\u273E "SIX PETALLED BLACK AND WHITE FLORETTE"
\u273F "BLACK FLORETTE"
\u2740 "WHITE FLORETTE"
\u2741 "EIGHT PETALLED OUTLINED BLACK FLORETTE"
\u2742 "CIRCLED OPEN CENTRE EIGHT POINTED STAR"
\u2743 "HEAVY TEARDROP-SPOKED PINWHEEL ASTERISK"
\u2744 "SNOWFLAKE"
\u2745 "TIGHT TRIFOLIATE SNOWFLAKE"
\u2746 "HEAVY CHEVRON SNOWFLAKE"
\u2747 "SPARKLE"
\u2748 "HEAVY SPARKLE"
\u2749 "BALLOON-SPOKED ASTERISK"
\u274A "EIGHT TEARDROP-SPOKED PROPELLER ASTERISK"
\u274B "HEAVY EIGHT TEARDROP-SPOKED PROPELLER ASTERISK"
\u274D "SHADOWED WHITE CIRCLE"
\u274F "LOWER RIGHT DROP-SHADOWED WHITE SQUARE"
\u2750 "UPPER RIGHT DROP-SHADOWED WHITE SQUARE"
\u2751 "LOWER RIGHT SHADOWED WHITE SQUARE"
\u2752 "UPPER RIGHT SHADOWED WHITE SQUARE"
\u2756 "BLACK DIAMOND MINUS WHITE X"
\u2758 "LIGHT VERTICAL BAR"
\u2759 "MEDIUM VERTICAL BAR"
\u275A "HEAVY VERTICAL BAR"
\u275B "HEAVY SINGLE TURNED COMMA QUOTATION MARK ORNAMENT"
\u275C "HEAVY SINGLE COMMA QUOTATION MARK ORNAMENT"
\u275D "HEAVY DOUBLE TURNED COMMA QUOTATION MARK ORNAMENT"
\u275E "HEAVY DOUBLE COMMA QUOTATION MARK ORNAMENT"
\u2761 "CURVED STEM PARAGRAPH SIGN ORNAMENT"
\u2762 "HEAVY EXCLAMATION MARK ORNAMENT"
\u2763 "HEAVY HEART EXCLAMATION MARK ORNAMENT"
\u2764 "HEAVY BLACK HEART"
\u2765 "ROTATED HEAVY BLACK HEART BULLET"
\u2766 "FLORAL HEART"
\u2767 "ROTATED FLORAL HEART BULLET"
\u2768 "MEDIUM LEFT PARENTHESIS ORNAMENT"
\u2769 "MEDIUM RIGHT PARENTHESIS ORNAMENT"
\u276A "MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT"
\u276B "MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT"
\u276C "MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT"
\u276D "MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT"
\u276E "HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT"
\u276F "HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT"
\u2770 "HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT"
\u2771 "HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT"
\u2772 "LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT"
\u2773 "LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT"
\u2774 "MEDIUM LEFT CURLY BRACKET ORNAMENT"
\u2775 "MEDIUM RIGHT CURLY BRACKET ORNAMENT"
\u2776 "DINGBAT NEGATIVE CIRCLED DIGIT ONE"
\u2777 "DINGBAT NEGATIVE CIRCLED DIGIT TWO"
\u2778 "DINGBAT NEGATIVE CIRCLED DIGIT THREE"
\u2779 "DINGBAT NEGATIVE CIRCLED DIGIT FOUR"
\u277A "DINGBAT NEGATIVE CIRCLED DIGIT FIVE"
\u277B "DINGBAT NEGATIVE CIRCLED DIGIT SIX"
\u277C "DINGBAT NEGATIVE CIRCLED DIGIT SEVEN"
\u277D "DINGBAT NEGATIVE CIRCLED DIGIT EIGHT"
\u277E "DINGBAT NEGATIVE CIRCLED DIGIT NINE"
\u277F "DINGBAT NEGATIVE CIRCLED NUMBER TEN"
\u2780 "DINGBAT CIRCLED SANS-SERIF DIGIT ONE"
\u2781 "DINGBAT CIRCLED SANS-SERIF DIGIT TWO"
\u2782 "DINGBAT CIRCLED SANS-SERIF DIGIT THREE"
\u2783 "DINGBAT CIRCLED SANS-SERIF DIGIT FOUR"
\u2784 "DINGBAT CIRCLED SANS-SERIF DIGIT FIVE"
\u2785 "DINGBAT CIRCLED SANS-SERIF DIGIT SIX"
\u2786 "DINGBAT CIRCLED SANS-SERIF DIGIT SEVEN"
\u2787 "DINGBAT CIRCLED SANS-SERIF DIGIT EIGHT"
\u2788 "DINGBAT CIRCLED SANS-SERIF DIGIT NINE"
\u2789 "DINGBAT CIRCLED SANS-SERIF NUMBER TEN"
\u278A "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ONE"
\u278B "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT TWO"
\u278C "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT THREE"
\u278D "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT FOUR"
\u278E "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT FIVE"
\u278F "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT SIX"
\u2790 "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT SEVEN"
\u2791 "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT EIGHT"
\u2792 "DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT NINE"
\u2793 "DINGBAT NEGATIVE CIRCLED SANS-SERIF NUMBER TEN"
\u2794 "HEAVY WIDE-HEADED RIGHTWARDS ARROW"
\u2798 "HEAVY SOUTH EAST ARROW"
\u2799 "HEAVY RIGHTWARDS ARROW"
\u279A "HEAVY NORTH EAST ARROW"
\u279B "DRAFTING POINT RIGHTWARDS ARROW"
\u279C "HEAVY ROUND-TIPPED RIGHTWARDS ARROW"
\u279D "TRIANGLE-HEADED RIGHTWARDS ARROW"
\u279E "HEAVY TRIANGLE-HEADED RIGHTWARDS ARROW"
\u279F "DASHED TRIANGLE-HEADED RIGHTWARDS ARROW"
\u27A0 "HEAVY DASHED TRIANGLE-HEADED RIGHTWARDS ARROW"
\u27A1 "BLACK RIGHTWARDS ARROW"
\u27A2 "THREE-D TOP-LIGHTED RIGHTWARDS ARROWHEAD"
\u27A3 "THREE-D BOTTOM-LIGHTED RIGHTWARDS ARROWHEAD"
\u27A4 "BLACK RIGHTWARDS ARROWHEAD"
\u27A5 "HEAVY BLACK CURVED DOWNWARDS AND RIGHTWARDS ARROW"
\u27A6 "HEAVY BLACK CURVED UPWARDS AND RIGHTWARDS ARROW"
\u27A7 "SQUAT BLACK RIGHTWARDS ARROW"
\u27A8 "HEAVY CONCAVE-POINTED BLACK RIGHTWARDS ARROW"
\u27A9 "RIGHT-SHADED WHITE RIGHTWARDS ARROW"
\u27AA "LEFT-SHADED WHITE RIGHTWARDS ARROW"
\u27AB "BACK-TILTED SHADOWED WHITE RIGHTWARDS ARROW"
\u27AC "FRONT-TILTED SHADOWED WHITE RIGHTWARDS ARROW"
\u27AD "HEAVY LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW"
\u27AE "HEAVY UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW"
\u27AF "NOTCHED LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW"
\u27B1 "NOTCHED UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW"
\u27B2 "CIRCLED HEAVY WHITE RIGHTWARDS ARROW"
\u27B3 "WHITE-FEATHERED RIGHTWARDS ARROW"
\u27B4 "BLACK-FEATHERED SOUTH EAST ARROW"
\u27B5 "BLACK-FEATHERED RIGHTWARDS ARROW"
\u27B6 "BLACK-FEATHERED NORTH EAST ARROW"
\u27B7 "HEAVY BLACK-FEATHERED SOUTH EAST ARROW"
\u27B8 "HEAVY BLACK-FEATHERED RIGHTWARDS ARROW"
\u27B9 "HEAVY BLACK-FEATHERED NORTH EAST ARROW"
\u27BA "TEARDROP-BARBED RIGHTWARDS ARROW"
\u27BB "HEAVY TEARDROP-SHANKED RIGHTWARDS ARROW"
\u27BC "WEDGE-TAILED RIGHTWARDS ARROW"
\u27BD "HEAVY WEDGE-TAILED RIGHTWARDS ARROW"
\u27BE "OPEN-OUTLINED RIGHTWARDS ARROW"
\u27C0 "THREE DIMENSIONAL ANGLE"
\u27C1 "WHITE TRIANGLE CONTAINING SMALL WHITE TRIANGLE"
\u27C2 "PERPENDICULAR"
\u27C3 "OPEN SUBSET"
\u27C4 "OPEN SUPERSET"
\u27C5 "LEFT S-SHAPED BAG DELIMITER"
\u27C6 "RIGHT S-SHAPED BAG DELIMITER"
\u27C7 "OR WITH DOT INSIDE"
\u27C8 "REVERSE SOLIDUS PRECEDING SUBSET"
\u27C9 "SUPERSET PRECEDING SOLIDUS"
\u27CA "VERTICAL BAR WITH HORIZONTAL STROKE"
\u27CC "LONG DIVISION"
\u27D0 "WHITE DIAMOND WITH CENTRED DOT"
\u27D1 "AND WITH DOT"
\u27D2 "ELEMENT OF OPENING UPWARDS"
\u27D3 "LOWER RIGHT CORNER WITH DOT"
\u27D4 "UPPER LEFT CORNER WITH DOT"
\u27D5 "LEFT OUTER JOIN"
\u27D6 "RIGHT OUTER JOIN"
\u27D7 "FULL OUTER JOIN"
\u27D8 "LARGE UP TACK"
\u27D9 "LARGE DOWN TACK"
\u27DA "LEFT AND RIGHT DOUBLE TURNSTILE"
\u27DB "LEFT AND RIGHT TACK"
\u27DC "LEFT MULTIMAP"
\u27DD "LONG RIGHT TACK"
\u27DE "LONG LEFT TACK"
\u27DF "UP TACK WITH CIRCLE ABOVE"
\u27E0 "LOZENGE DIVIDED BY HORIZONTAL RULE"
\u27E1 "WHITE CONCAVE-SIDED DIAMOND"
\u27E2 "WHITE CONCAVE-SIDED DIAMOND WITH LEFTWARDS TICK"
\u27E3 "WHITE CONCAVE-SIDED DIAMOND WITH RIGHTWARDS TICK"
\u27E4 "WHITE SQUARE WITH LEFTWARDS TICK"
\u27E5 "WHITE SQUARE WITH RIGHTWARDS TICK"
\u27E6 "MATHEMATICAL LEFT WHITE SQUARE BRACKET"
\u27E7 "MATHEMATICAL RIGHT WHITE SQUARE BRACKET"
\u27E8 "MATHEMATICAL LEFT ANGLE BRACKET"
\u27E9 "MATHEMATICAL RIGHT ANGLE BRACKET"
\u27EA "MATHEMATICAL LEFT DOUBLE ANGLE BRACKET"
\u27EB "MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET"
\u27EC "MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET"
\u27ED "MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET"
\u27EE "MATHEMATICAL LEFT FLATTENED PARENTHESIS"
\u27EF "MATHEMATICAL RIGHT FLATTENED PARENTHESIS"
\u27F0 "UPWARDS QUADRUPLE ARROW"
\u27F1 "DOWNWARDS QUADRUPLE ARROW"
\u27F2 "ANTICLOCKWISE GAPPED CIRCLE ARROW"
\u27F3 "CLOCKWISE GAPPED CIRCLE ARROW"
\u27F4 "RIGHT ARROW WITH CIRCLED PLUS"
\u27F5 "LONG LEFTWARDS ARROW"
\u27F6 "LONG RIGHTWARDS ARROW"
\u27F7 "LONG LEFT RIGHT ARROW"
\u27F8 "LONG LEFTWARDS DOUBLE ARROW"
\u27F9 "LONG RIGHTWARDS DOUBLE ARROW"
\u27FA "LONG LEFT RIGHT DOUBLE ARROW"
\u27FB "LONG LEFTWARDS ARROW FROM BAR"
\u27FC "LONG RIGHTWARDS ARROW FROM BAR"
\u27FD "LONG LEFTWARDS DOUBLE ARROW FROM BAR"
\u27FE "LONG RIGHTWARDS DOUBLE ARROW FROM BAR"
\u27FF "LONG RIGHTWARDS SQUIGGLE ARROW"
\u2800 "BRAILLE PATTERN BLANK"
\u2801 "BRAILLE PATTERN DOTS-1"
\u2802 "BRAILLE PATTERN DOTS-2"
\u2803 "BRAILLE PATTERN DOTS-12"
\u2804 "BRAILLE PATTERN DOTS-3"
\u2805 "BRAILLE PATTERN DOTS-13"
\u2806 "BRAILLE PATTERN DOTS-23"
\u2807 "BRAILLE PATTERN DOTS-123"
\u2808 "BRAILLE PATTERN DOTS-4"
\u2809 "BRAILLE PATTERN DOTS-14"
\u280A "BRAILLE PATTERN DOTS-24"
\u280B "BRAILLE PATTERN DOTS-124"
\u280C "BRAILLE PATTERN DOTS-34"
\u280D "BRAILLE PATTERN DOTS-134"
\u280E "BRAILLE PATTERN DOTS-234"
\u280F "BRAILLE PATTERN DOTS-1234"
\u2810 "BRAILLE PATTERN DOTS-5"
\u2811 "BRAILLE PATTERN DOTS-15"
\u2812 "BRAILLE PATTERN DOTS-25"
\u2813 "BRAILLE PATTERN DOTS-125"
\u2814 "BRAILLE PATTERN DOTS-35"
\u2815 "BRAILLE PATTERN DOTS-135"
\u2816 "BRAILLE PATTERN DOTS-235"
\u2817 "BRAILLE PATTERN DOTS-1235"
\u2818 "BRAILLE PATTERN DOTS-45"
\u2819 "BRAILLE PATTERN DOTS-145"
\u281A "BRAILLE PATTERN DOTS-245"
\u281B "BRAILLE PATTERN DOTS-1245"
\u281C "BRAILLE PATTERN DOTS-345"
\u281D "BRAILLE PATTERN DOTS-1345"
\u281E "BRAILLE PATTERN DOTS-2345"
\u281F "BRAILLE PATTERN DOTS-12345"
\u2820 "BRAILLE PATTERN DOTS-6"
\u2821 "BRAILLE PATTERN DOTS-16"
\u2822 "BRAILLE PATTERN DOTS-26"
\u2823 "BRAILLE PATTERN DOTS-126"
\u2824 "BRAILLE PATTERN DOTS-36"
\u2825 "BRAILLE PATTERN DOTS-136"
\u2826 "BRAILLE PATTERN DOTS-236"
\u2827 "BRAILLE PATTERN DOTS-1236"
\u2828 "BRAILLE PATTERN DOTS-46"
\u2829 "BRAILLE PATTERN DOTS-146"
\u282A "BRAILLE PATTERN DOTS-246"
\u282B "BRAILLE PATTERN DOTS-1246"
\u282C "BRAILLE PATTERN DOTS-346"
\u282D "BRAILLE PATTERN DOTS-1346"
\u282E "BRAILLE PATTERN DOTS-2346"
\u282F "BRAILLE PATTERN DOTS-12346"
\u2830 "BRAILLE PATTERN DOTS-56"
\u2831 "BRAILLE PATTERN DOTS-156"
\u2832 "BRAILLE PATTERN DOTS-256"
\u2833 "BRAILLE PATTERN DOTS-1256"
\u2834 "BRAILLE PATTERN DOTS-356"
\u2835 "BRAILLE PATTERN DOTS-1356"
\u2836 "BRAILLE PATTERN DOTS-2356"
\u2837 "BRAILLE PATTERN DOTS-12356"
\u2838 "BRAILLE PATTERN DOTS-456"
\u2839 "BRAILLE PATTERN DOTS-1456"
\u283A "BRAILLE PATTERN DOTS-2456"
\u283B "BRAILLE PATTERN DOTS-12456"
\u283C "BRAILLE PATTERN DOTS-3456"
\u283D "BRAILLE PATTERN DOTS-13456"
\u283E "BRAILLE PATTERN DOTS-23456"
\u283F "BRAILLE PATTERN DOTS-123456"
\u2840 "BRAILLE PATTERN DOTS-7"
\u2841 "BRAILLE PATTERN DOTS-17"
\u2842 "BRAILLE PATTERN DOTS-27"
\u2843 "BRAILLE PATTERN DOTS-127"
\u2844 "BRAILLE PATTERN DOTS-37"
\u2845 "BRAILLE PATTERN DOTS-137"
\u2846 "BRAILLE PATTERN DOTS-237"
\u2847 "BRAILLE PATTERN DOTS-1237"
\u2848 "BRAILLE PATTERN DOTS-47"
\u2849 "BRAILLE PATTERN DOTS-147"
\u284A "BRAILLE PATTERN DOTS-247"
\u284B "BRAILLE PATTERN DOTS-1247"
\u284C "BRAILLE PATTERN DOTS-347"
\u284D "BRAILLE PATTERN DOTS-1347"
\u284E "BRAILLE PATTERN DOTS-2347"
\u284F "BRAILLE PATTERN DOTS-12347"
\u2850 "BRAILLE PATTERN DOTS-57"
\u2851 "BRAILLE PATTERN DOTS-157"
\u2852 "BRAILLE PATTERN DOTS-257"
\u2853 "BRAILLE PATTERN DOTS-1257"
\u2854 "BRAILLE PATTERN DOTS-357"
\u2855 "BRAILLE PATTERN DOTS-1357"
\u2856 "BRAILLE PATTERN DOTS-2357"
\u2857 "BRAILLE PATTERN DOTS-12357"
\u2858 "BRAILLE PATTERN DOTS-457"
\u2859 "BRAILLE PATTERN DOTS-1457"
\u285A "BRAILLE PATTERN DOTS-2457"
\u285B "BRAILLE PATTERN DOTS-12457"
\u285C "BRAILLE PATTERN DOTS-3457"
\u285D "BRAILLE PATTERN DOTS-13457"
\u285E "BRAILLE PATTERN DOTS-23457"
\u285F "BRAILLE PATTERN DOTS-123457"
\u2860 "BRAILLE PATTERN DOTS-67"
\u2861 "BRAILLE PATTERN DOTS-167"
\u2862 "BRAILLE PATTERN DOTS-267"
\u2863 "BRAILLE PATTERN DOTS-1267"
\u2864 "BRAILLE PATTERN DOTS-367"
\u2865 "BRAILLE PATTERN DOTS-1367"
\u2866 "BRAILLE PATTERN DOTS-2367"
\u2867 "BRAILLE PATTERN DOTS-12367"
\u2868 "BRAILLE PATTERN DOTS-467"
\u2869 "BRAILLE PATTERN DOTS-1467"
\u286A "BRAILLE PATTERN DOTS-2467"
\u286B "BRAILLE PATTERN DOTS-12467"
\u286C "BRAILLE PATTERN DOTS-3467"
\u286D "BRAILLE PATTERN DOTS-13467"
\u286E "BRAILLE PATTERN DOTS-23467"
\u286F "BRAILLE PATTERN DOTS-123467"
\u2870 "BRAILLE PATTERN DOTS-567"
\u2871 "BRAILLE PATTERN DOTS-1567"
\u2872 "BRAILLE PATTERN DOTS-2567"
\u2873 "BRAILLE PATTERN DOTS-12567"
\u2874 "BRAILLE PATTERN DOTS-3567"
\u2875 "BRAILLE PATTERN DOTS-13567"
\u2876 "BRAILLE PATTERN DOTS-23567"
\u2877 "BRAILLE PATTERN DOTS-123567"
\u2878 "BRAILLE PATTERN DOTS-4567"
\u2879 "BRAILLE PATTERN DOTS-14567"
\u287A "BRAILLE PATTERN DOTS-24567"
\u287B "BRAILLE PATTERN DOTS-124567"
\u287C "BRAILLE PATTERN DOTS-34567"
\u287D "BRAILLE PATTERN DOTS-134567"
\u287E "BRAILLE PATTERN DOTS-234567"
\u287F "BRAILLE PATTERN DOTS-1234567"
\u2880 "BRAILLE PATTERN DOTS-8"
\u2881 "BRAILLE PATTERN DOTS-18"
\u2882 "BRAILLE PATTERN DOTS-28"
\u2883 "BRAILLE PATTERN DOTS-128"
\u2884 "BRAILLE PATTERN DOTS-38"
\u2885 "BRAILLE PATTERN DOTS-138"
\u2886 "BRAILLE PATTERN DOTS-238"
\u2887 "BRAILLE PATTERN DOTS-1238"
\u2888 "BRAILLE PATTERN DOTS-48"
\u2889 "BRAILLE PATTERN DOTS-148"
\u288A "BRAILLE PATTERN DOTS-248"
\u288B "BRAILLE PATTERN DOTS-1248"
\u288C "BRAILLE PATTERN DOTS-348"
\u288D "BRAILLE PATTERN DOTS-1348"
\u288E "BRAILLE PATTERN DOTS-2348"
\u288F "BRAILLE PATTERN DOTS-12348"
\u2890 "BRAILLE PATTERN DOTS-58"
\u2891 "BRAILLE PATTERN DOTS-158"
\u2892 "BRAILLE PATTERN DOTS-258"
\u2893 "BRAILLE PATTERN DOTS-1258"
\u2894 "BRAILLE PATTERN DOTS-358"
\u2895 "BRAILLE PATTERN DOTS-1358"
\u2896 "BRAILLE PATTERN DOTS-2358"
\u2897 "BRAILLE PATTERN DOTS-12358"
\u2898 "BRAILLE PATTERN DOTS-458"
\u2899 "BRAILLE PATTERN DOTS-1458"
\u289A "BRAILLE PATTERN DOTS-2458"
\u289B "BRAILLE PATTERN DOTS-12458"
\u289C "BRAILLE PATTERN DOTS-3458"
\u289D "BRAILLE PATTERN DOTS-13458"
\u289E "BRAILLE PATTERN DOTS-23458"
\u289F "BRAILLE PATTERN DOTS-123458"
\u28A0 "BRAILLE PATTERN DOTS-68"
\u28A1 "BRAILLE PATTERN DOTS-168"
\u28A2 "BRAILLE PATTERN DOTS-268"
\u28A3 "BRAILLE PATTERN DOTS-1268"
\u28A4 "BRAILLE PATTERN DOTS-368"
\u28A5 "BRAILLE PATTERN DOTS-1368"
\u28A6 "BRAILLE PATTERN DOTS-2368"
\u28A7 "BRAILLE PATTERN DOTS-12368"
\u28A8 "BRAILLE PATTERN DOTS-468"
\u28A9 "BRAILLE PATTERN DOTS-1468"
\u28AA "BRAILLE PATTERN DOTS-2468"
\u28AB "BRAILLE PATTERN DOTS-12468"
\u28AC "BRAILLE PATTERN DOTS-3468"
\u28AD "BRAILLE PATTERN DOTS-13468"
\u28AE "BRAILLE PATTERN DOTS-23468"
\u28AF "BRAILLE PATTERN DOTS-123468"
\u28B0 "BRAILLE PATTERN DOTS-568"
\u28B1 "BRAILLE PATTERN DOTS-1568"
\u28B2 "BRAILLE PATTERN DOTS-2568"
\u28B3 "BRAILLE PATTERN DOTS-12568"
\u28B4 "BRAILLE PATTERN DOTS-3568"
\u28B5 "BRAILLE PATTERN DOTS-13568"
\u28B6 "BRAILLE PATTERN DOTS-23568"
\u28B7 "BRAILLE PATTERN DOTS-123568"
\u28B8 "BRAILLE PATTERN DOTS-4568"
\u28B9 "BRAILLE PATTERN DOTS-14568"
\u28BA "BRAILLE PATTERN DOTS-24568"
\u28BB "BRAILLE PATTERN DOTS-124568"
\u28BC "BRAILLE PATTERN DOTS-34568"
\u28BD "BRAILLE PATTERN DOTS-134568"
\u28BE "BRAILLE PATTERN DOTS-234568"
\u28BF "BRAILLE PATTERN DOTS-1234568"
\u28C0 "BRAILLE PATTERN DOTS-78"
\u28C1 "BRAILLE PATTERN DOTS-178"
\u28C2 "BRAILLE PATTERN DOTS-278"
\u28C3 "BRAILLE PATTERN DOTS-1278"
\u28C4 "BRAILLE PATTERN DOTS-378"
\u28C5 "BRAILLE PATTERN DOTS-1378"
\u28C6 "BRAILLE PATTERN DOTS-2378"
\u28C7 "BRAILLE PATTERN DOTS-12378"
\u28C8 "BRAILLE PATTERN DOTS-478"
\u28C9 "BRAILLE PATTERN DOTS-1478"
\u28CA "BRAILLE PATTERN DOTS-2478"
\u28CB "BRAILLE PATTERN DOTS-12478"
\u28CC "BRAILLE PATTERN DOTS-3478"
\u28CD "BRAILLE PATTERN DOTS-13478"
\u28CE "BRAILLE PATTERN DOTS-23478"
\u28CF "BRAILLE PATTERN DOTS-123478"
\u28D0 "BRAILLE PATTERN DOTS-578"
\u28D1 "BRAILLE PATTERN DOTS-1578"
\u28D2 "BRAILLE PATTERN DOTS-2578"
\u28D3 "BRAILLE PATTERN DOTS-12578"
\u28D4 "BRAILLE PATTERN DOTS-3578"
\u28D5 "BRAILLE PATTERN DOTS-13578"
\u28D6 "BRAILLE PATTERN DOTS-23578"
\u28D7 "BRAILLE PATTERN DOTS-123578"
\u28D8 "BRAILLE PATTERN DOTS-4578"
\u28D9 "BRAILLE PATTERN DOTS-14578"
\u28DA "BRAILLE PATTERN DOTS-24578"
\u28DB "BRAILLE PATTERN DOTS-124578"
\u28DC "BRAILLE PATTERN DOTS-34578"
\u28DD "BRAILLE PATTERN DOTS-134578"
\u28DE "BRAILLE PATTERN DOTS-234578"
\u28DF "BRAILLE PATTERN DOTS-1234578"
\u28E0 "BRAILLE PATTERN DOTS-678"
\u28E1 "BRAILLE PATTERN DOTS-1678"
\u28E2 "BRAILLE PATTERN DOTS-2678"
\u28E3 "BRAILLE PATTERN DOTS-12678"
\u28E4 "BRAILLE PATTERN DOTS-3678"
\u28E5 "BRAILLE PATTERN DOTS-13678"
\u28E6 "BRAILLE PATTERN DOTS-23678"
\u28E7 "BRAILLE PATTERN DOTS-123678"
\u28E8 "BRAILLE PATTERN DOTS-4678"
\u28E9 "BRAILLE PATTERN DOTS-14678"
\u28EA "BRAILLE PATTERN DOTS-24678"
\u28EB "BRAILLE PATTERN DOTS-124678"
\u28EC "BRAILLE PATTERN DOTS-34678"
\u28ED "BRAILLE PATTERN DOTS-134678"
\u28EE "BRAILLE PATTERN DOTS-234678"
\u28EF "BRAILLE PATTERN DOTS-1234678"
\u28F0 "BRAILLE PATTERN DOTS-5678"
\u28F1 "BRAILLE PATTERN DOTS-15678"
\u28F2 "BRAILLE PATTERN DOTS-25678"
\u28F3 "BRAILLE PATTERN DOTS-125678"
\u28F4 "BRAILLE PATTERN DOTS-35678"
\u28F5 "BRAILLE PATTERN DOTS-135678"
\u28F6 "BRAILLE PATTERN DOTS-235678"
\u28F7 "BRAILLE PATTERN DOTS-1235678"
\u28F8 "BRAILLE PATTERN DOTS-45678"
\u28F9 "BRAILLE PATTERN DOTS-145678"
\u28FA "BRAILLE PATTERN DOTS-245678"
\u28FB "BRAILLE PATTERN DOTS-1245678"
\u28FC "BRAILLE PATTERN DOTS-345678"
\u28FD "BRAILLE PATTERN DOTS-1345678"
\u28FE "BRAILLE PATTERN DOTS-2345678"
\u28FF "BRAILLE PATTERN DOTS-12345678"
\u2900 "RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE"
\u2901 "RIGHTWARDS TWO-HEADED ARROW WITH DOUBLE VERTICAL STROKE"
\u2902 "LEFTWARDS DOUBLE ARROW WITH VERTICAL STROKE"
\u2903 "RIGHTWARDS DOUBLE ARROW WITH VERTICAL STROKE"
\u2904 "LEFT RIGHT DOUBLE ARROW WITH VERTICAL STROKE"
\u2905 "RIGHTWARDS TWO-HEADED ARROW FROM BAR"
\u2906 "LEFTWARDS DOUBLE ARROW FROM BAR"
\u2907 "RIGHTWARDS DOUBLE ARROW FROM BAR"
\u2908 "DOWNWARDS ARROW WITH HORIZONTAL STROKE"
\u2909 "UPWARDS ARROW WITH HORIZONTAL STROKE"
\u290A "UPWARDS TRIPLE ARROW"
\u290B "DOWNWARDS TRIPLE ARROW"
\u290C "LEFTWARDS DOUBLE DASH ARROW"
\u290D "RIGHTWARDS DOUBLE DASH ARROW"
\u290E "LEFTWARDS TRIPLE DASH ARROW"
\u290F "RIGHTWARDS TRIPLE DASH ARROW"
\u2910 "RIGHTWARDS TWO-HEADED TRIPLE DASH ARROW"
\u2911 "RIGHTWARDS ARROW WITH DOTTED STEM"
\u2912 "UPWARDS ARROW TO BAR"
\u2913 "DOWNWARDS ARROW TO BAR"
\u2914 "RIGHTWARDS ARROW WITH TAIL WITH VERTICAL STROKE"
\u2915 "RIGHTWARDS ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE"
\u2916 "RIGHTWARDS TWO-HEADED ARROW WITH TAIL"
\u2917 "RIGHTWARDS TWO-HEADED ARROW WITH TAIL WITH VERTICAL STROKE"
\u2918 "RIGHTWARDS TWO-HEADED ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE"
\u2919 "LEFTWARDS ARROW-TAIL"
\u291A "RIGHTWARDS ARROW-TAIL"
\u291B "LEFTWARDS DOUBLE ARROW-TAIL"
\u291C "RIGHTWARDS DOUBLE ARROW-TAIL"
\u291D "LEFTWARDS ARROW TO BLACK DIAMOND"
\u291E "RIGHTWARDS ARROW TO BLACK DIAMOND"
\u291F "LEFTWARDS ARROW FROM BAR TO BLACK DIAMOND"
\u2920 "RIGHTWARDS ARROW FROM BAR TO BLACK DIAMOND"
\u2921 "NORTH WEST AND SOUTH EAST ARROW"
\u2922 "NORTH EAST AND SOUTH WEST ARROW"
\u2923 "NORTH WEST ARROW WITH HOOK"
\u2924 "NORTH EAST ARROW WITH HOOK"
\u2925 "SOUTH EAST ARROW WITH HOOK"
\u2926 "SOUTH WEST ARROW WITH HOOK"
\u2927 "NORTH WEST ARROW AND NORTH EAST ARROW"
\u2928 "NORTH EAST ARROW AND SOUTH EAST ARROW"
\u2929 "SOUTH EAST ARROW AND SOUTH WEST ARROW"
\u292A "SOUTH WEST ARROW AND NORTH WEST ARROW"
\u292B "RISING DIAGONAL CROSSING FALLING DIAGONAL"
\u292C "FALLING DIAGONAL CROSSING RISING DIAGONAL"
\u292D "SOUTH EAST ARROW CROSSING NORTH EAST ARROW"
\u292E "NORTH EAST ARROW CROSSING SOUTH EAST ARROW"
\u292F "FALLING DIAGONAL CROSSING NORTH EAST ARROW"
\u2930 "RISING DIAGONAL CROSSING SOUTH EAST ARROW"
\u2931 "NORTH EAST ARROW CROSSING NORTH WEST ARROW"
\u2932 "NORTH WEST ARROW CROSSING NORTH EAST ARROW"
\u2933 "WAVE ARROW POINTING DIRECTLY RIGHT"
\u2934 "ARROW POINTING RIGHTWARDS THEN CURVING UPWARDS"
\u2935 "ARROW POINTING RIGHTWARDS THEN CURVING DOWNWARDS"
\u2936 "ARROW POINTING DOWNWARDS THEN CURVING LEFTWARDS"
\u2937 "ARROW POINTING DOWNWARDS THEN CURVING RIGHTWARDS"
\u2938 "RIGHT-SIDE ARC CLOCKWISE ARROW"
\u2939 "LEFT-SIDE ARC ANTICLOCKWISE ARROW"
\u293A "TOP ARC ANTICLOCKWISE ARROW"
\u293B "BOTTOM ARC ANTICLOCKWISE ARROW"
\u293C "TOP ARC CLOCKWISE ARROW WITH MINUS"
\u293D "TOP ARC ANTICLOCKWISE ARROW WITH PLUS"
\u293E "LOWER RIGHT SEMICIRCULAR CLOCKWISE ARROW"
\u293F "LOWER LEFT SEMICIRCULAR ANTICLOCKWISE ARROW"
\u2940 "ANTICLOCKWISE CLOSED CIRCLE ARROW"
\u2941 "CLOCKWISE CLOSED CIRCLE ARROW"
\u2942 "RIGHTWARDS ARROW ABOVE SHORT LEFTWARDS ARROW"
\u2943 "LEFTWARDS ARROW ABOVE SHORT RIGHTWARDS ARROW"
\u2944 "SHORT RIGHTWARDS ARROW ABOVE LEFTWARDS ARROW"
\u2945 "RIGHTWARDS ARROW WITH PLUS BELOW"
\u2946 "LEFTWARDS ARROW WITH PLUS BELOW"
\u2947 "RIGHTWARDS ARROW THROUGH X"
\u2948 "LEFT RIGHT ARROW THROUGH SMALL CIRCLE"
\u2949 "UPWARDS TWO-HEADED ARROW FROM SMALL CIRCLE"
\u294A "LEFT BARB UP RIGHT BARB DOWN HARPOON"
\u294B "LEFT BARB DOWN RIGHT BARB UP HARPOON"
\u294C "UP BARB RIGHT DOWN BARB LEFT HARPOON"
\u294D "UP BARB LEFT DOWN BARB RIGHT HARPOON"
\u294E "LEFT BARB UP RIGHT BARB UP HARPOON"
\u294F "UP BARB RIGHT DOWN BARB RIGHT HARPOON"
\u2950 "LEFT BARB DOWN RIGHT BARB DOWN HARPOON"
\u2951 "UP BARB LEFT DOWN BARB LEFT HARPOON"
\u2952 "LEFTWARDS HARPOON WITH BARB UP TO BAR"
\u2953 "RIGHTWARDS HARPOON WITH BARB UP TO BAR"
\u2954 "UPWARDS HARPOON WITH BARB RIGHT TO BAR"
\u2955 "DOWNWARDS HARPOON WITH BARB RIGHT TO BAR"
\u2956 "LEFTWARDS HARPOON WITH BARB DOWN TO BAR"
\u2957 "RIGHTWARDS HARPOON WITH BARB DOWN TO BAR"
\u2958 "UPWARDS HARPOON WITH BARB LEFT TO BAR"
\u2959 "DOWNWARDS HARPOON WITH BARB LEFT TO BAR"
\u295A "LEFTWARDS HARPOON WITH BARB UP FROM BAR"
\u295B "RIGHTWARDS HARPOON WITH BARB UP FROM BAR"
\u295C "UPWARDS HARPOON WITH BARB RIGHT FROM BAR"
\u295D "DOWNWARDS HARPOON WITH BARB RIGHT FROM BAR"
\u295E "LEFTWARDS HARPOON WITH BARB DOWN FROM BAR"
\u295F "RIGHTWARDS HARPOON WITH BARB DOWN FROM BAR"
\u2960 "UPWARDS HARPOON WITH BARB LEFT FROM BAR"
\u2961 "DOWNWARDS HARPOON WITH BARB LEFT FROM BAR"
\u2962 "LEFTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB DOWN"
\u2963 "UPWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT"
\u2964 "RIGHTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB DOWN"
\u2965 "DOWNWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT"
\u2966 "LEFTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB UP"
\u2967 "LEFTWARDS HARPOON WITH BARB DOWN ABOVE RIGHTWARDS HARPOON WITH BARB DOWN"
\u2968 "RIGHTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB UP"
\u2969 "RIGHTWARDS HARPOON WITH BARB DOWN ABOVE LEFTWARDS HARPOON WITH BARB DOWN"
\u296A "LEFTWARDS HARPOON WITH BARB UP ABOVE LONG DASH"
\u296B "LEFTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH"
\u296C "RIGHTWARDS HARPOON WITH BARB UP ABOVE LONG DASH"
\u296D "RIGHTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH"
\u296E "UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT"
\u296F "DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT"
\u2970 "RIGHT DOUBLE ARROW WITH ROUNDED HEAD"
\u2971 "EQUALS SIGN ABOVE RIGHTWARDS ARROW"
\u2972 "TILDE OPERATOR ABOVE RIGHTWARDS ARROW"
\u2973 "LEFTWARDS ARROW ABOVE TILDE OPERATOR"
\u2974 "RIGHTWARDS ARROW ABOVE TILDE OPERATOR"
\u2975 "RIGHTWARDS ARROW ABOVE ALMOST EQUAL TO"
\u2976 "LESS-THAN ABOVE LEFTWARDS ARROW"
\u2977 "LEFTWARDS ARROW THROUGH LESS-THAN"
\u2978 "GREATER-THAN ABOVE RIGHTWARDS ARROW"
\u2979 "SUBSET ABOVE RIGHTWARDS ARROW"
\u297A "LEFTWARDS ARROW THROUGH SUBSET"
\u297B "SUPERSET ABOVE LEFTWARDS ARROW"
\u297C "LEFT FISH TAIL"
\u297D "RIGHT FISH TAIL"
\u297E "UP FISH TAIL"
\u297F "DOWN FISH TAIL"
\u2980 "TRIPLE VERTICAL BAR DELIMITER"
\u2981 "Z NOTATION SPOT"
\u2982 "Z NOTATION TYPE COLON"
\u2983 "LEFT WHITE CURLY BRACKET"
\u2984 "RIGHT WHITE CURLY BRACKET"
\u2985 "LEFT WHITE PARENTHESIS"
\u2986 "RIGHT WHITE PARENTHESIS"
\u2987 "Z NOTATION LEFT IMAGE BRACKET"
\u2988 "Z NOTATION RIGHT IMAGE BRACKET"
\u2989 "Z NOTATION LEFT BINDING BRACKET"
\u298A "Z NOTATION RIGHT BINDING BRACKET"
\u298B "LEFT SQUARE BRACKET WITH UNDERBAR"
\u298C "RIGHT SQUARE BRACKET WITH UNDERBAR"
\u298D "LEFT SQUARE BRACKET WITH TICK IN TOP CORNER"
\u298E "RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER"
\u298F "LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER"
\u2990 "RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER"
\u2991 "LEFT ANGLE BRACKET WITH DOT"
\u2992 "RIGHT ANGLE BRACKET WITH DOT"
\u2993 "LEFT ARC LESS-THAN BRACKET"
\u2994 "RIGHT ARC GREATER-THAN BRACKET"
\u2995 "DOUBLE LEFT ARC GREATER-THAN BRACKET"
\u2996 "DOUBLE RIGHT ARC LESS-THAN BRACKET"
\u2997 "LEFT BLACK TORTOISE SHELL BRACKET"
\u2998 "RIGHT BLACK TORTOISE SHELL BRACKET"
\u2999 "DOTTED FENCE"
\u299A "VERTICAL ZIGZAG LINE"
\u299B "MEASURED ANGLE OPENING LEFT"
\u299C "RIGHT ANGLE VARIANT WITH SQUARE"
\u299D "MEASURED RIGHT ANGLE WITH DOT"
\u299E "ANGLE WITH S INSIDE"
\u299F "ACUTE ANGLE"
\u29A0 "SPHERICAL ANGLE OPENING LEFT"
\u29A1 "SPHERICAL ANGLE OPENING UP"
\u29A2 "TURNED ANGLE"
\u29A3 "REVERSED ANGLE"
\u29A4 "ANGLE WITH UNDERBAR"
\u29A5 "REVERSED ANGLE WITH UNDERBAR"
\u29A6 "OBLIQUE ANGLE OPENING UP"
\u29A7 "OBLIQUE ANGLE OPENING DOWN"
\u29A8 "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND RIGHT"
\u29A9 "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND LEFT"
\u29AA "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND RIGHT"
\u29AB "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND LEFT"
\u29AC "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND UP"
\u29AD "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND UP"
\u29AE "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND DOWN"
\u29AF "MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND DOWN"
\u29B0 "REVERSED EMPTY SET"
\u29B1 "EMPTY SET WITH OVERBAR"
\u29B2 "EMPTY SET WITH SMALL CIRCLE ABOVE"
\u29B3 "EMPTY SET WITH RIGHT ARROW ABOVE"
\u29B4 "EMPTY SET WITH LEFT ARROW ABOVE"
\u29B5 "CIRCLE WITH HORIZONTAL BAR"
\u29B6 "CIRCLED VERTICAL BAR"
\u29B7 "CIRCLED PARALLEL"
\u29B8 "CIRCLED REVERSE SOLIDUS"
\u29B9 "CIRCLED PERPENDICULAR"
\u29BA "CIRCLE DIVIDED BY HORIZONTAL BAR AND TOP HALF DIVIDED BY VERTICAL BAR"
\u29BB "CIRCLE WITH SUPERIMPOSED X"
\u29BC "CIRCLED ANTICLOCKWISE-ROTATED DIVISION SIGN"
\u29BD "UP ARROW THROUGH CIRCLE"
\u29BE "CIRCLED WHITE BULLET"
\u29BF "CIRCLED BULLET"
\u29C0 "CIRCLED LESS-THAN"
\u29C1 "CIRCLED GREATER-THAN"
\u29C2 "CIRCLE WITH SMALL CIRCLE TO THE RIGHT"
\u29C3 "CIRCLE WITH TWO HORIZONTAL STROKES TO THE RIGHT"
\u29C4 "SQUARED RISING DIAGONAL SLASH"
\u29C5 "SQUARED FALLING DIAGONAL SLASH"
\u29C6 "SQUARED ASTERISK"
\u29C7 "SQUARED SMALL CIRCLE"
\u29C8 "SQUARED SQUARE"
\u29C9 "TWO JOINED SQUARES"
\u29CA "TRIANGLE WITH DOT ABOVE"
\u29CB "TRIANGLE WITH UNDERBAR"
\u29CC "S IN TRIANGLE"
\u29CD "TRIANGLE WITH SERIFS AT BOTTOM"
\u29CE "RIGHT TRIANGLE ABOVE LEFT TRIANGLE"
\u29CF "LEFT TRIANGLE BESIDE VERTICAL BAR"
\u29D0 "VERTICAL BAR BESIDE RIGHT TRIANGLE"
\u29D1 "BOWTIE WITH LEFT HALF BLACK"
\u29D2 "BOWTIE WITH RIGHT HALF BLACK"
\u29D3 "BLACK BOWTIE"
\u29D4 "TIMES WITH LEFT HALF BLACK"
\u29D5 "TIMES WITH RIGHT HALF BLACK"
\u29D6 "WHITE HOURGLASS"
\u29D7 "BLACK HOURGLASS"
\u29D8 "LEFT WIGGLY FENCE"
\u29D9 "RIGHT WIGGLY FENCE"
\u29DA "LEFT DOUBLE WIGGLY FENCE"
\u29DB "RIGHT DOUBLE WIGGLY FENCE"
\u29DC "INCOMPLETE INFINITY"
\u29DD "TIE OVER INFINITY"
\u29DE "INFINITY NEGATED WITH VERTICAL BAR"
\u29DF "DOUBLE-ENDED MULTIMAP"
\u29E0 "SQUARE WITH CONTOURED OUTLINE"
\u29E1 "INCREASES AS"
\u29E2 "SHUFFLE PRODUCT"
\u29E3 "EQUALS SIGN AND SLANTED PARALLEL"
\u29E4 "EQUALS SIGN AND SLANTED PARALLEL WITH TILDE ABOVE"
\u29E5 "IDENTICAL TO AND SLANTED PARALLEL"
\u29E6 "GLEICH STARK"
\u29E7 "THERMODYNAMIC"
\u29E8 "DOWN-POINTING TRIANGLE WITH LEFT HALF BLACK"
\u29E9 "DOWN-POINTING TRIANGLE WITH RIGHT HALF BLACK"
\u29EA "BLACK DIAMOND WITH DOWN ARROW"
\u29EB "BLACK LOZENGE"
\u29EC "WHITE CIRCLE WITH DOWN ARROW"
\u29ED "BLACK CIRCLE WITH DOWN ARROW"
\u29EE "ERROR-BARRED WHITE SQUARE"
\u29EF "ERROR-BARRED BLACK SQUARE"
\u29F0 "ERROR-BARRED WHITE DIAMOND"
\u29F1 "ERROR-BARRED BLACK DIAMOND"
\u29F2 "ERROR-BARRED WHITE CIRCLE"
\u29F3 "ERROR-BARRED BLACK CIRCLE"
\u29F4 "RULE-DELAYED"
\u29F5 "REVERSE SOLIDUS OPERATOR"
\u29F6 "SOLIDUS WITH OVERBAR"
\u29F7 "REVERSE SOLIDUS WITH HORIZONTAL STROKE"
\u29F8 "BIG SOLIDUS"
\u29F9 "BIG REVERSE SOLIDUS"
\u29FA "DOUBLE PLUS"
\u29FB "TRIPLE PLUS"
\u29FC "LEFT-POINTING CURVED ANGLE BRACKET"
\u29FD "RIGHT-POINTING CURVED ANGLE BRACKET"
\u29FE "TINY"
\u29FF "MINY"
\u2A00 "N-ARY CIRCLED DOT OPERATOR"
\u2A01 "N-ARY CIRCLED PLUS OPERATOR"
\u2A02 "N-ARY CIRCLED TIMES OPERATOR"
\u2A03 "N-ARY UNION OPERATOR WITH DOT"
\u2A04 "N-ARY UNION OPERATOR WITH PLUS"
\u2A05 "N-ARY SQUARE INTERSECTION OPERATOR"
\u2A06 "N-ARY SQUARE UNION OPERATOR"
\u2A07 "TWO LOGICAL AND OPERATOR"
\u2A08 "TWO LOGICAL OR OPERATOR"
\u2A09 "N-ARY TIMES OPERATOR"
\u2A0A "MODULO TWO SUM"
\u2A0B "SUMMATION WITH INTEGRAL"
\u2A0C "QUADRUPLE INTEGRAL OPERATOR"
\u2A0D "FINITE PART INTEGRAL"
\u2A0E "INTEGRAL WITH DOUBLE STROKE"
\u2A0F "INTEGRAL AVERAGE WITH SLASH"
\u2A10 "CIRCULATION FUNCTION"
\u2A11 "ANTICLOCKWISE INTEGRATION"
\u2A12 "LINE INTEGRATION WITH RECTANGULAR PATH AROUND POLE"
\u2A13 "LINE INTEGRATION WITH SEMICIRCULAR PATH AROUND POLE"
\u2A14 "LINE INTEGRATION NOT INCLUDING THE POLE"
\u2A15 "INTEGRAL AROUND A POINT OPERATOR"
\u2A16 "QUATERNION INTEGRAL OPERATOR"
\u2A17 "INTEGRAL WITH LEFTWARDS ARROW WITH HOOK"
\u2A18 "INTEGRAL WITH TIMES SIGN"
\u2A19 "INTEGRAL WITH INTERSECTION"
\u2A1A "INTEGRAL WITH UNION"
\u2A1B "INTEGRAL WITH OVERBAR"
\u2A1C "INTEGRAL WITH UNDERBAR"
\u2A1D "JOIN"
\u2A1E "LARGE LEFT TRIANGLE OPERATOR"
\u2A1F "Z NOTATION SCHEMA COMPOSITION"
\u2A20 "Z NOTATION SCHEMA PIPING"
\u2A21 "Z NOTATION SCHEMA PROJECTION"
\u2A22 "PLUS SIGN WITH SMALL CIRCLE ABOVE"
\u2A23 "PLUS SIGN WITH CIRCUMFLEX ACCENT ABOVE"
\u2A24 "PLUS SIGN WITH TILDE ABOVE"
\u2A25 "PLUS SIGN WITH DOT BELOW"
\u2A26 "PLUS SIGN WITH TILDE BELOW"
\u2A27 "PLUS SIGN WITH SUBSCRIPT TWO"
\u2A28 "PLUS SIGN WITH BLACK TRIANGLE"
\u2A29 "MINUS SIGN WITH COMMA ABOVE"
\u2A2A "MINUS SIGN WITH DOT BELOW"
\u2A2B "MINUS SIGN WITH FALLING DOTS"
\u2A2C "MINUS SIGN WITH RISING DOTS"
\u2A2D "PLUS SIGN IN LEFT HALF CIRCLE"
\u2A2E "PLUS SIGN IN RIGHT HALF CIRCLE"
\u2A2F "VECTOR OR CROSS PRODUCT"
\u2A30 "MULTIPLICATION SIGN WITH DOT ABOVE"
\u2A31 "MULTIPLICATION SIGN WITH UNDERBAR"
\u2A32 "SEMIDIRECT PRODUCT WITH BOTTOM CLOSED"
\u2A33 "SMASH PRODUCT"
\u2A34 "MULTIPLICATION SIGN IN LEFT HALF CIRCLE"
\u2A35 "MULTIPLICATION SIGN IN RIGHT HALF CIRCLE"
\u2A36 "CIRCLED MULTIPLICATION SIGN WITH CIRCUMFLEX ACCENT"
\u2A37 "MULTIPLICATION SIGN IN DOUBLE CIRCLE"
\u2A38 "CIRCLED DIVISION SIGN"
\u2A39 "PLUS SIGN IN TRIANGLE"
\u2A3A "MINUS SIGN IN TRIANGLE"
\u2A3B "MULTIPLICATION SIGN IN TRIANGLE"
\u2A3C "INTERIOR PRODUCT"
\u2A3D "RIGHTHAND INTERIOR PRODUCT"
\u2A3E "Z NOTATION RELATIONAL COMPOSITION"
\u2A3F "AMALGAMATION OR COPRODUCT"
\u2A40 "INTERSECTION WITH DOT"
\u2A41 "UNION WITH MINUS SIGN"
\u2A42 "UNION WITH OVERBAR"
\u2A43 "INTERSECTION WITH OVERBAR"
\u2A44 "INTERSECTION WITH LOGICAL AND"
\u2A45 "UNION WITH LOGICAL OR"
\u2A46 "UNION ABOVE INTERSECTION"
\u2A47 "INTERSECTION ABOVE UNION"
\u2A48 "UNION ABOVE BAR ABOVE INTERSECTION"
\u2A49 "INTERSECTION ABOVE BAR ABOVE UNION"
\u2A4A "UNION BESIDE AND JOINED WITH UNION"
\u2A4B "INTERSECTION BESIDE AND JOINED WITH INTERSECTION"
\u2A4C "CLOSED UNION WITH SERIFS"
\u2A4D "CLOSED INTERSECTION WITH SERIFS"
\u2A4E "DOUBLE SQUARE INTERSECTION"
\u2A4F "DOUBLE SQUARE UNION"
\u2A50 "CLOSED UNION WITH SERIFS AND SMASH PRODUCT"
\u2A51 "LOGICAL AND WITH DOT ABOVE"
\u2A52 "LOGICAL OR WITH DOT ABOVE"
\u2A53 "DOUBLE LOGICAL AND"
\u2A54 "DOUBLE LOGICAL OR"
\u2A55 "TWO INTERSECTING LOGICAL AND"
\u2A56 "TWO INTERSECTING LOGICAL OR"
\u2A57 "SLOPING LARGE OR"
\u2A58 "SLOPING LARGE AND"
\u2A59 "LOGICAL OR OVERLAPPING LOGICAL AND"
\u2A5A "LOGICAL AND WITH MIDDLE STEM"
\u2A5B "LOGICAL OR WITH MIDDLE STEM"
\u2A5C "LOGICAL AND WITH HORIZONTAL DASH"
\u2A5D "LOGICAL OR WITH HORIZONTAL DASH"
\u2A5E "LOGICAL AND WITH DOUBLE OVERBAR"
\u2A5F "LOGICAL AND WITH UNDERBAR"
\u2A60 "LOGICAL AND WITH DOUBLE UNDERBAR"
\u2A61 "SMALL VEE WITH UNDERBAR"
\u2A62 "LOGICAL OR WITH DOUBLE OVERBAR"
\u2A63 "LOGICAL OR WITH DOUBLE UNDERBAR"
\u2A64 "Z NOTATION DOMAIN ANTIRESTRICTION"
\u2A65 "Z NOTATION RANGE ANTIRESTRICTION"
\u2A66 "EQUALS SIGN WITH DOT BELOW"
\u2A67 "IDENTICAL WITH DOT ABOVE"
\u2A68 "TRIPLE HORIZONTAL BAR WITH DOUBLE VERTICAL STROKE"
\u2A69 "TRIPLE HORIZONTAL BAR WITH TRIPLE VERTICAL STROKE"
\u2A6A "TILDE OPERATOR WITH DOT ABOVE"
\u2A6B "TILDE OPERATOR WITH RISING DOTS"
\u2A6C "SIMILAR MINUS SIMILAR"
\u2A6D "CONGRUENT WITH DOT ABOVE"
\u2A6E "EQUALS WITH ASTERISK"
\u2A6F "ALMOST EQUAL TO WITH CIRCUMFLEX ACCENT"
\u2A70 "APPROXIMATELY EQUAL OR EQUAL TO"
\u2A71 "EQUALS SIGN ABOVE PLUS SIGN"
\u2A72 "PLUS SIGN ABOVE EQUALS SIGN"
\u2A73 "EQUALS SIGN ABOVE TILDE OPERATOR"
\u2A74 "DOUBLE COLON EQUAL"
\u2A75 "TWO CONSECUTIVE EQUALS SIGNS"
\u2A76 "THREE CONSECUTIVE EQUALS SIGNS"
\u2A77 "EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW"
\u2A78 "EQUIVALENT WITH FOUR DOTS ABOVE"
\u2A79 "LESS-THAN WITH CIRCLE INSIDE"
\u2A7A "GREATER-THAN WITH CIRCLE INSIDE"
\u2A7B "LESS-THAN WITH QUESTION MARK ABOVE"
\u2A7C "GREATER-THAN WITH QUESTION MARK ABOVE"
\u2A7D "LESS-THAN OR SLANTED EQUAL TO"
\u2A7E "GREATER-THAN OR SLANTED EQUAL TO"
\u2A7F "LESS-THAN OR SLANTED EQUAL TO WITH DOT INSIDE"
\u2A80 "GREATER-THAN OR SLANTED EQUAL TO WITH DOT INSIDE"
\u2A81 "LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE"
\u2A82 "GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE"
\u2A83 "LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE RIGHT"
\u2A84 "GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE LEFT"
\u2A85 "LESS-THAN OR APPROXIMATE"
\u2A86 "GREATER-THAN OR APPROXIMATE"
\u2A87 "LESS-THAN AND SINGLE-LINE NOT EQUAL TO"
\u2A88 "GREATER-THAN AND SINGLE-LINE NOT EQUAL TO"
\u2A89 "LESS-THAN AND NOT APPROXIMATE"
\u2A8A "GREATER-THAN AND NOT APPROXIMATE"
\u2A8B "LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN"
\u2A8C "GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN"
\u2A8D "LESS-THAN ABOVE SIMILAR OR EQUAL"
\u2A8E "GREATER-THAN ABOVE SIMILAR OR EQUAL"
\u2A8F "LESS-THAN ABOVE SIMILAR ABOVE GREATER-THAN"
\u2A90 "GREATER-THAN ABOVE SIMILAR ABOVE LESS-THAN"
\u2A91 "LESS-THAN ABOVE GREATER-THAN ABOVE DOUBLE-LINE EQUAL"
\u2A92 "GREATER-THAN ABOVE LESS-THAN ABOVE DOUBLE-LINE EQUAL"
\u2A93 "LESS-THAN ABOVE SLANTED EQUAL ABOVE GREATER-THAN ABOVE SLANTED EQUAL"
\u2A94 "GREATER-THAN ABOVE SLANTED EQUAL ABOVE LESS-THAN ABOVE SLANTED EQUAL"
\u2A95 "SLANTED EQUAL TO OR LESS-THAN"
\u2A96 "SLANTED EQUAL TO OR GREATER-THAN"
\u2A97 "SLANTED EQUAL TO OR LESS-THAN WITH DOT INSIDE"
\u2A98 "SLANTED EQUAL TO OR GREATER-THAN WITH DOT INSIDE"
\u2A99 "DOUBLE-LINE EQUAL TO OR LESS-THAN"
\u2A9A "DOUBLE-LINE EQUAL TO OR GREATER-THAN"
\u2A9B "DOUBLE-LINE SLANTED EQUAL TO OR LESS-THAN"
\u2A9C "DOUBLE-LINE SLANTED EQUAL TO OR GREATER-THAN"
\u2A9D "SIMILAR OR LESS-THAN"
\u2A9E "SIMILAR OR GREATER-THAN"
\u2A9F "SIMILAR ABOVE LESS-THAN ABOVE EQUALS SIGN"
\u2AA0 "SIMILAR ABOVE GREATER-THAN ABOVE EQUALS SIGN"
\u2AA1 "DOUBLE NESTED LESS-THAN"
\u2AA2 "DOUBLE NESTED GREATER-THAN"
\u2AA3 "DOUBLE NESTED LESS-THAN WITH UNDERBAR"
\u2AA4 "GREATER-THAN OVERLAPPING LESS-THAN"
\u2AA5 "GREATER-THAN BESIDE LESS-THAN"
\u2AA6 "LESS-THAN CLOSED BY CURVE"
\u2AA7 "GREATER-THAN CLOSED BY CURVE"
\u2AA8 "LESS-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL"
\u2AA9 "GREATER-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL"
\u2AAA "SMALLER THAN"
\u2AAB "LARGER THAN"
\u2AAC "SMALLER THAN OR EQUAL TO"
\u2AAD "LARGER THAN OR EQUAL TO"
\u2AAE "EQUALS SIGN WITH BUMPY ABOVE"
\u2AAF "PRECEDES ABOVE SINGLE-LINE EQUALS SIGN"
\u2AB0 "SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN"
\u2AB1 "PRECEDES ABOVE SINGLE-LINE NOT EQUAL TO"
\u2AB2 "SUCCEEDS ABOVE SINGLE-LINE NOT EQUAL TO"
\u2AB3 "PRECEDES ABOVE EQUALS SIGN"
\u2AB4 "SUCCEEDS ABOVE EQUALS SIGN"
\u2AB5 "PRECEDES ABOVE NOT EQUAL TO"
\u2AB6 "SUCCEEDS ABOVE NOT EQUAL TO"
\u2AB7 "PRECEDES ABOVE ALMOST EQUAL TO"
\u2AB8 "SUCCEEDS ABOVE ALMOST EQUAL TO"
\u2AB9 "PRECEDES ABOVE NOT ALMOST EQUAL TO"
\u2ABA "SUCCEEDS ABOVE NOT ALMOST EQUAL TO"
\u2ABB "DOUBLE PRECEDES"
\u2ABC "DOUBLE SUCCEEDS"
\u2ABD "SUBSET WITH DOT"
\u2ABE "SUPERSET WITH DOT"
\u2ABF "SUBSET WITH PLUS SIGN BELOW"
\u2AC0 "SUPERSET WITH PLUS SIGN BELOW"
\u2AC1 "SUBSET WITH MULTIPLICATION SIGN BELOW"
\u2AC2 "SUPERSET WITH MULTIPLICATION SIGN BELOW"
\u2AC3 "SUBSET OF OR EQUAL TO WITH DOT ABOVE"
\u2AC4 "SUPERSET OF OR EQUAL TO WITH DOT ABOVE"
\u2AC5 "SUBSET OF ABOVE EQUALS SIGN"
\u2AC6 "SUPERSET OF ABOVE EQUALS SIGN"
\u2AC7 "SUBSET OF ABOVE TILDE OPERATOR"
\u2AC8 "SUPERSET OF ABOVE TILDE OPERATOR"
\u2AC9 "SUBSET OF ABOVE ALMOST EQUAL TO"
\u2ACA "SUPERSET OF ABOVE ALMOST EQUAL TO"
\u2ACB "SUBSET OF ABOVE NOT EQUAL TO"
\u2ACC "SUPERSET OF ABOVE NOT EQUAL TO"
\u2ACD "SQUARE LEFT OPEN BOX OPERATOR"
\u2ACE "SQUARE RIGHT OPEN BOX OPERATOR"
\u2ACF "CLOSED SUBSET"
\u2AD0 "CLOSED SUPERSET"
\u2AD1 "CLOSED SUBSET OR EQUAL TO"
\u2AD2 "CLOSED SUPERSET OR EQUAL TO"
\u2AD3 "SUBSET ABOVE SUPERSET"
\u2AD4 "SUPERSET ABOVE SUBSET"
\u2AD5 "SUBSET ABOVE SUBSET"
\u2AD6 "SUPERSET ABOVE SUPERSET"
\u2AD7 "SUPERSET BESIDE SUBSET"
\u2AD8 "SUPERSET BESIDE AND JOINED BY DASH WITH SUBSET"
\u2AD9 "ELEMENT OF OPENING DOWNWARDS"
\u2ADA "PITCHFORK WITH TEE TOP"
\u2ADB "TRANSVERSAL INTERSECTION"
\u2ADC "FORKING"
\u2ADD "NONFORKING"
\u2ADE "SHORT LEFT TACK"
\u2ADF "SHORT DOWN TACK"
\u2AE0 "SHORT UP TACK"
\u2AE1 "PERPENDICULAR WITH S"
\u2AE2 "VERTICAL BAR TRIPLE RIGHT TURNSTILE"
\u2AE3 "DOUBLE VERTICAL BAR LEFT TURNSTILE"
\u2AE4 "VERTICAL BAR DOUBLE LEFT TURNSTILE"
\u2AE5 "DOUBLE VERTICAL BAR DOUBLE LEFT TURNSTILE"
\u2AE6 "LONG DASH FROM LEFT MEMBER OF DOUBLE VERTICAL"
\u2AE7 "SHORT DOWN TACK WITH OVERBAR"
\u2AE8 "SHORT UP TACK WITH UNDERBAR"
\u2AE9 "SHORT UP TACK ABOVE SHORT DOWN TACK"
\u2AEA "DOUBLE DOWN TACK"
\u2AEB "DOUBLE UP TACK"
\u2AEC "DOUBLE STROKE NOT SIGN"
\u2AED "REVERSED DOUBLE STROKE NOT SIGN"
\u2AEE "DOES NOT DIVIDE WITH REVERSED NEGATION SLASH"
\u2AEF "VERTICAL LINE WITH CIRCLE ABOVE"
\u2AF0 "VERTICAL LINE WITH CIRCLE BELOW"
\u2AF1 "DOWN TACK WITH CIRCLE BELOW"
\u2AF2 "PARALLEL WITH HORIZONTAL STROKE"
\u2AF3 "PARALLEL WITH TILDE OPERATOR"
\u2AF4 "TRIPLE VERTICAL BAR BINARY RELATION"
\u2AF5 "TRIPLE VERTICAL BAR WITH HORIZONTAL STROKE"
\u2AF6 "TRIPLE COLON OPERATOR"
\u2AF7 "TRIPLE NESTED LESS-THAN"
\u2AF8 "TRIPLE NESTED GREATER-THAN"
\u2AF9 "DOUBLE-LINE SLANTED LESS-THAN OR EQUAL TO"
\u2AFA "DOUBLE-LINE SLANTED GREATER-THAN OR EQUAL TO"
\u2AFB "TRIPLE SOLIDUS BINARY RELATION"
\u2AFC "LARGE TRIPLE VERTICAL BAR OPERATOR"
\u2AFD "DOUBLE SOLIDUS OPERATOR"
\u2AFE "WHITE VERTICAL BAR"
\u2AFF "N-ARY WHITE VERTICAL BAR"
\u2B00 "NORTH EAST WHITE ARROW"
\u2B01 "NORTH WEST WHITE ARROW"
\u2B02 "SOUTH EAST WHITE ARROW"
\u2B03 "SOUTH WEST WHITE ARROW"
\u2B04 "LEFT RIGHT WHITE ARROW"
\u2B05 "LEFTWARDS BLACK ARROW"
\u2B06 "UPWARDS BLACK ARROW"
\u2B07 "DOWNWARDS BLACK ARROW"
\u2B08 "NORTH EAST BLACK ARROW"
\u2B09 "NORTH WEST BLACK ARROW"
\u2B0A "SOUTH EAST BLACK ARROW"
\u2B0B "SOUTH WEST BLACK ARROW"
\u2B0C "LEFT RIGHT BLACK ARROW"
\u2B0D "UP DOWN BLACK ARROW"
\u2B0E "RIGHTWARDS ARROW WITH TIP DOWNWARDS"
\u2B0F "RIGHTWARDS ARROW WITH TIP UPWARDS"
\u2B10 "LEFTWARDS ARROW WITH TIP DOWNWARDS"
\u2B11 "LEFTWARDS ARROW WITH TIP UPWARDS"
\u2B12 "SQUARE WITH TOP HALF BLACK"
\u2B13 "SQUARE WITH BOTTOM HALF BLACK"
\u2B14 "SQUARE WITH UPPER RIGHT DIAGONAL HALF BLACK"
\u2B15 "SQUARE WITH LOWER LEFT DIAGONAL HALF BLACK"
\u2B16 "DIAMOND WITH LEFT HALF BLACK"
\u2B17 "DIAMOND WITH RIGHT HALF BLACK"
\u2B18 "DIAMOND WITH TOP HALF BLACK"
\u2B19 "DIAMOND WITH BOTTOM HALF BLACK"
\u2B1A "DOTTED SQUARE"
\u2B1B "BLACK LARGE SQUARE"
\u2B1C "WHITE LARGE SQUARE"
\u2B1D "BLACK VERY SMALL SQUARE"
\u2B1E "WHITE VERY SMALL SQUARE"
\u2B1F "BLACK PENTAGON"
\u2B20 "WHITE PENTAGON"
\u2B21 "WHITE HEXAGON"
\u2B22 "BLACK HEXAGON"
\u2B23 "HORIZONTAL BLACK HEXAGON"
\u2B24 "BLACK LARGE CIRCLE"
\u2B25 "BLACK MEDIUM DIAMOND"
\u2B26 "WHITE MEDIUM DIAMOND"
\u2B27 "BLACK MEDIUM LOZENGE"
\u2B28 "WHITE MEDIUM LOZENGE"
\u2B29 "BLACK SMALL DIAMOND"
\u2B2A "BLACK SMALL LOZENGE"
\u2B2B "WHITE SMALL LOZENGE"
\u2B2C "BLACK HORIZONTAL ELLIPSE"
\u2B2D "WHITE HORIZONTAL ELLIPSE"
\u2B2E "BLACK VERTICAL ELLIPSE"
\u2B2F "WHITE VERTICAL ELLIPSE"
\u2B30 "LEFT ARROW WITH SMALL CIRCLE"
\u2B31 "THREE LEFTWARDS ARROWS"
\u2B32 "LEFT ARROW WITH CIRCLED PLUS"
\u2B33 "LONG LEFTWARDS SQUIGGLE ARROW"
\u2B34 "LEFTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE"
\u2B35 "LEFTWARDS TWO-HEADED ARROW WITH DOUBLE VERTICAL STROKE"
\u2B36 "LEFTWARDS TWO-HEADED ARROW FROM BAR"
\u2B37 "LEFTWARDS TWO-HEADED TRIPLE DASH ARROW"
\u2B38 "LEFTWARDS ARROW WITH DOTTED STEM"
\u2B39 "LEFTWARDS ARROW WITH TAIL WITH VERTICAL STROKE"
\u2B3A "LEFTWARDS ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE"
\u2B3B "LEFTWARDS TWO-HEADED ARROW WITH TAIL"
\u2B3C "LEFTWARDS TWO-HEADED ARROW WITH TAIL WITH VERTICAL STROKE"
\u2B3D "LEFTWARDS TWO-HEADED ARROW WITH TAIL WITH DOUBLE VERTICAL STROKE"
\u2B3E "LEFTWARDS ARROW THROUGH X"
\u2B3F "WAVE ARROW POINTING DIRECTLY LEFT"
\u2B40 "EQUALS SIGN ABOVE LEFTWARDS ARROW"
\u2B41 "REVERSE TILDE OPERATOR ABOVE LEFTWARDS ARROW"
\u2B42 "LEFTWARDS ARROW ABOVE REVERSE ALMOST EQUAL TO"
\u2B43 "RIGHTWARDS ARROW THROUGH GREATER-THAN"
\u2B44 "RIGHTWARDS ARROW THROUGH SUPERSET"
\u2B45 "LEFTWARDS QUADRUPLE ARROW"
\u2B46 "RIGHTWARDS QUADRUPLE ARROW"
\u2B47 "REVERSE TILDE OPERATOR ABOVE RIGHTWARDS ARROW"
\u2B48 "RIGHTWARDS ARROW ABOVE REVERSE ALMOST EQUAL TO"
\u2B49 "TILDE OPERATOR ABOVE LEFTWARDS ARROW"
\u2B4A "LEFTWARDS ARROW ABOVE ALMOST EQUAL TO"
\u2B4B "LEFTWARDS ARROW ABOVE REVERSE TILDE OPERATOR"
\u2B4C "RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR"
\u2B50 "WHITE MEDIUM STAR"
\u2B51 "BLACK SMALL STAR"
\u2B52 "WHITE SMALL STAR"
\u2B53 "BLACK RIGHT-POINTING PENTAGON"
\u2B54 "WHITE RIGHT-POINTING PENTAGON"
\u2C00 "GLAGOLITIC CAPITAL LETTER AZU"
\u2C01 "GLAGOLITIC CAPITAL LETTER BUKY"
\u2C02 "GLAGOLITIC CAPITAL LETTER VEDE"
\u2C03 "GLAGOLITIC CAPITAL LETTER GLAGOLI"
\u2C04 "GLAGOLITIC CAPITAL LETTER DOBRO"
\u2C05 "GLAGOLITIC CAPITAL LETTER YESTU"
\u2C06 "GLAGOLITIC CAPITAL LETTER ZHIVETE"
\u2C07 "GLAGOLITIC CAPITAL LETTER DZELO"
\u2C08 "GLAGOLITIC CAPITAL LETTER ZEMLJA"
\u2C09 "GLAGOLITIC CAPITAL LETTER IZHE"
\u2C0A "GLAGOLITIC CAPITAL LETTER INITIAL IZHE"
\u2C0B "GLAGOLITIC CAPITAL LETTER I"
\u2C0C "GLAGOLITIC CAPITAL LETTER DJERVI"
\u2C0D "GLAGOLITIC CAPITAL LETTER KAKO"
\u2C0E "GLAGOLITIC CAPITAL LETTER LJUDIJE"
\u2C0F "GLAGOLITIC CAPITAL LETTER MYSLITE"
\u2C10 "GLAGOLITIC CAPITAL LETTER NASHI"
\u2C11 "GLAGOLITIC CAPITAL LETTER ONU"
\u2C12 "GLAGOLITIC CAPITAL LETTER POKOJI"
\u2C13 "GLAGOLITIC CAPITAL LETTER RITSI"
\u2C14 "GLAGOLITIC CAPITAL LETTER SLOVO"
\u2C15 "GLAGOLITIC CAPITAL LETTER TVRIDO"
\u2C16 "GLAGOLITIC CAPITAL LETTER UKU"
\u2C17 "GLAGOLITIC CAPITAL LETTER FRITU"
\u2C18 "GLAGOLITIC CAPITAL LETTER HERU"
\u2C19 "GLAGOLITIC CAPITAL LETTER OTU"
\u2C1A "GLAGOLITIC CAPITAL LETTER PE"
\u2C1B "GLAGOLITIC CAPITAL LETTER SHTA"
\u2C1C "GLAGOLITIC CAPITAL LETTER TSI"
\u2C1D "GLAGOLITIC CAPITAL LETTER CHRIVI"
\u2C1E "GLAGOLITIC CAPITAL LETTER SHA"
\u2C1F "GLAGOLITIC CAPITAL LETTER YERU"
\u2C20 "GLAGOLITIC CAPITAL LETTER YERI"
\u2C21 "GLAGOLITIC CAPITAL LETTER YATI"
\u2C22 "GLAGOLITIC CAPITAL LETTER SPIDERY HA"
\u2C23 "GLAGOLITIC CAPITAL LETTER YU"
\u2C24 "GLAGOLITIC CAPITAL LETTER SMALL YUS"
\u2C25 "GLAGOLITIC CAPITAL LETTER SMALL YUS WITH TAIL"
\u2C26 "GLAGOLITIC CAPITAL LETTER YO"
\u2C27 "GLAGOLITIC CAPITAL LETTER IOTATED SMALL YUS"
\u2C28 "GLAGOLITIC CAPITAL LETTER BIG YUS"
\u2C29 "GLAGOLITIC CAPITAL LETTER IOTATED BIG YUS"
\u2C2A "GLAGOLITIC CAPITAL LETTER FITA"
\u2C2B "GLAGOLITIC CAPITAL LETTER IZHITSA"
\u2C2C "GLAGOLITIC CAPITAL LETTER SHTAPIC"
\u2C2D "GLAGOLITIC CAPITAL LETTER TROKUTASTI A"
\u2C2E "GLAGOLITIC CAPITAL LETTER LATINATE MYSLITE"
\u2C30 "GLAGOLITIC SMALL LETTER AZU"
\u2C31 "GLAGOLITIC SMALL LETTER BUKY"
\u2C32 "GLAGOLITIC SMALL LETTER VEDE"
\u2C33 "GLAGOLITIC SMALL LETTER GLAGOLI"
\u2C34 "GLAGOLITIC SMALL LETTER DOBRO"
\u2C35 "GLAGOLITIC SMALL LETTER YESTU"
\u2C36 "GLAGOLITIC SMALL LETTER ZHIVETE"
\u2C37 "GLAGOLITIC SMALL LETTER DZELO"
\u2C38 "GLAGOLITIC SMALL LETTER ZEMLJA"
\u2C39 "GLAGOLITIC SMALL LETTER IZHE"
\u2C3A "GLAGOLITIC SMALL LETTER INITIAL IZHE"
\u2C3B "GLAGOLITIC SMALL LETTER I"
\u2C3C "GLAGOLITIC SMALL LETTER DJERVI"
\u2C3D "GLAGOLITIC SMALL LETTER KAKO"
\u2C3E "GLAGOLITIC SMALL LETTER LJUDIJE"
\u2C3F "GLAGOLITIC SMALL LETTER MYSLITE"
\u2C40 "GLAGOLITIC SMALL LETTER NASHI"
\u2C41 "GLAGOLITIC SMALL LETTER ONU"
\u2C42 "GLAGOLITIC SMALL LETTER POKOJI"
\u2C43 "GLAGOLITIC SMALL LETTER RITSI"
\u2C44 "GLAGOLITIC SMALL LETTER SLOVO"
\u2C45 "GLAGOLITIC SMALL LETTER TVRIDO"
\u2C46 "GLAGOLITIC SMALL LETTER UKU"
\u2C47 "GLAGOLITIC SMALL LETTER FRITU"
\u2C48 "GLAGOLITIC SMALL LETTER HERU"
\u2C49 "GLAGOLITIC SMALL LETTER OTU"
\u2C4A "GLAGOLITIC SMALL LETTER PE"
\u2C4B "GLAGOLITIC SMALL LETTER SHTA"
\u2C4C "GLAGOLITIC SMALL LETTER TSI"
\u2C4D "GLAGOLITIC SMALL LETTER CHRIVI"
\u2C4E "GLAGOLITIC SMALL LETTER SHA"
\u2C4F "GLAGOLITIC SMALL LETTER YERU"
\u2C50 "GLAGOLITIC SMALL LETTER YERI"
\u2C51 "GLAGOLITIC SMALL LETTER YATI"
\u2C52 "GLAGOLITIC SMALL LETTER SPIDERY HA"
\u2C53 "GLAGOLITIC SMALL LETTER YU"
\u2C54 "GLAGOLITIC SMALL LETTER SMALL YUS"
\u2C55 "GLAGOLITIC SMALL LETTER SMALL YUS WITH TAIL"
\u2C56 "GLAGOLITIC SMALL LETTER YO"
\u2C57 "GLAGOLITIC SMALL LETTER IOTATED SMALL YUS"
\u2C58 "GLAGOLITIC SMALL LETTER BIG YUS"
\u2C59 "GLAGOLITIC SMALL LETTER IOTATED BIG YUS"
\u2C5A "GLAGOLITIC SMALL LETTER FITA"
\u2C5B "GLAGOLITIC SMALL LETTER IZHITSA"
\u2C5C "GLAGOLITIC SMALL LETTER SHTAPIC"
\u2C5D "GLAGOLITIC SMALL LETTER TROKUTASTI A"
\u2C5E "GLAGOLITIC SMALL LETTER LATINATE MYSLITE"
\u2C60 "LATIN CAPITAL LETTER L WITH DOUBLE BAR"
\u2C61 "LATIN SMALL LETTER L WITH DOUBLE BAR"
\u2C62 "LATIN CAPITAL LETTER L WITH MIDDLE TILDE"
\u2C63 "LATIN CAPITAL LETTER P WITH STROKE"
\u2C64 "LATIN CAPITAL LETTER R WITH TAIL"
\u2C65 "LATIN SMALL LETTER A WITH STROKE"
\u2C66 "LATIN SMALL LETTER T WITH DIAGONAL STROKE"
\u2C67 "LATIN CAPITAL LETTER H WITH DESCENDER"
\u2C68 "LATIN SMALL LETTER H WITH DESCENDER"
\u2C69 "LATIN CAPITAL LETTER K WITH DESCENDER"
\u2C6A "LATIN SMALL LETTER K WITH DESCENDER"
\u2C6B "LATIN CAPITAL LETTER Z WITH DESCENDER"
\u2C6C "LATIN SMALL LETTER Z WITH DESCENDER"
\u2C6D "LATIN CAPITAL LETTER ALPHA"
\u2C6E "LATIN CAPITAL LETTER M WITH HOOK"
\u2C6F "LATIN CAPITAL LETTER TURNED A"
\u2C71 "LATIN SMALL LETTER V WITH RIGHT HOOK"
\u2C72 "LATIN CAPITAL LETTER W WITH HOOK"
\u2C73 "LATIN SMALL LETTER W WITH HOOK"
\u2C74 "LATIN SMALL LETTER V WITH CURL"
\u2C75 "LATIN CAPITAL LETTER HALF H"
\u2C76 "LATIN SMALL LETTER HALF H"
\u2C77 "LATIN SMALL LETTER TAILLESS PHI"
\u2C78 "LATIN SMALL LETTER E WITH NOTCH"
\u2C79 "LATIN SMALL LETTER TURNED R WITH TAIL"
\u2C7A "LATIN SMALL LETTER O WITH LOW RING INSIDE"
\u2C7B "LATIN LETTER SMALL CAPITAL TURNED E"
\u2C7C "LATIN SUBSCRIPT SMALL LETTER J"
\u2C7D "MODIFIER LETTER CAPITAL V"
\u2C80 "COPTIC CAPITAL LETTER ALFA"
\u2C81 "COPTIC SMALL LETTER ALFA"
\u2C82 "COPTIC CAPITAL LETTER VIDA"
\u2C83 "COPTIC SMALL LETTER VIDA"
\u2C84 "COPTIC CAPITAL LETTER GAMMA"
\u2C85 "COPTIC SMALL LETTER GAMMA"
\u2C86 "COPTIC CAPITAL LETTER DALDA"
\u2C87 "COPTIC SMALL LETTER DALDA"
\u2C88 "COPTIC CAPITAL LETTER EIE"
\u2C89 "COPTIC SMALL LETTER EIE"
\u2C8A "COPTIC CAPITAL LETTER SOU"
\u2C8B "COPTIC SMALL LETTER SOU"
\u2C8C "COPTIC CAPITAL LETTER ZATA"
\u2C8D "COPTIC SMALL LETTER ZATA"
\u2C8E "COPTIC CAPITAL LETTER HATE"
\u2C8F "COPTIC SMALL LETTER HATE"
\u2C90 "COPTIC CAPITAL LETTER THETHE"
\u2C91 "COPTIC SMALL LETTER THETHE"
\u2C92 "COPTIC CAPITAL LETTER IAUDA"
\u2C93 "COPTIC SMALL LETTER IAUDA"
\u2C94 "COPTIC CAPITAL LETTER KAPA"
\u2C95 "COPTIC SMALL LETTER KAPA"
\u2C96 "COPTIC CAPITAL LETTER LAULA"
\u2C97 "COPTIC SMALL LETTER LAULA"
\u2C98 "COPTIC CAPITAL LETTER MI"
\u2C99 "COPTIC SMALL LETTER MI"
\u2C9A "COPTIC CAPITAL LETTER NI"
\u2C9B "COPTIC SMALL LETTER NI"
\u2C9C "COPTIC CAPITAL LETTER KSI"
\u2C9D "COPTIC SMALL LETTER KSI"
\u2C9E "COPTIC CAPITAL LETTER O"
\u2C9F "COPTIC SMALL LETTER O"
\u2CA0 "COPTIC CAPITAL LETTER PI"
\u2CA1 "COPTIC SMALL LETTER PI"
\u2CA2 "COPTIC CAPITAL LETTER RO"
\u2CA3 "COPTIC SMALL LETTER RO"
\u2CA4 "COPTIC CAPITAL LETTER SIMA"
\u2CA5 "COPTIC SMALL LETTER SIMA"
\u2CA6 "COPTIC CAPITAL LETTER TAU"
\u2CA7 "COPTIC SMALL LETTER TAU"
\u2CA8 "COPTIC CAPITAL LETTER UA"
\u2CA9 "COPTIC SMALL LETTER UA"
\u2CAA "COPTIC CAPITAL LETTER FI"
\u2CAB "COPTIC SMALL LETTER FI"
\u2CAC "COPTIC CAPITAL LETTER KHI"
\u2CAD "COPTIC SMALL LETTER KHI"
\u2CAE "COPTIC CAPITAL LETTER PSI"
\u2CAF "COPTIC SMALL LETTER PSI"
\u2CB0 "COPTIC CAPITAL LETTER OOU"
\u2CB1 "COPTIC SMALL LETTER OOU"
\u2CB2 "COPTIC CAPITAL LETTER DIALECT-P ALEF"
\u2CB3 "COPTIC SMALL LETTER DIALECT-P ALEF"
\u2CB4 "COPTIC CAPITAL LETTER OLD COPTIC AIN"
\u2CB5 "COPTIC SMALL LETTER OLD COPTIC AIN"
\u2CB6 "COPTIC CAPITAL LETTER CRYPTOGRAMMIC EIE"
\u2CB7 "COPTIC SMALL LETTER CRYPTOGRAMMIC EIE"
\u2CB8 "COPTIC CAPITAL LETTER DIALECT-P KAPA"
\u2CB9 "COPTIC SMALL LETTER DIALECT-P KAPA"
\u2CBA "COPTIC CAPITAL LETTER DIALECT-P NI"
\u2CBB "COPTIC SMALL LETTER DIALECT-P NI"
\u2CBC "COPTIC CAPITAL LETTER CRYPTOGRAMMIC NI"
\u2CBD "COPTIC SMALL LETTER CRYPTOGRAMMIC NI"
\u2CBE "COPTIC CAPITAL LETTER OLD COPTIC OOU"
\u2CBF "COPTIC SMALL LETTER OLD COPTIC OOU"
\u2CC0 "COPTIC CAPITAL LETTER SAMPI"
\u2CC1 "COPTIC SMALL LETTER SAMPI"
\u2CC2 "COPTIC CAPITAL LETTER CROSSED SHEI"
\u2CC3 "COPTIC SMALL LETTER CROSSED SHEI"
\u2CC4 "COPTIC CAPITAL LETTER OLD COPTIC SHEI"
\u2CC5 "COPTIC SMALL LETTER OLD COPTIC SHEI"
\u2CC6 "COPTIC CAPITAL LETTER OLD COPTIC ESH"
\u2CC7 "COPTIC SMALL LETTER OLD COPTIC ESH"
\u2CC8 "COPTIC CAPITAL LETTER AKHMIMIC KHEI"
\u2CC9 "COPTIC SMALL LETTER AKHMIMIC KHEI"
\u2CCA "COPTIC CAPITAL LETTER DIALECT-P HORI"
\u2CCB "COPTIC SMALL LETTER DIALECT-P HORI"
\u2CCC "COPTIC CAPITAL LETTER OLD COPTIC HORI"
\u2CCD "COPTIC SMALL LETTER OLD COPTIC HORI"
\u2CCE "COPTIC CAPITAL LETTER OLD COPTIC HA"
\u2CCF "COPTIC SMALL LETTER OLD COPTIC HA"
\u2CD0 "COPTIC CAPITAL LETTER L-SHAPED HA"
\u2CD1 "COPTIC SMALL LETTER L-SHAPED HA"
\u2CD2 "COPTIC CAPITAL LETTER OLD COPTIC HEI"
\u2CD3 "COPTIC SMALL LETTER OLD COPTIC HEI"
\u2CD4 "COPTIC CAPITAL LETTER OLD COPTIC HAT"
\u2CD5 "COPTIC SMALL LETTER OLD COPTIC HAT"
\u2CD6 "COPTIC CAPITAL LETTER OLD COPTIC GANGIA"
\u2CD7 "COPTIC SMALL LETTER OLD COPTIC GANGIA"
\u2CD8 "COPTIC CAPITAL LETTER OLD COPTIC DJA"
\u2CD9 "COPTIC SMALL LETTER OLD COPTIC DJA"
\u2CDA "COPTIC CAPITAL LETTER OLD COPTIC SHIMA"
\u2CDB "COPTIC SMALL LETTER OLD COPTIC SHIMA"
\u2CDC "COPTIC CAPITAL LETTER OLD NUBIAN SHIMA"
\u2CDD "COPTIC SMALL LETTER OLD NUBIAN SHIMA"
\u2CDE "COPTIC CAPITAL LETTER OLD NUBIAN NGI"
\u2CDF "COPTIC SMALL LETTER OLD NUBIAN NGI"
\u2CE0 "COPTIC CAPITAL LETTER OLD NUBIAN NYI"
\u2CE1 "COPTIC SMALL LETTER OLD NUBIAN NYI"
\u2CE2 "COPTIC CAPITAL LETTER OLD NUBIAN WAU"
\u2CE3 "COPTIC SMALL LETTER OLD NUBIAN WAU"
\u2CE4 "COPTIC SYMBOL KAI"
\u2CE5 "COPTIC SYMBOL MI RO"
\u2CE6 "COPTIC SYMBOL PI RO"
\u2CE7 "COPTIC SYMBOL STAUROS"
\u2CE8 "COPTIC SYMBOL TAU RO"
\u2CE9 "COPTIC SYMBOL KHI RO"
\u2CEA "COPTIC SYMBOL SHIMA SIMA"
\u2CF9 "COPTIC OLD NUBIAN FULL STOP"
\u2CFA "COPTIC OLD NUBIAN DIRECT QUESTION MARK"
\u2CFB "COPTIC OLD NUBIAN INDIRECT QUESTION MARK"
\u2CFC "COPTIC OLD NUBIAN VERSE DIVIDER"
\u2CFD "COPTIC FRACTION ONE HALF"
\u2CFE "COPTIC FULL STOP"
\u2CFF "COPTIC MORPHOLOGICAL DIVIDER"
\u2D00 "GEORGIAN SMALL LETTER AN"
\u2D01 "GEORGIAN SMALL LETTER BAN"
\u2D02 "GEORGIAN SMALL LETTER GAN"
\u2D03 "GEORGIAN SMALL LETTER DON"
\u2D04 "GEORGIAN SMALL LETTER EN"
\u2D05 "GEORGIAN SMALL LETTER VIN"
\u2D06 "GEORGIAN SMALL LETTER ZEN"
\u2D07 "GEORGIAN SMALL LETTER TAN"
\u2D08 "GEORGIAN SMALL LETTER IN"
\u2D09 "GEORGIAN SMALL LETTER KAN"
\u2D0A "GEORGIAN SMALL LETTER LAS"
\u2D0B "GEORGIAN SMALL LETTER MAN"
\u2D0C "GEORGIAN SMALL LETTER NAR"
\u2D0D "GEORGIAN SMALL LETTER ON"
\u2D0E "GEORGIAN SMALL LETTER PAR"
\u2D0F "GEORGIAN SMALL LETTER ZHAR"
\u2D10 "GEORGIAN SMALL LETTER RAE"
\u2D11 "GEORGIAN SMALL LETTER SAN"
\u2D12 "GEORGIAN SMALL LETTER TAR"
\u2D13 "GEORGIAN SMALL LETTER UN"
\u2D14 "GEORGIAN SMALL LETTER PHAR"
\u2D15 "GEORGIAN SMALL LETTER KHAR"
\u2D16 "GEORGIAN SMALL LETTER GHAN"
\u2D17 "GEORGIAN SMALL LETTER QAR"
\u2D18 "GEORGIAN SMALL LETTER SHIN"
\u2D19 "GEORGIAN SMALL LETTER CHIN"
\u2D1A "GEORGIAN SMALL LETTER CAN"
\u2D1B "GEORGIAN SMALL LETTER JIL"
\u2D1C "GEORGIAN SMALL LETTER CIL"
\u2D1D "GEORGIAN SMALL LETTER CHAR"
\u2D1E "GEORGIAN SMALL LETTER XAN"
\u2D1F "GEORGIAN SMALL LETTER JHAN"
\u2D20 "GEORGIAN SMALL LETTER HAE"
\u2D21 "GEORGIAN SMALL LETTER HE"
\u2D22 "GEORGIAN SMALL LETTER HIE"
\u2D23 "GEORGIAN SMALL LETTER WE"
\u2D24 "GEORGIAN SMALL LETTER HAR"
\u2D25 "GEORGIAN SMALL LETTER HOE"
\u2D30 "TIFINAGH LETTER YA"
\u2D31 "TIFINAGH LETTER YAB"
\u2D32 "TIFINAGH LETTER YABH"
\u2D33 "TIFINAGH LETTER YAG"
\u2D34 "TIFINAGH LETTER YAGHH"
\u2D35 "TIFINAGH LETTER BERBER ACADEMY YAJ"
\u2D36 "TIFINAGH LETTER YAJ"
\u2D37 "TIFINAGH LETTER YAD"
\u2D38 "TIFINAGH LETTER YADH"
\u2D39 "TIFINAGH LETTER YADD"
\u2D3A "TIFINAGH LETTER YADDH"
\u2D3B "TIFINAGH LETTER YEY"
\u2D3C "TIFINAGH LETTER YAF"
\u2D3D "TIFINAGH LETTER YAK"
\u2D3E "TIFINAGH LETTER TUAREG YAK"
\u2D3F "TIFINAGH LETTER YAKHH"
\u2D40 "TIFINAGH LETTER YAH"
\u2D41 "TIFINAGH LETTER BERBER ACADEMY YAH"
\u2D42 "TIFINAGH LETTER TUAREG YAH"
\u2D43 "TIFINAGH LETTER YAHH"
\u2D44 "TIFINAGH LETTER YAA"
\u2D45 "TIFINAGH LETTER YAKH"
\u2D46 "TIFINAGH LETTER TUAREG YAKH"
\u2D47 "TIFINAGH LETTER YAQ"
\u2D48 "TIFINAGH LETTER TUAREG YAQ"
\u2D49 "TIFINAGH LETTER YI"
\u2D4A "TIFINAGH LETTER YAZH"
\u2D4B "TIFINAGH LETTER AHAGGAR YAZH"
\u2D4C "TIFINAGH LETTER TUAREG YAZH"
\u2D4D "TIFINAGH LETTER YAL"
\u2D4E "TIFINAGH LETTER YAM"
\u2D4F "TIFINAGH LETTER YAN"
\u2D50 "TIFINAGH LETTER TUAREG YAGN"
\u2D51 "TIFINAGH LETTER TUAREG YANG"
\u2D52 "TIFINAGH LETTER YAP"
\u2D53 "TIFINAGH LETTER YU"
\u2D54 "TIFINAGH LETTER YAR"
\u2D55 "TIFINAGH LETTER YARR"
\u2D56 "TIFINAGH LETTER YAGH"
\u2D57 "TIFINAGH LETTER TUAREG YAGH"
\u2D58 "TIFINAGH LETTER AYER YAGH"
\u2D59 "TIFINAGH LETTER YAS"
\u2D5A "TIFINAGH LETTER YASS"
\u2D5B "TIFINAGH LETTER YASH"
\u2D5C "TIFINAGH LETTER YAT"
\u2D5D "TIFINAGH LETTER YATH"
\u2D5E "TIFINAGH LETTER YACH"
\u2D5F "TIFINAGH LETTER YATT"
\u2D60 "TIFINAGH LETTER YAV"
\u2D61 "TIFINAGH LETTER YAW"
\u2D62 "TIFINAGH LETTER YAY"
\u2D63 "TIFINAGH LETTER YAZ"
\u2D64 "TIFINAGH LETTER TAWELLEMET YAZ"
\u2D65 "TIFINAGH LETTER YAZZ"
\u2D6F "TIFINAGH MODIFIER LETTER LABIALIZATION MARK"
\u2D80 "ETHIOPIC SYLLABLE LOA"
\u2D81 "ETHIOPIC SYLLABLE MOA"
\u2D82 "ETHIOPIC SYLLABLE ROA"
\u2D83 "ETHIOPIC SYLLABLE SOA"
\u2D84 "ETHIOPIC SYLLABLE SHOA"
\u2D85 "ETHIOPIC SYLLABLE BOA"
\u2D86 "ETHIOPIC SYLLABLE TOA"
\u2D87 "ETHIOPIC SYLLABLE COA"
\u2D88 "ETHIOPIC SYLLABLE NOA"
\u2D89 "ETHIOPIC SYLLABLE NYOA"
\u2D8A "ETHIOPIC SYLLABLE GLOTTAL OA"
\u2D8B "ETHIOPIC SYLLABLE ZOA"
\u2D8C "ETHIOPIC SYLLABLE DOA"
\u2D8D "ETHIOPIC SYLLABLE DDOA"
\u2D8E "ETHIOPIC SYLLABLE JOA"
\u2D8F "ETHIOPIC SYLLABLE THOA"
\u2D90 "ETHIOPIC SYLLABLE CHOA"
\u2D91 "ETHIOPIC SYLLABLE PHOA"
\u2D92 "ETHIOPIC SYLLABLE POA"
\u2D93 "ETHIOPIC SYLLABLE GGWA"
\u2D94 "ETHIOPIC SYLLABLE GGWI"
\u2D95 "ETHIOPIC SYLLABLE GGWEE"
\u2D96 "ETHIOPIC SYLLABLE GGWE"
\u2DA0 "ETHIOPIC SYLLABLE SSA"
\u2DA1 "ETHIOPIC SYLLABLE SSU"
\u2DA2 "ETHIOPIC SYLLABLE SSI"
\u2DA3 "ETHIOPIC SYLLABLE SSAA"
\u2DA4 "ETHIOPIC SYLLABLE SSEE"
\u2DA5 "ETHIOPIC SYLLABLE SSE"
\u2DA6 "ETHIOPIC SYLLABLE SSO"
\u2DA8 "ETHIOPIC SYLLABLE CCA"
\u2DA9 "ETHIOPIC SYLLABLE CCU"
\u2DAA "ETHIOPIC SYLLABLE CCI"
\u2DAB "ETHIOPIC SYLLABLE CCAA"
\u2DAC "ETHIOPIC SYLLABLE CCEE"
\u2DAD "ETHIOPIC SYLLABLE CCE"
\u2DAE "ETHIOPIC SYLLABLE CCO"
\u2DB0 "ETHIOPIC SYLLABLE ZZA"
\u2DB1 "ETHIOPIC SYLLABLE ZZU"
\u2DB2 "ETHIOPIC SYLLABLE ZZI"
\u2DB3 "ETHIOPIC SYLLABLE ZZAA"
\u2DB4 "ETHIOPIC SYLLABLE ZZEE"
\u2DB5 "ETHIOPIC SYLLABLE ZZE"
\u2DB6 "ETHIOPIC SYLLABLE ZZO"
\u2DB8 "ETHIOPIC SYLLABLE CCHA"
\u2DB9 "ETHIOPIC SYLLABLE CCHU"
\u2DBA "ETHIOPIC SYLLABLE CCHI"
\u2DBB "ETHIOPIC SYLLABLE CCHAA"
\u2DBC "ETHIOPIC SYLLABLE CCHEE"
\u2DBD "ETHIOPIC SYLLABLE CCHE"
\u2DBE "ETHIOPIC SYLLABLE CCHO"
\u2DC0 "ETHIOPIC SYLLABLE QYA"
\u2DC1 "ETHIOPIC SYLLABLE QYU"
\u2DC2 "ETHIOPIC SYLLABLE QYI"
\u2DC3 "ETHIOPIC SYLLABLE QYAA"
\u2DC4 "ETHIOPIC SYLLABLE QYEE"
\u2DC5 "ETHIOPIC SYLLABLE QYE"
\u2DC6 "ETHIOPIC SYLLABLE QYO"
\u2DC8 "ETHIOPIC SYLLABLE KYA"
\u2DC9 "ETHIOPIC SYLLABLE KYU"
\u2DCA "ETHIOPIC SYLLABLE KYI"
\u2DCB "ETHIOPIC SYLLABLE KYAA"
\u2DCC "ETHIOPIC SYLLABLE KYEE"
\u2DCD "ETHIOPIC SYLLABLE KYE"
\u2DCE "ETHIOPIC SYLLABLE KYO"
\u2DD0 "ETHIOPIC SYLLABLE XYA"
\u2DD1 "ETHIOPIC SYLLABLE XYU"
\u2DD2 "ETHIOPIC SYLLABLE XYI"
\u2DD3 "ETHIOPIC SYLLABLE XYAA"
\u2DD4 "ETHIOPIC SYLLABLE XYEE"
\u2DD5 "ETHIOPIC SYLLABLE XYE"
\u2DD6 "ETHIOPIC SYLLABLE XYO"
\u2DD8 "ETHIOPIC SYLLABLE GYA"
\u2DD9 "ETHIOPIC SYLLABLE GYU"
\u2DDA "ETHIOPIC SYLLABLE GYI"
\u2DDB "ETHIOPIC SYLLABLE GYAA"
\u2DDC "ETHIOPIC SYLLABLE GYEE"
\u2DDD "ETHIOPIC SYLLABLE GYE"
\u2DDE "ETHIOPIC SYLLABLE GYO"
\u2DE0 "COMBINING CYRILLIC LETTER BE"
\u2DE1 "COMBINING CYRILLIC LETTER VE"
\u2DE2 "COMBINING CYRILLIC LETTER GHE"
\u2DE3 "COMBINING CYRILLIC LETTER DE"
\u2DE4 "COMBINING CYRILLIC LETTER ZHE"
\u2DE5 "COMBINING CYRILLIC LETTER ZE"
\u2DE6 "COMBINING CYRILLIC LETTER KA"
\u2DE7 "COMBINING CYRILLIC LETTER EL"
\u2DE8 "COMBINING CYRILLIC LETTER EM"
\u2DE9 "COMBINING CYRILLIC LETTER EN"
\u2DEA "COMBINING CYRILLIC LETTER O"
\u2DEB "COMBINING CYRILLIC LETTER PE"
\u2DEC "COMBINING CYRILLIC LETTER ER"
\u2DED "COMBINING CYRILLIC LETTER ES"
\u2DEE "COMBINING CYRILLIC LETTER TE"
\u2DEF "COMBINING CYRILLIC LETTER HA"
\u2DF0 "COMBINING CYRILLIC LETTER TSE"
\u2DF1 "COMBINING CYRILLIC LETTER CHE"
\u2DF2 "COMBINING CYRILLIC LETTER SHA"
\u2DF3 "COMBINING CYRILLIC LETTER SHCHA"
\u2DF4 "COMBINING CYRILLIC LETTER FITA"
\u2DF5 "COMBINING CYRILLIC LETTER ES-TE"
\u2DF6 "COMBINING CYRILLIC LETTER A"
\u2DF7 "COMBINING CYRILLIC LETTER IE"
\u2DF8 "COMBINING CYRILLIC LETTER DJERV"
\u2DF9 "COMBINING CYRILLIC LETTER MONOGRAPH UK"
\u2DFA "COMBINING CYRILLIC LETTER YAT"
\u2DFB "COMBINING CYRILLIC LETTER YU"
\u2DFC "COMBINING CYRILLIC LETTER IOTIFIED A"
\u2DFD "COMBINING CYRILLIC LETTER LITTLE YUS"
\u2DFE "COMBINING CYRILLIC LETTER BIG YUS"
\u2DFF "COMBINING CYRILLIC LETTER IOTIFIED BIG YUS"
\u2E00 "RIGHT ANGLE SUBSTITUTION MARKER"
\u2E01 "RIGHT ANGLE DOTTED SUBSTITUTION MARKER"
\u2E02 "LEFT SUBSTITUTION BRACKET"
\u2E03 "RIGHT SUBSTITUTION BRACKET"
\u2E04 "LEFT DOTTED SUBSTITUTION BRACKET"
\u2E05 "RIGHT DOTTED SUBSTITUTION BRACKET"
\u2E06 "RAISED INTERPOLATION MARKER"
\u2E07 "RAISED DOTTED INTERPOLATION MARKER"
\u2E08 "DOTTED TRANSPOSITION MARKER"
\u2E09 "LEFT TRANSPOSITION BRACKET"
\u2E0A "RIGHT TRANSPOSITION BRACKET"
\u2E0B "RAISED SQUARE"
\u2E0C "LEFT RAISED OMISSION BRACKET"
\u2E0D "RIGHT RAISED OMISSION BRACKET"
\u2E0E "EDITORIAL CORONIS"
\u2E0F "PARAGRAPHOS"
\u2E10 "FORKED PARAGRAPHOS"
\u2E11 "REVERSED FORKED PARAGRAPHOS"
\u2E12 "HYPODIASTOLE"
\u2E13 "DOTTED OBELOS"
\u2E14 "DOWNWARDS ANCORA"
\u2E15 "UPWARDS ANCORA"
\u2E16 "DOTTED RIGHT-POINTING ANGLE"
\u2E17 "DOUBLE OBLIQUE HYPHEN"
\u2E18 "INVERTED INTERROBANG"
\u2E19 "PALM BRANCH"
\u2E1A "HYPHEN WITH DIAERESIS"
\u2E1B "TILDE WITH RING ABOVE"
\u2E1C "LEFT LOW PARAPHRASE BRACKET"
\u2E1D "RIGHT LOW PARAPHRASE BRACKET"
\u2E1E "TILDE WITH DOT ABOVE"
\u2E1F "TILDE WITH DOT BELOW"
\u2E20 "LEFT VERTICAL BAR WITH QUILL"
\u2E21 "RIGHT VERTICAL BAR WITH QUILL"
\u2E22 "TOP LEFT HALF BRACKET"
\u2E23 "TOP RIGHT HALF BRACKET"
\u2E24 "BOTTOM LEFT HALF BRACKET"
\u2E25 "BOTTOM RIGHT HALF BRACKET"
\u2E26 "LEFT SIDEWAYS U BRACKET"
\u2E27 "RIGHT SIDEWAYS U BRACKET"
\u2E28 "LEFT DOUBLE PARENTHESIS"
\u2E29 "RIGHT DOUBLE PARENTHESIS"
\u2E2A "TWO DOTS OVER ONE DOT PUNCTUATION"
\u2E2B "ONE DOT OVER TWO DOTS PUNCTUATION"
\u2E2C "SQUARED FOUR DOT PUNCTUATION"
\u2E2D "FIVE DOT MARK"
\u2E2E "REVERSED QUESTION MARK"
\u2E2F "VERTICAL TILDE"
\u2E30 "RING POINT"
\u2E80 "CJK RADICAL REPEAT"
\u2E81 "CJK RADICAL CLIFF"
\u2E82 "CJK RADICAL SECOND ONE"
\u2E83 "CJK RADICAL SECOND TWO"
\u2E84 "CJK RADICAL SECOND THREE"
\u2E85 "CJK RADICAL PERSON"
\u2E86 "CJK RADICAL BOX"
\u2E87 "CJK RADICAL TABLE"
\u2E88 "CJK RADICAL KNIFE ONE"
\u2E89 "CJK RADICAL KNIFE TWO"
\u2E8A "CJK RADICAL DIVINATION"
\u2E8B "CJK RADICAL SEAL"
\u2E8C "CJK RADICAL SMALL ONE"
\u2E8D "CJK RADICAL SMALL TWO"
\u2E8E "CJK RADICAL LAME ONE"
\u2E8F "CJK RADICAL LAME TWO"
\u2E90 "CJK RADICAL LAME THREE"
\u2E91 "CJK RADICAL LAME FOUR"
\u2E92 "CJK RADICAL SNAKE"
\u2E93 "CJK RADICAL THREAD"
\u2E94 "CJK RADICAL SNOUT ONE"
\u2E95 "CJK RADICAL SNOUT TWO"
\u2E96 "CJK RADICAL HEART ONE"
\u2E97 "CJK RADICAL HEART TWO"
\u2E98 "CJK RADICAL HAND"
\u2E99 "CJK RADICAL RAP"
\u2E9B "CJK RADICAL CHOKE"
\u2E9C "CJK RADICAL SUN"
\u2E9D "CJK RADICAL MOON"
\u2E9E "CJK RADICAL DEATH"
\u2E9F "CJK RADICAL MOTHER"
\u2EA0 "CJK RADICAL CIVILIAN"
\u2EA1 "CJK RADICAL WATER ONE"
\u2EA2 "CJK RADICAL WATER TWO"
\u2EA3 "CJK RADICAL FIRE"
\u2EA4 "CJK RADICAL PAW ONE"
\u2EA5 "CJK RADICAL PAW TWO"
\u2EA6 "CJK RADICAL SIMPLIFIED HALF TREE TRUNK"
\u2EA7 "CJK RADICAL COW"
\u2EA8 "CJK RADICAL DOG"
\u2EA9 "CJK RADICAL JADE"
\u2EAA "CJK RADICAL BOLT OF CLOTH"
\u2EAB "CJK RADICAL EYE"
\u2EAC "CJK RADICAL SPIRIT ONE"
\u2EAD "CJK RADICAL SPIRIT TWO"
\u2EAE "CJK RADICAL BAMBOO"
\u2EAF "CJK RADICAL SILK"
\u2EB0 "CJK RADICAL C-SIMPLIFIED SILK"
\u2EB1 "CJK RADICAL NET ONE"
\u2EB2 "CJK RADICAL NET TWO"
\u2EB3 "CJK RADICAL NET THREE"
\u2EB4 "CJK RADICAL NET FOUR"
\u2EB5 "CJK RADICAL MESH"
\u2EB6 "CJK RADICAL SHEEP"
\u2EB7 "CJK RADICAL RAM"
\u2EB8 "CJK RADICAL EWE"
\u2EB9 "CJK RADICAL OLD"
\u2EBA "CJK RADICAL BRUSH ONE"
\u2EBB "CJK RADICAL BRUSH TWO"
\u2EBC "CJK RADICAL MEAT"
\u2EBD "CJK RADICAL MORTAR"
\u2EBE "CJK RADICAL GRASS ONE"
\u2EBF "CJK RADICAL GRASS TWO"
\u2EC0 "CJK RADICAL GRASS THREE"
\u2EC1 "CJK RADICAL TIGER"
\u2EC2 "CJK RADICAL CLOTHES"
\u2EC3 "CJK RADICAL WEST ONE"
\u2EC4 "CJK RADICAL WEST TWO"
\u2EC5 "CJK RADICAL C-SIMPLIFIED SEE"
\u2EC6 "CJK RADICAL SIMPLIFIED HORN"
\u2EC7 "CJK RADICAL HORN"
\u2EC8 "CJK RADICAL C-SIMPLIFIED SPEECH"
\u2EC9 "CJK RADICAL C-SIMPLIFIED SHELL"
\u2ECA "CJK RADICAL FOOT"
\u2ECB "CJK RADICAL C-SIMPLIFIED CART"
\u2ECC "CJK RADICAL SIMPLIFIED WALK"
\u2ECD "CJK RADICAL WALK ONE"
\u2ECE "CJK RADICAL WALK TWO"
\u2ECF "CJK RADICAL CITY"
\u2ED0 "CJK RADICAL C-SIMPLIFIED GOLD"
\u2ED1 "CJK RADICAL LONG ONE"
\u2ED2 "CJK RADICAL LONG TWO"
\u2ED3 "CJK RADICAL C-SIMPLIFIED LONG"
\u2ED4 "CJK RADICAL C-SIMPLIFIED GATE"
\u2ED5 "CJK RADICAL MOUND ONE"
\u2ED6 "CJK RADICAL MOUND TWO"
\u2ED7 "CJK RADICAL RAIN"
\u2ED8 "CJK RADICAL BLUE"
\u2ED9 "CJK RADICAL C-SIMPLIFIED TANNED LEATHER"
\u2EDA "CJK RADICAL C-SIMPLIFIED LEAF"
\u2EDB "CJK RADICAL C-SIMPLIFIED WIND"
\u2EDC "CJK RADICAL C-SIMPLIFIED FLY"
\u2EDD "CJK RADICAL EAT ONE"
\u2EDE "CJK RADICAL EAT TWO"
\u2EDF "CJK RADICAL EAT THREE"
\u2EE0 "CJK RADICAL C-SIMPLIFIED EAT"
\u2EE1 "CJK RADICAL HEAD"
\u2EE2 "CJK RADICAL C-SIMPLIFIED HORSE"
\u2EE3 "CJK RADICAL BONE"
\u2EE4 "CJK RADICAL GHOST"
\u2EE5 "CJK RADICAL C-SIMPLIFIED FISH"
\u2EE6 "CJK RADICAL C-SIMPLIFIED BIRD"
\u2EE7 "CJK RADICAL C-SIMPLIFIED SALT"
\u2EE8 "CJK RADICAL SIMPLIFIED WHEAT"
\u2EE9 "CJK RADICAL SIMPLIFIED YELLOW"
\u2EEA "CJK RADICAL C-SIMPLIFIED FROG"
\u2EEB "CJK RADICAL J-SIMPLIFIED EVEN"
\u2EEC "CJK RADICAL C-SIMPLIFIED EVEN"
\u2EED "CJK RADICAL J-SIMPLIFIED TOOTH"
\u2EEE "CJK RADICAL C-SIMPLIFIED TOOTH"
\u2EEF "CJK RADICAL J-SIMPLIFIED DRAGON"
\u2EF0 "CJK RADICAL C-SIMPLIFIED DRAGON"
\u2EF1 "CJK RADICAL TURTLE"
\u2EF2 "CJK RADICAL J-SIMPLIFIED TURTLE"
\u2EF3 "CJK RADICAL C-SIMPLIFIED TURTLE"
\u2F00 "KANGXI RADICAL ONE"
\u2F01 "KANGXI RADICAL LINE"
\u2F02 "KANGXI RADICAL DOT"
\u2F03 "KANGXI RADICAL SLASH"
\u2F04 "KANGXI RADICAL SECOND"
\u2F05 "KANGXI RADICAL HOOK"
\u2F06 "KANGXI RADICAL TWO"
\u2F07 "KANGXI RADICAL LID"
\u2F08 "KANGXI RADICAL MAN"
\u2F09 "KANGXI RADICAL LEGS"
\u2F0A "KANGXI RADICAL ENTER"
\u2F0B "KANGXI RADICAL EIGHT"
\u2F0C "KANGXI RADICAL DOWN BOX"
\u2F0D "KANGXI RADICAL COVER"
\u2F0E "KANGXI RADICAL ICE"
\u2F0F "KANGXI RADICAL TABLE"
\u2F10 "KANGXI RADICAL OPEN BOX"
\u2F11 "KANGXI RADICAL KNIFE"
\u2F12 "KANGXI RADICAL POWER"
\u2F13 "KANGXI RADICAL WRAP"
\u2F14 "KANGXI RADICAL SPOON"
\u2F15 "KANGXI RADICAL RIGHT OPEN BOX"
\u2F16 "KANGXI RADICAL HIDING ENCLOSURE"
\u2F17 "KANGXI RADICAL TEN"
\u2F18 "KANGXI RADICAL DIVINATION"
\u2F19 "KANGXI RADICAL SEAL"
\u2F1A "KANGXI RADICAL CLIFF"
\u2F1B "KANGXI RADICAL PRIVATE"
\u2F1C "KANGXI RADICAL AGAIN"
\u2F1D "KANGXI RADICAL MOUTH"
\u2F1E "KANGXI RADICAL ENCLOSURE"
\u2F1F "KANGXI RADICAL EARTH"
\u2F20 "KANGXI RADICAL SCHOLAR"
\u2F21 "KANGXI RADICAL GO"
\u2F22 "KANGXI RADICAL GO SLOWLY"
\u2F23 "KANGXI RADICAL EVENING"
\u2F24 "KANGXI RADICAL BIG"
\u2F25 "KANGXI RADICAL WOMAN"
\u2F26 "KANGXI RADICAL CHILD"
\u2F27 "KANGXI RADICAL ROOF"
\u2F28 "KANGXI RADICAL INCH"
\u2F29 "KANGXI RADICAL SMALL"
\u2F2A "KANGXI RADICAL LAME"
\u2F2B "KANGXI RADICAL CORPSE"
\u2F2C "KANGXI RADICAL SPROUT"
\u2F2D "KANGXI RADICAL MOUNTAIN"
\u2F2E "KANGXI RADICAL RIVER"
\u2F2F "KANGXI RADICAL WORK"
\u2F30 "KANGXI RADICAL ONESELF"
\u2F31 "KANGXI RADICAL TURBAN"
\u2F32 "KANGXI RADICAL DRY"
\u2F33 "KANGXI RADICAL SHORT THREAD"
\u2F34 "KANGXI RADICAL DOTTED CLIFF"
\u2F35 "KANGXI RADICAL LONG STRIDE"
\u2F36 "KANGXI RADICAL TWO HANDS"
\u2F37 "KANGXI RADICAL SHOOT"
\u2F38 "KANGXI RADICAL BOW"
\u2F39 "KANGXI RADICAL SNOUT"
\u2F3A "KANGXI RADICAL BRISTLE"
\u2F3B "KANGXI RADICAL STEP"
\u2F3C "KANGXI RADICAL HEART"
\u2F3D "KANGXI RADICAL HALBERD"
\u2F3E "KANGXI RADICAL DOOR"
\u2F3F "KANGXI RADICAL HAND"
\u2F40 "KANGXI RADICAL BRANCH"
\u2F41 "KANGXI RADICAL RAP"
\u2F42 "KANGXI RADICAL SCRIPT"
\u2F43 "KANGXI RADICAL DIPPER"
\u2F44 "KANGXI RADICAL AXE"
\u2F45 "KANGXI RADICAL SQUARE"
\u2F46 "KANGXI RADICAL NOT"
\u2F47 "KANGXI RADICAL SUN"
\u2F48 "KANGXI RADICAL SAY"
\u2F49 "KANGXI RADICAL MOON"
\u2F4A "KANGXI RADICAL TREE"
\u2F4B "KANGXI RADICAL LACK"
\u2F4C "KANGXI RADICAL STOP"
\u2F4D "KANGXI RADICAL DEATH"
\u2F4E "KANGXI RADICAL WEAPON"
\u2F4F "KANGXI RADICAL DO NOT"
\u2F50 "KANGXI RADICAL COMPARE"
\u2F51 "KANGXI RADICAL FUR"
\u2F52 "KANGXI RADICAL CLAN"
\u2F53 "KANGXI RADICAL STEAM"
\u2F54 "KANGXI RADICAL WATER"
\u2F55 "KANGXI RADICAL FIRE"
\u2F56 "KANGXI RADICAL CLAW"
\u2F57 "KANGXI RADICAL FATHER"
\u2F58 "KANGXI RADICAL DOUBLE X"
\u2F59 "KANGXI RADICAL HALF TREE TRUNK"
\u2F5A "KANGXI RADICAL SLICE"
\u2F5B "KANGXI RADICAL FANG"
\u2F5C "KANGXI RADICAL COW"
\u2F5D "KANGXI RADICAL DOG"
\u2F5E "KANGXI RADICAL PROFOUND"
\u2F5F "KANGXI RADICAL JADE"
\u2F60 "KANGXI RADICAL MELON"
\u2F61 "KANGXI RADICAL TILE"
\u2F62 "KANGXI RADICAL SWEET"
\u2F63 "KANGXI RADICAL LIFE"
\u2F64 "KANGXI RADICAL USE"
\u2F65 "KANGXI RADICAL FIELD"
\u2F66 "KANGXI RADICAL BOLT OF CLOTH"
\u2F67 "KANGXI RADICAL SICKNESS"
\u2F68 "KANGXI RADICAL DOTTED TENT"
\u2F69 "KANGXI RADICAL WHITE"
\u2F6A "KANGXI RADICAL SKIN"
\u2F6B "KANGXI RADICAL DISH"
\u2F6C "KANGXI RADICAL EYE"
\u2F6D "KANGXI RADICAL SPEAR"
\u2F6E "KANGXI RADICAL ARROW"
\u2F6F "KANGXI RADICAL STONE"
\u2F70 "KANGXI RADICAL SPIRIT"
\u2F71 "KANGXI RADICAL TRACK"
\u2F72 "KANGXI RADICAL GRAIN"
\u2F73 "KANGXI RADICAL CAVE"
\u2F74 "KANGXI RADICAL STAND"
\u2F75 "KANGXI RADICAL BAMBOO"
\u2F76 "KANGXI RADICAL RICE"
\u2F77 "KANGXI RADICAL SILK"
\u2F78 "KANGXI RADICAL JAR"
\u2F79 "KANGXI RADICAL NET"
\u2F7A "KANGXI RADICAL SHEEP"
\u2F7B "KANGXI RADICAL FEATHER"
\u2F7C "KANGXI RADICAL OLD"
\u2F7D "KANGXI RADICAL AND"
\u2F7E "KANGXI RADICAL PLOW"
\u2F7F "KANGXI RADICAL EAR"
\u2F80 "KANGXI RADICAL BRUSH"
\u2F81 "KANGXI RADICAL MEAT"
\u2F82 "KANGXI RADICAL MINISTER"
\u2F83 "KANGXI RADICAL SELF"
\u2F84 "KANGXI RADICAL ARRIVE"
\u2F85 "KANGXI RADICAL MORTAR"
\u2F86 "KANGXI RADICAL TONGUE"
\u2F87 "KANGXI RADICAL OPPOSE"
\u2F88 "KANGXI RADICAL BOAT"
\u2F89 "KANGXI RADICAL STOPPING"
\u2F8A "KANGXI RADICAL COLOR"
\u2F8B "KANGXI RADICAL GRASS"
\u2F8C "KANGXI RADICAL TIGER"
\u2F8D "KANGXI RADICAL INSECT"
\u2F8E "KANGXI RADICAL BLOOD"
\u2F8F "KANGXI RADICAL WALK ENCLOSURE"
\u2F90 "KANGXI RADICAL CLOTHES"
\u2F91 "KANGXI RADICAL WEST"
\u2F92 "KANGXI RADICAL SEE"
\u2F93 "KANGXI RADICAL HORN"
\u2F94 "KANGXI RADICAL SPEECH"
\u2F95 "KANGXI RADICAL VALLEY"
\u2F96 "KANGXI RADICAL BEAN"
\u2F97 "KANGXI RADICAL PIG"
\u2F98 "KANGXI RADICAL BADGER"
\u2F99 "KANGXI RADICAL SHELL"
\u2F9A "KANGXI RADICAL RED"
\u2F9B "KANGXI RADICAL RUN"
\u2F9C "KANGXI RADICAL FOOT"
\u2F9D "KANGXI RADICAL BODY"
\u2F9E "KANGXI RADICAL CART"
\u2F9F "KANGXI RADICAL BITTER"
\u2FA0 "KANGXI RADICAL MORNING"
\u2FA1 "KANGXI RADICAL WALK"
\u2FA2 "KANGXI RADICAL CITY"
\u2FA3 "KANGXI RADICAL WINE"
\u2FA4 "KANGXI RADICAL DISTINGUISH"
\u2FA5 "KANGXI RADICAL VILLAGE"
\u2FA6 "KANGXI RADICAL GOLD"
\u2FA7 "KANGXI RADICAL LONG"
\u2FA8 "KANGXI RADICAL GATE"
\u2FA9 "KANGXI RADICAL MOUND"
\u2FAA "KANGXI RADICAL SLAVE"
\u2FAB "KANGXI RADICAL SHORT TAILED BIRD"
\u2FAC "KANGXI RADICAL RAIN"
\u2FAD "KANGXI RADICAL BLUE"
\u2FAE "KANGXI RADICAL WRONG"
\u2FAF "KANGXI RADICAL FACE"
\u2FB0 "KANGXI RADICAL LEATHER"
\u2FB1 "KANGXI RADICAL TANNED LEATHER"
\u2FB2 "KANGXI RADICAL LEEK"
\u2FB3 "KANGXI RADICAL SOUND"
\u2FB4 "KANGXI RADICAL LEAF"
\u2FB5 "KANGXI RADICAL WIND"
\u2FB6 "KANGXI RADICAL FLY"
\u2FB7 "KANGXI RADICAL EAT"
\u2FB8 "KANGXI RADICAL HEAD"
\u2FB9 "KANGXI RADICAL FRAGRANT"
\u2FBA "KANGXI RADICAL HORSE"
\u2FBB "KANGXI RADICAL BONE"
\u2FBC "KANGXI RADICAL TALL"
\u2FBD "KANGXI RADICAL HAIR"
\u2FBE "KANGXI RADICAL FIGHT"
\u2FBF "KANGXI RADICAL SACRIFICIAL WINE"
\u2FC0 "KANGXI RADICAL CAULDRON"
\u2FC1 "KANGXI RADICAL GHOST"
\u2FC2 "KANGXI RADICAL FISH"
\u2FC3 "KANGXI RADICAL BIRD"
\u2FC4 "KANGXI RADICAL SALT"
\u2FC5 "KANGXI RADICAL DEER"
\u2FC6 "KANGXI RADICAL WHEAT"
\u2FC7 "KANGXI RADICAL HEMP"
\u2FC8 "KANGXI RADICAL YELLOW"
\u2FC9 "KANGXI RADICAL MILLET"
\u2FCA "KANGXI RADICAL BLACK"
\u2FCB "KANGXI RADICAL EMBROIDERY"
\u2FCC "KANGXI RADICAL FROG"
\u2FCD "KANGXI RADICAL TRIPOD"
\u2FCE "KANGXI RADICAL DRUM"
\u2FCF "KANGXI RADICAL RAT"
\u2FD0 "KANGXI RADICAL NOSE"
\u2FD1 "KANGXI RADICAL EVEN"
\u2FD2 "KANGXI RADICAL TOOTH"
\u2FD3 "KANGXI RADICAL DRAGON"
\u2FD4 "KANGXI RADICAL TURTLE"
\u2FD5 "KANGXI RADICAL FLUTE"
\u2FF0 "IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT"
\u2FF1 "IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO BELOW"
\u2FF2 "IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO MIDDLE AND RIGHT"
\u2FF3 "IDEOGRAPHIC DESCRIPTION CHARACTER ABOVE TO MIDDLE AND BELOW"
\u2FF4 "IDEOGRAPHIC DESCRIPTION CHARACTER FULL SURROUND"
\u2FF5 "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM ABOVE"
\u2FF6 "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM BELOW"
\u2FF7 "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LEFT"
\u2FF8 "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM UPPER LEFT"
\u2FF9 "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM UPPER RIGHT"
\u2FFA "IDEOGRAPHIC DESCRIPTION CHARACTER SURROUND FROM LOWER LEFT"
\u2FFB "IDEOGRAPHIC DESCRIPTION CHARACTER OVERLAID"
\u3000 "IDEOGRAPHIC SPACE"
\u3001 "IDEOGRAPHIC COMMA"
\u3002 "IDEOGRAPHIC FULL STOP"
\u3003 "DITTO MARK"
\u3004 "JAPANESE INDUSTRIAL STANDARD SYMBOL"
\u3005 "IDEOGRAPHIC ITERATION MARK"
\u3006 "IDEOGRAPHIC CLOSING MARK"
\u3007 "IDEOGRAPHIC NUMBER ZERO"
\u3008 "LEFT ANGLE BRACKET"
\u3009 "RIGHT ANGLE BRACKET"
\u300A "LEFT DOUBLE ANGLE BRACKET"
\u300B "RIGHT DOUBLE ANGLE BRACKET"
\u300C "LEFT CORNER BRACKET"
\u300D "RIGHT CORNER BRACKET"
\u300E "LEFT WHITE CORNER BRACKET"
\u300F "RIGHT WHITE CORNER BRACKET"
\u3010 "LEFT BLACK LENTICULAR BRACKET"
\u3011 "RIGHT BLACK LENTICULAR BRACKET"
\u3012 "POSTAL MARK"
\u3013 "GETA MARK"
\u3014 "LEFT TORTOISE SHELL BRACKET"
\u3015 "RIGHT TORTOISE SHELL BRACKET"
\u3016 "LEFT WHITE LENTICULAR BRACKET"
\u3017 "RIGHT WHITE LENTICULAR BRACKET"
\u3018 "LEFT WHITE TORTOISE SHELL BRACKET"
\u3019 "RIGHT WHITE TORTOISE SHELL BRACKET"
\u301A "LEFT WHITE SQUARE BRACKET"
\u301B "RIGHT WHITE SQUARE BRACKET"
\u301C "WAVE DASH"
\u301D "REVERSED DOUBLE PRIME QUOTATION MARK"
\u301E "DOUBLE PRIME QUOTATION MARK"
\u301F "LOW DOUBLE PRIME QUOTATION MARK"
\u3020 "POSTAL MARK FACE"
\u3021 "HANGZHOU NUMERAL ONE"
\u3022 "HANGZHOU NUMERAL TWO"
\u3023 "HANGZHOU NUMERAL THREE"
\u3024 "HANGZHOU NUMERAL FOUR"
\u3025 "HANGZHOU NUMERAL FIVE"
\u3026 "HANGZHOU NUMERAL SIX"
\u3027 "HANGZHOU NUMERAL SEVEN"
\u3028 "HANGZHOU NUMERAL EIGHT"
\u3029 "HANGZHOU NUMERAL NINE"
\u302A "IDEOGRAPHIC LEVEL TONE MARK"
\u302B "IDEOGRAPHIC RISING TONE MARK"
\u302C "IDEOGRAPHIC DEPARTING TONE MARK"
\u302D "IDEOGRAPHIC ENTERING TONE MARK"
\u302E "HANGUL SINGLE DOT TONE MARK"
\u302F "HANGUL DOUBLE DOT TONE MARK"
\u3030 "WAVY DASH"
\u3031 "VERTICAL KANA REPEAT MARK"
\u3032 "VERTICAL KANA REPEAT WITH VOICED SOUND MARK"
\u3033 "VERTICAL KANA REPEAT MARK UPPER HALF"
\u3034 "VERTICAL KANA REPEAT WITH VOICED SOUND MARK UPPER HALF"
\u3035 "VERTICAL KANA REPEAT MARK LOWER HALF"
\u3036 "CIRCLED POSTAL MARK"
\u3037 "IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL"
\u3038 "HANGZHOU NUMERAL TEN"
\u3039 "HANGZHOU NUMERAL TWENTY"
\u303A "HANGZHOU NUMERAL THIRTY"
\u303B "VERTICAL IDEOGRAPHIC ITERATION MARK"
\u303C "MASU MARK"
\u303D "PART ALTERNATION MARK"
\u303E "IDEOGRAPHIC VARIATION INDICATOR"
\u303F "IDEOGRAPHIC HALF FILL SPACE"
\u3041 "HIRAGANA LETTER SMALL A"
\u3042 "HIRAGANA LETTER A"
\u3043 "HIRAGANA LETTER SMALL I"
\u3044 "HIRAGANA LETTER I"
\u3045 "HIRAGANA LETTER SMALL U"
\u3046 "HIRAGANA LETTER U"
\u3047 "HIRAGANA LETTER SMALL E"
\u3048 "HIRAGANA LETTER E"
\u3049 "HIRAGANA LETTER SMALL O"
\u304A "HIRAGANA LETTER O"
\u304B "HIRAGANA LETTER KA"
\u304C "HIRAGANA LETTER GA"
\u304D "HIRAGANA LETTER KI"
\u304E "HIRAGANA LETTER GI"
\u304F "HIRAGANA LETTER KU"
\u3050 "HIRAGANA LETTER GU"
\u3051 "HIRAGANA LETTER KE"
\u3052 "HIRAGANA LETTER GE"
\u3053 "HIRAGANA LETTER KO"
\u3054 "HIRAGANA LETTER GO"
\u3055 "HIRAGANA LETTER SA"
\u3056 "HIRAGANA LETTER ZA"
\u3057 "HIRAGANA LETTER SI"
\u3058 "HIRAGANA LETTER ZI"
\u3059 "HIRAGANA LETTER SU"
\u305A "HIRAGANA LETTER ZU"
\u305B "HIRAGANA LETTER SE"
\u305C "HIRAGANA LETTER ZE"
\u305D "HIRAGANA LETTER SO"
\u305E "HIRAGANA LETTER ZO"
\u305F "HIRAGANA LETTER TA"
\u3060 "HIRAGANA LETTER DA"
\u3061 "HIRAGANA LETTER TI"
\u3062 "HIRAGANA LETTER DI"
\u3063 "HIRAGANA LETTER SMALL TU"
\u3064 "HIRAGANA LETTER TU"
\u3065 "HIRAGANA LETTER DU"
\u3066 "HIRAGANA LETTER TE"
\u3067 "HIRAGANA LETTER DE"
\u3068 "HIRAGANA LETTER TO"
\u3069 "HIRAGANA LETTER DO"
\u306A "HIRAGANA LETTER NA"
\u306B "HIRAGANA LETTER NI"
\u306C "HIRAGANA LETTER NU"
\u306D "HIRAGANA LETTER NE"
\u306E "HIRAGANA LETTER NO"
\u306F "HIRAGANA LETTER HA"
\u3070 "HIRAGANA LETTER BA"
\u3071 "HIRAGANA LETTER PA"
\u3072 "HIRAGANA LETTER HI"
\u3073 "HIRAGANA LETTER BI"
\u3074 "HIRAGANA LETTER PI"
\u3075 "HIRAGANA LETTER HU"
\u3076 "HIRAGANA LETTER BU"
\u3077 "HIRAGANA LETTER PU"
\u3078 "HIRAGANA LETTER HE"
\u3079 "HIRAGANA LETTER BE"
\u307A "HIRAGANA LETTER PE"
\u307B "HIRAGANA LETTER HO"
\u307C "HIRAGANA LETTER BO"
\u307D "HIRAGANA LETTER PO"
\u307E "HIRAGANA LETTER MA"
\u307F "HIRAGANA LETTER MI"
\u3080 "HIRAGANA LETTER MU"
\u3081 "HIRAGANA LETTER ME"
\u3082 "HIRAGANA LETTER MO"
\u3083 "HIRAGANA LETTER SMALL YA"
\u3084 "HIRAGANA LETTER YA"
\u3085 "HIRAGANA LETTER SMALL YU"
\u3086 "HIRAGANA LETTER YU"
\u3087 "HIRAGANA LETTER SMALL YO"
\u3088 "HIRAGANA LETTER YO"
\u3089 "HIRAGANA LETTER RA"
\u308A "HIRAGANA LETTER RI"
\u308B "HIRAGANA LETTER RU"
\u308C "HIRAGANA LETTER RE"
\u308D "HIRAGANA LETTER RO"
\u308E "HIRAGANA LETTER SMALL WA"
\u308F "HIRAGANA LETTER WA"
\u3090 "HIRAGANA LETTER WI"
\u3091 "HIRAGANA LETTER WE"
\u3092 "HIRAGANA LETTER WO"
\u3093 "HIRAGANA LETTER N"
\u3094 "HIRAGANA LETTER VU"
\u3095 "HIRAGANA LETTER SMALL KA"
\u3096 "HIRAGANA LETTER SMALL KE"
\u3099 "COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK"
\u309A "COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK"
\u309B "KATAKANA-HIRAGANA VOICED SOUND MARK"
\u309C "KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK"
\u309D "HIRAGANA ITERATION MARK"
\u309E "HIRAGANA VOICED ITERATION MARK"
\u309F "HIRAGANA DIGRAPH YORI"
\u30A0 "KATAKANA-HIRAGANA DOUBLE HYPHEN"
\u30A1 "KATAKANA LETTER SMALL A"
\u30A2 "KATAKANA LETTER A"
\u30A3 "KATAKANA LETTER SMALL I"
\u30A4 "KATAKANA LETTER I"
\u30A5 "KATAKANA LETTER SMALL U"
\u30A6 "KATAKANA LETTER U"
\u30A7 "KATAKANA LETTER SMALL E"
\u30A8 "KATAKANA LETTER E"
\u30A9 "KATAKANA LETTER SMALL O"
\u30AA "KATAKANA LETTER O"
\u30AB "KATAKANA LETTER KA"
\u30AC "KATAKANA LETTER GA"
\u30AD "KATAKANA LETTER KI"
\u30AE "KATAKANA LETTER GI"
\u30AF "KATAKANA LETTER KU"
\u30B0 "KATAKANA LETTER GU"
\u30B1 "KATAKANA LETTER KE"
\u30B2 "KATAKANA LETTER GE"
\u30B3 "KATAKANA LETTER KO"
\u30B4 "KATAKANA LETTER GO"
\u30B5 "KATAKANA LETTER SA"
\u30B6 "KATAKANA LETTER ZA"
\u30B7 "KATAKANA LETTER SI"
\u30B8 "KATAKANA LETTER ZI"
\u30B9 "KATAKANA LETTER SU"
\u30BA "KATAKANA LETTER ZU"
\u30BB "KATAKANA LETTER SE"
\u30BC "KATAKANA LETTER ZE"
\u30BD "KATAKANA LETTER SO"
\u30BE "KATAKANA LETTER ZO"
\u30BF "KATAKANA LETTER TA"
\u30C0 "KATAKANA LETTER DA"
\u30C1 "KATAKANA LETTER TI"
\u30C2 "KATAKANA LETTER DI"
\u30C3 "KATAKANA LETTER SMALL TU"
\u30C4 "KATAKANA LETTER TU"
\u30C5 "KATAKANA LETTER DU"
\u30C6 "KATAKANA LETTER TE"
\u30C7 "KATAKANA LETTER DE"
\u30C8 "KATAKANA LETTER TO"
\u30C9 "KATAKANA LETTER DO"
\u30CA "KATAKANA LETTER NA"
\u30CB "KATAKANA LETTER NI"
\u30CC "KATAKANA LETTER NU"
\u30CD "KATAKANA LETTER NE"
\u30CE "KATAKANA LETTER NO"
\u30CF "KATAKANA LETTER HA"
\u30D0 "KATAKANA LETTER BA"
\u30D1 "KATAKANA LETTER PA"
\u30D2 "KATAKANA LETTER HI"
\u30D3 "KATAKANA LETTER BI"
\u30D4 "KATAKANA LETTER PI"
\u30D5 "KATAKANA LETTER HU"
\u30D6 "KATAKANA LETTER BU"
\u30D7 "KATAKANA LETTER PU"
\u30D8 "KATAKANA LETTER HE"
\u30D9 "KATAKANA LETTER BE"
\u30DA "KATAKANA LETTER PE"
\u30DB "KATAKANA LETTER HO"
\u30DC "KATAKANA LETTER BO"
\u30DD "KATAKANA LETTER PO"
\u30DE "KATAKANA LETTER MA"
\u30DF "KATAKANA LETTER MI"
\u30E0 "KATAKANA LETTER MU"
\u30E1 "KATAKANA LETTER ME"
\u30E2 "KATAKANA LETTER MO"
\u30E3 "KATAKANA LETTER SMALL YA"
\u30E4 "KATAKANA LETTER YA"
\u30E5 "KATAKANA LETTER SMALL YU"
\u30E6 "KATAKANA LETTER YU"
\u30E7 "KATAKANA LETTER SMALL YO"
\u30E8 "KATAKANA LETTER YO"
\u30E9 "KATAKANA LETTER RA"
\u30EA "KATAKANA LETTER RI"
\u30EB "KATAKANA LETTER RU"
\u30EC "KATAKANA LETTER RE"
\u30ED "KATAKANA LETTER RO"
\u30EE "KATAKANA LETTER SMALL WA"
\u30EF "KATAKANA LETTER WA"
\u30F0 "KATAKANA LETTER WI"
\u30F1 "KATAKANA LETTER WE"
\u30F2 "KATAKANA LETTER WO"
\u30F3 "KATAKANA LETTER N"
\u30F4 "KATAKANA LETTER VU"
\u30F5 "KATAKANA LETTER SMALL KA"
\u30F6 "KATAKANA LETTER SMALL KE"
\u30F7 "KATAKANA LETTER VA"
\u30F8 "KATAKANA LETTER VI"
\u30F9 "KATAKANA LETTER VE"
\u30FA "KATAKANA LETTER VO"
\u30FB "KATAKANA MIDDLE DOT"
\u30FC "KATAKANA-HIRAGANA PROLONGED SOUND MARK"
\u30FD "KATAKANA ITERATION MARK"
\u30FE "KATAKANA VOICED ITERATION MARK"
\u30FF "KATAKANA DIGRAPH KOTO"
\u3105 "BOPOMOFO LETTER B"
\u3106 "BOPOMOFO LETTER P"
\u3107 "BOPOMOFO LETTER M"
\u3108 "BOPOMOFO LETTER F"
\u3109 "BOPOMOFO LETTER D"
\u310A "BOPOMOFO LETTER T"
\u310B "BOPOMOFO LETTER N"
\u310C "BOPOMOFO LETTER L"
\u310D "BOPOMOFO LETTER G"
\u310E "BOPOMOFO LETTER K"
\u310F "BOPOMOFO LETTER H"
\u3110 "BOPOMOFO LETTER J"
\u3111 "BOPOMOFO LETTER Q"
\u3112 "BOPOMOFO LETTER X"
\u3113 "BOPOMOFO LETTER ZH"
\u3114 "BOPOMOFO LETTER CH"
\u3115 "BOPOMOFO LETTER SH"
\u3116 "BOPOMOFO LETTER R"
\u3117 "BOPOMOFO LETTER Z"
\u3118 "BOPOMOFO LETTER C"
\u3119 "BOPOMOFO LETTER S"
\u311A "BOPOMOFO LETTER A"
\u311B "BOPOMOFO LETTER O"
\u311C "BOPOMOFO LETTER E"
\u311D "BOPOMOFO LETTER EH"
\u311E "BOPOMOFO LETTER AI"
\u311F "BOPOMOFO LETTER EI"
\u3120 "BOPOMOFO LETTER AU"
\u3121 "BOPOMOFO LETTER OU"
\u3122 "BOPOMOFO LETTER AN"
\u3123 "BOPOMOFO LETTER EN"
\u3124 "BOPOMOFO LETTER ANG"
\u3125 "BOPOMOFO LETTER ENG"
\u3126 "BOPOMOFO LETTER ER"
\u3127 "BOPOMOFO LETTER I"
\u3128 "BOPOMOFO LETTER U"
\u3129 "BOPOMOFO LETTER IU"
\u312A "BOPOMOFO LETTER V"
\u312B "BOPOMOFO LETTER NG"
\u312C "BOPOMOFO LETTER GN"
\u312D "BOPOMOFO LETTER IH"
\u3131 "HANGUL LETTER KIYEOK"
\u3132 "HANGUL LETTER SSANGKIYEOK"
\u3133 "HANGUL LETTER KIYEOK-SIOS"
\u3134 "HANGUL LETTER NIEUN"
\u3135 "HANGUL LETTER NIEUN-CIEUC"
\u3136 "HANGUL LETTER NIEUN-HIEUH"
\u3137 "HANGUL LETTER TIKEUT"
\u3138 "HANGUL LETTER SSANGTIKEUT"
\u3139 "HANGUL LETTER RIEUL"
\u313A "HANGUL LETTER RIEUL-KIYEOK"
\u313B "HANGUL LETTER RIEUL-MIEUM"
\u313C "HANGUL LETTER RIEUL-PIEUP"
\u313D "HANGUL LETTER RIEUL-SIOS"
\u313E "HANGUL LETTER RIEUL-THIEUTH"
\u313F "HANGUL LETTER RIEUL-PHIEUPH"
\u3140 "HANGUL LETTER RIEUL-HIEUH"
\u3141 "HANGUL LETTER MIEUM"
\u3142 "HANGUL LETTER PIEUP"
\u3143 "HANGUL LETTER SSANGPIEUP"
\u3144 "HANGUL LETTER PIEUP-SIOS"
\u3145 "HANGUL LETTER SIOS"
\u3146 "HANGUL LETTER SSANGSIOS"
\u3147 "HANGUL LETTER IEUNG"
\u3148 "HANGUL LETTER CIEUC"
\u3149 "HANGUL LETTER SSANGCIEUC"
\u314A "HANGUL LETTER CHIEUCH"
\u314B "HANGUL LETTER KHIEUKH"
\u314C "HANGUL LETTER THIEUTH"
\u314D "HANGUL LETTER PHIEUPH"
\u314E "HANGUL LETTER HIEUH"
\u314F "HANGUL LETTER A"
\u3150 "HANGUL LETTER AE"
\u3151 "HANGUL LETTER YA"
\u3152 "HANGUL LETTER YAE"
\u3153 "HANGUL LETTER EO"
\u3154 "HANGUL LETTER E"
\u3155 "HANGUL LETTER YEO"
\u3156 "HANGUL LETTER YE"
\u3157 "HANGUL LETTER O"
\u3158 "HANGUL LETTER WA"
\u3159 "HANGUL LETTER WAE"
\u315A "HANGUL LETTER OE"
\u315B "HANGUL LETTER YO"
\u315C "HANGUL LETTER U"
\u315D "HANGUL LETTER WEO"
\u315E "HANGUL LETTER WE"
\u315F "HANGUL LETTER WI"
\u3160 "HANGUL LETTER YU"
\u3161 "HANGUL LETTER EU"
\u3162 "HANGUL LETTER YI"
\u3163 "HANGUL LETTER I"
\u3164 "HANGUL FILLER"
\u3165 "HANGUL LETTER SSANGNIEUN"
\u3166 "HANGUL LETTER NIEUN-TIKEUT"
\u3167 "HANGUL LETTER NIEUN-SIOS"
\u3168 "HANGUL LETTER NIEUN-PANSIOS"
\u3169 "HANGUL LETTER RIEUL-KIYEOK-SIOS"
\u316A "HANGUL LETTER RIEUL-TIKEUT"
\u316B "HANGUL LETTER RIEUL-PIEUP-SIOS"
\u316C "HANGUL LETTER RIEUL-PANSIOS"
\u316D "HANGUL LETTER RIEUL-YEORINHIEUH"
\u316E "HANGUL LETTER MIEUM-PIEUP"
\u316F "HANGUL LETTER MIEUM-SIOS"
\u3170 "HANGUL LETTER MIEUM-PANSIOS"
\u3171 "HANGUL LETTER KAPYEOUNMIEUM"
\u3172 "HANGUL LETTER PIEUP-KIYEOK"
\u3173 "HANGUL LETTER PIEUP-TIKEUT"
\u3174 "HANGUL LETTER PIEUP-SIOS-KIYEOK"
\u3175 "HANGUL LETTER PIEUP-SIOS-TIKEUT"
\u3176 "HANGUL LETTER PIEUP-CIEUC"
\u3177 "HANGUL LETTER PIEUP-THIEUTH"
\u3178 "HANGUL LETTER KAPYEOUNPIEUP"
\u3179 "HANGUL LETTER KAPYEOUNSSANGPIEUP"
\u317A "HANGUL LETTER SIOS-KIYEOK"
\u317B "HANGUL LETTER SIOS-NIEUN"
\u317C "HANGUL LETTER SIOS-TIKEUT"
\u317D "HANGUL LETTER SIOS-PIEUP"
\u317E "HANGUL LETTER SIOS-CIEUC"
\u317F "HANGUL LETTER PANSIOS"
\u3180 "HANGUL LETTER SSANGIEUNG"
\u3181 "HANGUL LETTER YESIEUNG"
\u3182 "HANGUL LETTER YESIEUNG-SIOS"
\u3183 "HANGUL LETTER YESIEUNG-PANSIOS"
\u3184 "HANGUL LETTER KAPYEOUNPHIEUPH"
\u3185 "HANGUL LETTER SSANGHIEUH"
\u3186 "HANGUL LETTER YEORINHIEUH"
\u3187 "HANGUL LETTER YO-YA"
\u3188 "HANGUL LETTER YO-YAE"
\u3189 "HANGUL LETTER YO-I"
\u318A "HANGUL LETTER YU-YEO"
\u318B "HANGUL LETTER YU-YE"
\u318C "HANGUL LETTER YU-I"
\u318D "HANGUL LETTER ARAEA"
\u318E "HANGUL LETTER ARAEAE"
\u3190 "IDEOGRAPHIC ANNOTATION LINKING MARK"
\u3191 "IDEOGRAPHIC ANNOTATION REVERSE MARK"
\u3192 "IDEOGRAPHIC ANNOTATION ONE MARK"
\u3193 "IDEOGRAPHIC ANNOTATION TWO MARK"
\u3194 "IDEOGRAPHIC ANNOTATION THREE MARK"
\u3195 "IDEOGRAPHIC ANNOTATION FOUR MARK"
\u3196 "IDEOGRAPHIC ANNOTATION TOP MARK"
\u3197 "IDEOGRAPHIC ANNOTATION MIDDLE MARK"
\u3198 "IDEOGRAPHIC ANNOTATION BOTTOM MARK"
\u3199 "IDEOGRAPHIC ANNOTATION FIRST MARK"
\u319A "IDEOGRAPHIC ANNOTATION SECOND MARK"
\u319B "IDEOGRAPHIC ANNOTATION THIRD MARK"
\u319C "IDEOGRAPHIC ANNOTATION FOURTH MARK"
\u319D "IDEOGRAPHIC ANNOTATION HEAVEN MARK"
\u319E "IDEOGRAPHIC ANNOTATION EARTH MARK"
\u319F "IDEOGRAPHIC ANNOTATION MAN MARK"
\u31A0 "BOPOMOFO LETTER BU"
\u31A1 "BOPOMOFO LETTER ZI"
\u31A2 "BOPOMOFO LETTER JI"
\u31A3 "BOPOMOFO LETTER GU"
\u31A4 "BOPOMOFO LETTER EE"
\u31A5 "BOPOMOFO LETTER ENN"
\u31A6 "BOPOMOFO LETTER OO"
\u31A7 "BOPOMOFO LETTER ONN"
\u31A8 "BOPOMOFO LETTER IR"
\u31A9 "BOPOMOFO LETTER ANN"
\u31AA "BOPOMOFO LETTER INN"
\u31AB "BOPOMOFO LETTER UNN"
\u31AC "BOPOMOFO LETTER IM"
\u31AD "BOPOMOFO LETTER NGG"
\u31AE "BOPOMOFO LETTER AINN"
\u31AF "BOPOMOFO LETTER AUNN"
\u31B0 "BOPOMOFO LETTER AM"
\u31B1 "BOPOMOFO LETTER OM"
\u31B2 "BOPOMOFO LETTER ONG"
\u31B3 "BOPOMOFO LETTER INNN"
\u31B4 "BOPOMOFO FINAL LETTER P"
\u31B5 "BOPOMOFO FINAL LETTER T"
\u31B6 "BOPOMOFO FINAL LETTER K"
\u31B7 "BOPOMOFO FINAL LETTER H"
\u31C0 "CJK STROKE T"
\u31C1 "CJK STROKE WG"
\u31C2 "CJK STROKE XG"
\u31C3 "CJK STROKE BXG"
\u31C4 "CJK STROKE SW"
\u31C5 "CJK STROKE HZZ"
\u31C6 "CJK STROKE HZG"
\u31C7 "CJK STROKE HP"
\u31C8 "CJK STROKE HZWG"
\u31C9 "CJK STROKE SZWG"
\u31CA "CJK STROKE HZT"
\u31CB "CJK STROKE HZZP"
\u31CC "CJK STROKE HPWG"
\u31CD "CJK STROKE HZW"
\u31CE "CJK STROKE HZZZ"
\u31CF "CJK STROKE N"
\u31D0 "CJK STROKE H"
\u31D1 "CJK STROKE S"
\u31D2 "CJK STROKE P"
\u31D3 "CJK STROKE SP"
\u31D4 "CJK STROKE D"
\u31D5 "CJK STROKE HZ"
\u31D6 "CJK STROKE HG"
\u31D7 "CJK STROKE SZ"
\u31D8 "CJK STROKE SWZ"
\u31D9 "CJK STROKE ST"
\u31DA "CJK STROKE SG"
\u31DB "CJK STROKE PD"
\u31DC "CJK STROKE PZ"
\u31DD "CJK STROKE TN"
\u31DE "CJK STROKE SZZ"
\u31DF "CJK STROKE SWG"
\u31E0 "CJK STROKE HXWG"
\u31E1 "CJK STROKE HZZZG"
\u31E2 "CJK STROKE PG"
\u31E3 "CJK STROKE Q"
\u31F0 "KATAKANA LETTER SMALL KU"
\u31F1 "KATAKANA LETTER SMALL SI"
\u31F2 "KATAKANA LETTER SMALL SU"
\u31F3 "KATAKANA LETTER SMALL TO"
\u31F4 "KATAKANA LETTER SMALL NU"
\u31F5 "KATAKANA LETTER SMALL HA"
\u31F6 "KATAKANA LETTER SMALL HI"
\u31F7 "KATAKANA LETTER SMALL HU"
\u31F8 "KATAKANA LETTER SMALL HE"
\u31F9 "KATAKANA LETTER SMALL HO"
\u31FA "KATAKANA LETTER SMALL MU"
\u31FB "KATAKANA LETTER SMALL RA"
\u31FC "KATAKANA LETTER SMALL RI"
\u31FD "KATAKANA LETTER SMALL RU"
\u31FE "KATAKANA LETTER SMALL RE"
\u31FF "KATAKANA LETTER SMALL RO"
\u3200 "PARENTHESIZED HANGUL KIYEOK"
\u3201 "PARENTHESIZED HANGUL NIEUN"
\u3202 "PARENTHESIZED HANGUL TIKEUT"
\u3203 "PARENTHESIZED HANGUL RIEUL"
\u3204 "PARENTHESIZED HANGUL MIEUM"
\u3205 "PARENTHESIZED HANGUL PIEUP"
\u3206 "PARENTHESIZED HANGUL SIOS"
\u3207 "PARENTHESIZED HANGUL IEUNG"
\u3208 "PARENTHESIZED HANGUL CIEUC"
\u3209 "PARENTHESIZED HANGUL CHIEUCH"
\u320A "PARENTHESIZED HANGUL KHIEUKH"
\u320B "PARENTHESIZED HANGUL THIEUTH"
\u320C "PARENTHESIZED HANGUL PHIEUPH"
\u320D "PARENTHESIZED HANGUL HIEUH"
\u320E "PARENTHESIZED HANGUL KIYEOK A"
\u320F "PARENTHESIZED HANGUL NIEUN A"
\u3210 "PARENTHESIZED HANGUL TIKEUT A"
\u3211 "PARENTHESIZED HANGUL RIEUL A"
\u3212 "PARENTHESIZED HANGUL MIEUM A"
\u3213 "PARENTHESIZED HANGUL PIEUP A"
\u3214 "PARENTHESIZED HANGUL SIOS A"
\u3215 "PARENTHESIZED HANGUL IEUNG A"
\u3216 "PARENTHESIZED HANGUL CIEUC A"
\u3217 "PARENTHESIZED HANGUL CHIEUCH A"
\u3218 "PARENTHESIZED HANGUL KHIEUKH A"
\u3219 "PARENTHESIZED HANGUL THIEUTH A"
\u321A "PARENTHESIZED HANGUL PHIEUPH A"
\u321B "PARENTHESIZED HANGUL HIEUH A"
\u321C "PARENTHESIZED HANGUL CIEUC U"
\u321D "PARENTHESIZED KOREAN CHARACTER OJEON"
\u321E "PARENTHESIZED KOREAN CHARACTER O HU"
\u3220 "PARENTHESIZED IDEOGRAPH ONE"
\u3221 "PARENTHESIZED IDEOGRAPH TWO"
\u3222 "PARENTHESIZED IDEOGRAPH THREE"
\u3223 "PARENTHESIZED IDEOGRAPH FOUR"
\u3224 "PARENTHESIZED IDEOGRAPH FIVE"
\u3225 "PARENTHESIZED IDEOGRAPH SIX"
\u3226 "PARENTHESIZED IDEOGRAPH SEVEN"
\u3227 "PARENTHESIZED IDEOGRAPH EIGHT"
\u3228 "PARENTHESIZED IDEOGRAPH NINE"
\u3229 "PARENTHESIZED IDEOGRAPH TEN"
\u322A "PARENTHESIZED IDEOGRAPH MOON"
\u322B "PARENTHESIZED IDEOGRAPH FIRE"
\u322C "PARENTHESIZED IDEOGRAPH WATER"
\u322D "PARENTHESIZED IDEOGRAPH WOOD"
\u322E "PARENTHESIZED IDEOGRAPH METAL"
\u322F "PARENTHESIZED IDEOGRAPH EARTH"
\u3230 "PARENTHESIZED IDEOGRAPH SUN"
\u3231 "PARENTHESIZED IDEOGRAPH STOCK"
\u3232 "PARENTHESIZED IDEOGRAPH HAVE"
\u3233 "PARENTHESIZED IDEOGRAPH SOCIETY"
\u3234 "PARENTHESIZED IDEOGRAPH NAME"
\u3235 "PARENTHESIZED IDEOGRAPH SPECIAL"
\u3236 "PARENTHESIZED IDEOGRAPH FINANCIAL"
\u3237 "PARENTHESIZED IDEOGRAPH CONGRATULATION"
\u3238 "PARENTHESIZED IDEOGRAPH LABOR"
\u3239 "PARENTHESIZED IDEOGRAPH REPRESENT"
\u323A "PARENTHESIZED IDEOGRAPH CALL"
\u323B "PARENTHESIZED IDEOGRAPH STUDY"
\u323C "PARENTHESIZED IDEOGRAPH SUPERVISE"
\u323D "PARENTHESIZED IDEOGRAPH ENTERPRISE"
\u323E "PARENTHESIZED IDEOGRAPH RESOURCE"
\u323F "PARENTHESIZED IDEOGRAPH ALLIANCE"
\u3240 "PARENTHESIZED IDEOGRAPH FESTIVAL"
\u3241 "PARENTHESIZED IDEOGRAPH REST"
\u3242 "PARENTHESIZED IDEOGRAPH SELF"
\u3243 "PARENTHESIZED IDEOGRAPH REACH"
\u3250 "PARTNERSHIP SIGN"
\u3251 "CIRCLED NUMBER TWENTY ONE"
\u3252 "CIRCLED NUMBER TWENTY TWO"
\u3253 "CIRCLED NUMBER TWENTY THREE"
\u3254 "CIRCLED NUMBER TWENTY FOUR"
\u3255 "CIRCLED NUMBER TWENTY FIVE"
\u3256 "CIRCLED NUMBER TWENTY SIX"
\u3257 "CIRCLED NUMBER TWENTY SEVEN"
\u3258 "CIRCLED NUMBER TWENTY EIGHT"
\u3259 "CIRCLED NUMBER TWENTY NINE"
\u325A "CIRCLED NUMBER THIRTY"
\u325B "CIRCLED NUMBER THIRTY ONE"
\u325C "CIRCLED NUMBER THIRTY TWO"
\u325D "CIRCLED NUMBER THIRTY THREE"
\u325E "CIRCLED NUMBER THIRTY FOUR"
\u325F "CIRCLED NUMBER THIRTY FIVE"
\u3260 "CIRCLED HANGUL KIYEOK"
\u3261 "CIRCLED HANGUL NIEUN"
\u3262 "CIRCLED HANGUL TIKEUT"
\u3263 "CIRCLED HANGUL RIEUL"
\u3264 "CIRCLED HANGUL MIEUM"
\u3265 "CIRCLED HANGUL PIEUP"
\u3266 "CIRCLED HANGUL SIOS"
\u3267 "CIRCLED HANGUL IEUNG"
\u3268 "CIRCLED HANGUL CIEUC"
\u3269 "CIRCLED HANGUL CHIEUCH"
\u326A "CIRCLED HANGUL KHIEUKH"
\u326B "CIRCLED HANGUL THIEUTH"
\u326C "CIRCLED HANGUL PHIEUPH"
\u326D "CIRCLED HANGUL HIEUH"
\u326E "CIRCLED HANGUL KIYEOK A"
\u326F "CIRCLED HANGUL NIEUN A"
\u3270 "CIRCLED HANGUL TIKEUT A"
\u3271 "CIRCLED HANGUL RIEUL A"
\u3272 "CIRCLED HANGUL MIEUM A"
\u3273 "CIRCLED HANGUL PIEUP A"
\u3274 "CIRCLED HANGUL SIOS A"
\u3275 "CIRCLED HANGUL IEUNG A"
\u3276 "CIRCLED HANGUL CIEUC A"
\u3277 "CIRCLED HANGUL CHIEUCH A"
\u3278 "CIRCLED HANGUL KHIEUKH A"
\u3279 "CIRCLED HANGUL THIEUTH A"
\u327A "CIRCLED HANGUL PHIEUPH A"
\u327B "CIRCLED HANGUL HIEUH A"
\u327C "CIRCLED KOREAN CHARACTER CHAMKO"
\u327D "CIRCLED KOREAN CHARACTER JUEUI"
\u327E "CIRCLED HANGUL IEUNG U"
\u327F "KOREAN STANDARD SYMBOL"
\u3280 "CIRCLED IDEOGRAPH ONE"
\u3281 "CIRCLED IDEOGRAPH TWO"
\u3282 "CIRCLED IDEOGRAPH THREE"
\u3283 "CIRCLED IDEOGRAPH FOUR"
\u3284 "CIRCLED IDEOGRAPH FIVE"
\u3285 "CIRCLED IDEOGRAPH SIX"
\u3286 "CIRCLED IDEOGRAPH SEVEN"
\u3287 "CIRCLED IDEOGRAPH EIGHT"
\u3288 "CIRCLED IDEOGRAPH NINE"
\u3289 "CIRCLED IDEOGRAPH TEN"
\u328A "CIRCLED IDEOGRAPH MOON"
\u328B "CIRCLED IDEOGRAPH FIRE"
\u328C "CIRCLED IDEOGRAPH WATER"
\u328D "CIRCLED IDEOGRAPH WOOD"
\u328E "CIRCLED IDEOGRAPH METAL"
\u328F "CIRCLED IDEOGRAPH EARTH"
\u3290 "CIRCLED IDEOGRAPH SUN"
\u3291 "CIRCLED IDEOGRAPH STOCK"
\u3292 "CIRCLED IDEOGRAPH HAVE"
\u3293 "CIRCLED IDEOGRAPH SOCIETY"
\u3294 "CIRCLED IDEOGRAPH NAME"
\u3295 "CIRCLED IDEOGRAPH SPECIAL"
\u3296 "CIRCLED IDEOGRAPH FINANCIAL"
\u3297 "CIRCLED IDEOGRAPH CONGRATULATION"
\u3298 "CIRCLED IDEOGRAPH LABOR"
\u3299 "CIRCLED IDEOGRAPH SECRET"
\u329A "CIRCLED IDEOGRAPH MALE"
\u329B "CIRCLED IDEOGRAPH FEMALE"
\u329C "CIRCLED IDEOGRAPH SUITABLE"
\u329D "CIRCLED IDEOGRAPH EXCELLENT"
\u329E "CIRCLED IDEOGRAPH PRINT"
\u329F "CIRCLED IDEOGRAPH ATTENTION"
\u32A0 "CIRCLED IDEOGRAPH ITEM"
\u32A1 "CIRCLED IDEOGRAPH REST"
\u32A2 "CIRCLED IDEOGRAPH COPY"
\u32A3 "CIRCLED IDEOGRAPH CORRECT"
\u32A4 "CIRCLED IDEOGRAPH HIGH"
\u32A5 "CIRCLED IDEOGRAPH CENTRE"
\u32A6 "CIRCLED IDEOGRAPH LOW"
\u32A7 "CIRCLED IDEOGRAPH LEFT"
\u32A8 "CIRCLED IDEOGRAPH RIGHT"
\u32A9 "CIRCLED IDEOGRAPH MEDICINE"
\u32AA "CIRCLED IDEOGRAPH RELIGION"
\u32AB "CIRCLED IDEOGRAPH STUDY"
\u32AC "CIRCLED IDEOGRAPH SUPERVISE"
\u32AD "CIRCLED IDEOGRAPH ENTERPRISE"
\u32AE "CIRCLED IDEOGRAPH RESOURCE"
\u32AF "CIRCLED IDEOGRAPH ALLIANCE"
\u32B0 "CIRCLED IDEOGRAPH NIGHT"
\u32B1 "CIRCLED NUMBER THIRTY SIX"
\u32B2 "CIRCLED NUMBER THIRTY SEVEN"
\u32B3 "CIRCLED NUMBER THIRTY EIGHT"
\u32B4 "CIRCLED NUMBER THIRTY NINE"
\u32B5 "CIRCLED NUMBER FORTY"
\u32B6 "CIRCLED NUMBER FORTY ONE"
\u32B7 "CIRCLED NUMBER FORTY TWO"
\u32B8 "CIRCLED NUMBER FORTY THREE"
\u32B9 "CIRCLED NUMBER FORTY FOUR"
\u32BA "CIRCLED NUMBER FORTY FIVE"
\u32BB "CIRCLED NUMBER FORTY SIX"
\u32BC "CIRCLED NUMBER FORTY SEVEN"
\u32BD "CIRCLED NUMBER FORTY EIGHT"
\u32BE "CIRCLED NUMBER FORTY NINE"
\u32BF "CIRCLED NUMBER FIFTY"
\u32C0 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY"
\u32C1 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR FEBRUARY"
\u32C2 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR MARCH"
\u32C3 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR APRIL"
\u32C4 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR MAY"
\u32C5 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR JUNE"
\u32C6 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR JULY"
\u32C7 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR AUGUST"
\u32C8 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR SEPTEMBER"
\u32C9 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR OCTOBER"
\u32CA "IDEOGRAPHIC TELEGRAPH SYMBOL FOR NOVEMBER"
\u32CB "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DECEMBER"
\u32CC "SQUARE HG"
\u32CD "SQUARE ERG"
\u32CE "SQUARE EV"
\u32CF "LIMITED LIABILITY SIGN"
\u32D0 "CIRCLED KATAKANA A"
\u32D1 "CIRCLED KATAKANA I"
\u32D2 "CIRCLED KATAKANA U"
\u32D3 "CIRCLED KATAKANA E"
\u32D4 "CIRCLED KATAKANA O"
\u32D5 "CIRCLED KATAKANA KA"
\u32D6 "CIRCLED KATAKANA KI"
\u32D7 "CIRCLED KATAKANA KU"
\u32D8 "CIRCLED KATAKANA KE"
\u32D9 "CIRCLED KATAKANA KO"
\u32DA "CIRCLED KATAKANA SA"
\u32DB "CIRCLED KATAKANA SI"
\u32DC "CIRCLED KATAKANA SU"
\u32DD "CIRCLED KATAKANA SE"
\u32DE "CIRCLED KATAKANA SO"
\u32DF "CIRCLED KATAKANA TA"
\u32E0 "CIRCLED KATAKANA TI"
\u32E1 "CIRCLED KATAKANA TU"
\u32E2 "CIRCLED KATAKANA TE"
\u32E3 "CIRCLED KATAKANA TO"
\u32E4 "CIRCLED KATAKANA NA"
\u32E5 "CIRCLED KATAKANA NI"
\u32E6 "CIRCLED KATAKANA NU"
\u32E7 "CIRCLED KATAKANA NE"
\u32E8 "CIRCLED KATAKANA NO"
\u32E9 "CIRCLED KATAKANA HA"
\u32EA "CIRCLED KATAKANA HI"
\u32EB "CIRCLED KATAKANA HU"
\u32EC "CIRCLED KATAKANA HE"
\u32ED "CIRCLED KATAKANA HO"
\u32EE "CIRCLED KATAKANA MA"
\u32EF "CIRCLED KATAKANA MI"
\u32F0 "CIRCLED KATAKANA MU"
\u32F1 "CIRCLED KATAKANA ME"
\u32F2 "CIRCLED KATAKANA MO"
\u32F3 "CIRCLED KATAKANA YA"
\u32F4 "CIRCLED KATAKANA YU"
\u32F5 "CIRCLED KATAKANA YO"
\u32F6 "CIRCLED KATAKANA RA"
\u32F7 "CIRCLED KATAKANA RI"
\u32F8 "CIRCLED KATAKANA RU"
\u32F9 "CIRCLED KATAKANA RE"
\u32FA "CIRCLED KATAKANA RO"
\u32FB "CIRCLED KATAKANA WA"
\u32FC "CIRCLED KATAKANA WI"
\u32FD "CIRCLED KATAKANA WE"
\u32FE "CIRCLED KATAKANA WO"
\u3300 "SQUARE APAATO"
\u3301 "SQUARE ARUHUA"
\u3302 "SQUARE ANPEA"
\u3303 "SQUARE AARU"
\u3304 "SQUARE ININGU"
\u3305 "SQUARE INTI"
\u3306 "SQUARE UON"
\u3307 "SQUARE ESUKUUDO"
\u3308 "SQUARE EEKAA"
\u3309 "SQUARE ONSU"
\u330A "SQUARE OOMU"
\u330B "SQUARE KAIRI"
\u330C "SQUARE KARATTO"
\u330D "SQUARE KARORII"
\u330E "SQUARE GARON"
\u330F "SQUARE GANMA"
\u3310 "SQUARE GIGA"
\u3311 "SQUARE GINII"
\u3312 "SQUARE KYURII"
\u3313 "SQUARE GIRUDAA"
\u3314 "SQUARE KIRO"
\u3315 "SQUARE KIROGURAMU"
\u3316 "SQUARE KIROMEETORU"
\u3317 "SQUARE KIROWATTO"
\u3318 "SQUARE GURAMU"
\u3319 "SQUARE GURAMUTON"
\u331A "SQUARE KURUZEIRO"
\u331B "SQUARE KUROONE"
\u331C "SQUARE KEESU"
\u331D "SQUARE KORUNA"
\u331E "SQUARE KOOPO"
\u331F "SQUARE SAIKURU"
\u3320 "SQUARE SANTIIMU"
\u3321 "SQUARE SIRINGU"
\u3322 "SQUARE SENTI"
\u3323 "SQUARE SENTO"
\u3324 "SQUARE DAASU"
\u3325 "SQUARE DESI"
\u3326 "SQUARE DORU"
\u3327 "SQUARE TON"
\u3328 "SQUARE NANO"
\u3329 "SQUARE NOTTO"
\u332A "SQUARE HAITU"
\u332B "SQUARE PAASENTO"
\u332C "SQUARE PAATU"
\u332D "SQUARE BAARERU"
\u332E "SQUARE PIASUTORU"
\u332F "SQUARE PIKURU"
\u3330 "SQUARE PIKO"
\u3331 "SQUARE BIRU"
\u3332 "SQUARE HUARADDO"
\u3333 "SQUARE HUIITO"
\u3334 "SQUARE BUSSYERU"
\u3335 "SQUARE HURAN"
\u3336 "SQUARE HEKUTAARU"
\u3337 "SQUARE PESO"
\u3338 "SQUARE PENIHI"
\u3339 "SQUARE HERUTU"
\u333A "SQUARE PENSU"
\u333B "SQUARE PEEZI"
\u333C "SQUARE BEETA"
\u333D "SQUARE POINTO"
\u333E "SQUARE BORUTO"
\u333F "SQUARE HON"
\u3340 "SQUARE PONDO"
\u3341 "SQUARE HOORU"
\u3342 "SQUARE HOON"
\u3343 "SQUARE MAIKURO"
\u3344 "SQUARE MAIRU"
\u3345 "SQUARE MAHHA"
\u3346 "SQUARE MARUKU"
\u3347 "SQUARE MANSYON"
\u3348 "SQUARE MIKURON"
\u3349 "SQUARE MIRI"
\u334A "SQUARE MIRIBAARU"
\u334B "SQUARE MEGA"
\u334C "SQUARE MEGATON"
\u334D "SQUARE MEETORU"
\u334E "SQUARE YAADO"
\u334F "SQUARE YAARU"
\u3350 "SQUARE YUAN"
\u3351 "SQUARE RITTORU"
\u3352 "SQUARE RIRA"
\u3353 "SQUARE RUPII"
\u3354 "SQUARE RUUBURU"
\u3355 "SQUARE REMU"
\u3356 "SQUARE RENTOGEN"
\u3357 "SQUARE WATTO"
\u3358 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ZERO"
\u3359 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ONE"
\u335A "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWO"
\u335B "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR THREE"
\u335C "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FOUR"
\u335D "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FIVE"
\u335E "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SIX"
\u335F "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SEVEN"
\u3360 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR EIGHT"
\u3361 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR NINE"
\u3362 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TEN"
\u3363 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR ELEVEN"
\u3364 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWELVE"
\u3365 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR THIRTEEN"
\u3366 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FOURTEEN"
\u3367 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR FIFTEEN"
\u3368 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SIXTEEN"
\u3369 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR SEVENTEEN"
\u336A "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR EIGHTEEN"
\u336B "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR NINETEEN"
\u336C "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY"
\u336D "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-ONE"
\u336E "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-TWO"
\u336F "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-THREE"
\u3370 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR HOUR TWENTY-FOUR"
\u3371 "SQUARE HPA"
\u3372 "SQUARE DA"
\u3373 "SQUARE AU"
\u3374 "SQUARE BAR"
\u3375 "SQUARE OV"
\u3376 "SQUARE PC"
\u3377 "SQUARE DM"
\u3378 "SQUARE DM SQUARED"
\u3379 "SQUARE DM CUBED"
\u337A "SQUARE IU"
\u337B "SQUARE ERA NAME HEISEI"
\u337C "SQUARE ERA NAME SYOUWA"
\u337D "SQUARE ERA NAME TAISYOU"
\u337E "SQUARE ERA NAME MEIZI"
\u337F "SQUARE CORPORATION"
\u3380 "SQUARE PA AMPS"
\u3381 "SQUARE NA"
\u3382 "SQUARE MU A"
\u3383 "SQUARE MA"
\u3384 "SQUARE KA"
\u3385 "SQUARE KB"
\u3386 "SQUARE MB"
\u3387 "SQUARE GB"
\u3388 "SQUARE CAL"
\u3389 "SQUARE KCAL"
\u338A "SQUARE PF"
\u338B "SQUARE NF"
\u338C "SQUARE MU F"
\u338D "SQUARE MU G"
\u338E "SQUARE MG"
\u338F "SQUARE KG"
\u3390 "SQUARE HZ"
\u3391 "SQUARE KHZ"
\u3392 "SQUARE MHZ"
\u3393 "SQUARE GHZ"
\u3394 "SQUARE THZ"
\u3395 "SQUARE MU L"
\u3396 "SQUARE ML"
\u3397 "SQUARE DL"
\u3398 "SQUARE KL"
\u3399 "SQUARE FM"
\u339A "SQUARE NM"
\u339B "SQUARE MU M"
\u339C "SQUARE MM"
\u339D "SQUARE CM"
\u339E "SQUARE KM"
\u339F "SQUARE MM SQUARED"
\u33A0 "SQUARE CM SQUARED"
\u33A1 "SQUARE M SQUARED"
\u33A2 "SQUARE KM SQUARED"
\u33A3 "SQUARE MM CUBED"
\u33A4 "SQUARE CM CUBED"
\u33A5 "SQUARE M CUBED"
\u33A6 "SQUARE KM CUBED"
\u33A7 "SQUARE M OVER S"
\u33A8 "SQUARE M OVER S SQUARED"
\u33A9 "SQUARE PA"
\u33AA "SQUARE KPA"
\u33AB "SQUARE MPA"
\u33AC "SQUARE GPA"
\u33AD "SQUARE RAD"
\u33AE "SQUARE RAD OVER S"
\u33AF "SQUARE RAD OVER S SQUARED"
\u33B0 "SQUARE PS"
\u33B1 "SQUARE NS"
\u33B2 "SQUARE MU S"
\u33B3 "SQUARE MS"
\u33B4 "SQUARE PV"
\u33B5 "SQUARE NV"
\u33B6 "SQUARE MU V"
\u33B7 "SQUARE MV"
\u33B8 "SQUARE KV"
\u33B9 "SQUARE MV MEGA"
\u33BA "SQUARE PW"
\u33BB "SQUARE NW"
\u33BC "SQUARE MU W"
\u33BD "SQUARE MW"
\u33BE "SQUARE KW"
\u33BF "SQUARE MW MEGA"
\u33C0 "SQUARE K OHM"
\u33C1 "SQUARE M OHM"
\u33C2 "SQUARE AM"
\u33C3 "SQUARE BQ"
\u33C4 "SQUARE CC"
\u33C5 "SQUARE CD"
\u33C6 "SQUARE C OVER KG"
\u33C7 "SQUARE CO"
\u33C8 "SQUARE DB"
\u33C9 "SQUARE GY"
\u33CA "SQUARE HA"
\u33CB "SQUARE HP"
\u33CC "SQUARE IN"
\u33CD "SQUARE KK"
\u33CE "SQUARE KM CAPITAL"
\u33CF "SQUARE KT"
\u33D0 "SQUARE LM"
\u33D1 "SQUARE LN"
\u33D2 "SQUARE LOG"
\u33D3 "SQUARE LX"
\u33D4 "SQUARE MB SMALL"
\u33D5 "SQUARE MIL"
\u33D6 "SQUARE MOL"
\u33D7 "SQUARE PH"
\u33D8 "SQUARE PM"
\u33D9 "SQUARE PPM"
\u33DA "SQUARE PR"
\u33DB "SQUARE SR"
\u33DC "SQUARE SV"
\u33DD "SQUARE WB"
\u33DE "SQUARE V OVER M"
\u33DF "SQUARE A OVER M"
\u33E0 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ONE"
\u33E1 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWO"
\u33E2 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THREE"
\u33E3 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FOUR"
\u33E4 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FIVE"
\u33E5 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SIX"
\u33E6 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SEVEN"
\u33E7 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY EIGHT"
\u33E8 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY NINE"
\u33E9 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TEN"
\u33EA "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY ELEVEN"
\u33EB "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWELVE"
\u33EC "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTEEN"
\u33ED "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FOURTEEN"
\u33EE "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY FIFTEEN"
\u33EF "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SIXTEEN"
\u33F0 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY SEVENTEEN"
\u33F1 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY EIGHTEEN"
\u33F2 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY NINETEEN"
\u33F3 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY"
\u33F4 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-ONE"
\u33F5 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-TWO"
\u33F6 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-THREE"
\u33F7 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-FOUR"
\u33F8 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-FIVE"
\u33F9 "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-SIX"
\u33FA "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-SEVEN"
\u33FB "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-EIGHT"
\u33FC "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY TWENTY-NINE"
\u33FD "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY"
\u33FE "IDEOGRAPHIC TELEGRAPH SYMBOL FOR DAY THIRTY-ONE"
\u33FF "SQUARE GAL"
\u4DC0 "HEXAGRAM FOR THE CREATIVE HEAVEN"
\u4DC1 "HEXAGRAM FOR THE RECEPTIVE EARTH"
\u4DC2 "HEXAGRAM FOR DIFFICULTY AT THE BEGINNING"
\u4DC3 "HEXAGRAM FOR YOUTHFUL FOLLY"
\u4DC4 "HEXAGRAM FOR WAITING"
\u4DC5 "HEXAGRAM FOR CONFLICT"
\u4DC6 "HEXAGRAM FOR THE ARMY"
\u4DC7 "HEXAGRAM FOR HOLDING TOGETHER"
\u4DC8 "HEXAGRAM FOR SMALL TAMING"
\u4DC9 "HEXAGRAM FOR TREADING"
\u4DCA "HEXAGRAM FOR PEACE"
\u4DCB "HEXAGRAM FOR STANDSTILL"
\u4DCC "HEXAGRAM FOR FELLOWSHIP"
\u4DCD "HEXAGRAM FOR GREAT POSSESSION"
\u4DCE "HEXAGRAM FOR MODESTY"
\u4DCF "HEXAGRAM FOR ENTHUSIASM"
\u4DD0 "HEXAGRAM FOR FOLLOWING"
\u4DD1 "HEXAGRAM FOR WORK ON THE DECAYED"
\u4DD2 "HEXAGRAM FOR APPROACH"
\u4DD3 "HEXAGRAM FOR CONTEMPLATION"
\u4DD4 "HEXAGRAM FOR BITING THROUGH"
\u4DD5 "HEXAGRAM FOR GRACE"
\u4DD6 "HEXAGRAM FOR SPLITTING APART"
\u4DD7 "HEXAGRAM FOR RETURN"
\u4DD8 "HEXAGRAM FOR INNOCENCE"
\u4DD9 "HEXAGRAM FOR GREAT TAMING"
\u4DDA "HEXAGRAM FOR MOUTH CORNERS"
\u4DDB "HEXAGRAM FOR GREAT PREPONDERANCE"
\u4DDC "HEXAGRAM FOR THE ABYSMAL WATER"
\u4DDD "HEXAGRAM FOR THE CLINGING FIRE"
\u4DDE "HEXAGRAM FOR INFLUENCE"
\u4DDF "HEXAGRAM FOR DURATION"
\u4DE0 "HEXAGRAM FOR RETREAT"
\u4DE1 "HEXAGRAM FOR GREAT POWER"
\u4DE2 "HEXAGRAM FOR PROGRESS"
\u4DE3 "HEXAGRAM FOR DARKENING OF THE LIGHT"
\u4DE4 "HEXAGRAM FOR THE FAMILY"
\u4DE5 "HEXAGRAM FOR OPPOSITION"
\u4DE6 "HEXAGRAM FOR OBSTRUCTION"
\u4DE7 "HEXAGRAM FOR DELIVERANCE"
\u4DE8 "HEXAGRAM FOR DECREASE"
\u4DE9 "HEXAGRAM FOR INCREASE"
\u4DEA "HEXAGRAM FOR BREAKTHROUGH"
\u4DEB "HEXAGRAM FOR COMING TO MEET"
\u4DEC "HEXAGRAM FOR GATHERING TOGETHER"
\u4DED "HEXAGRAM FOR PUSHING UPWARD"
\u4DEE "HEXAGRAM FOR OPPRESSION"
\u4DEF "HEXAGRAM FOR THE WELL"
\u4DF0 "HEXAGRAM FOR REVOLUTION"
\u4DF1 "HEXAGRAM FOR THE CAULDRON"
\u4DF2 "HEXAGRAM FOR THE AROUSING THUNDER"
\u4DF3 "HEXAGRAM FOR THE KEEPING STILL MOUNTAIN"
\u4DF4 "HEXAGRAM FOR DEVELOPMENT"
\u4DF5 "HEXAGRAM FOR THE MARRYING MAIDEN"
\u4DF6 "HEXAGRAM FOR ABUNDANCE"
\u4DF7 "HEXAGRAM FOR THE WANDERER"
\u4DF8 "HEXAGRAM FOR THE GENTLE WIND"
\u4DF9 "HEXAGRAM FOR THE JOYOUS LAKE"
\u4DFA "HEXAGRAM FOR DISPERSION"
\u4DFB "HEXAGRAM FOR LIMITATION"
\u4DFC "HEXAGRAM FOR INNER TRUTH"
\u4DFD "HEXAGRAM FOR SMALL PREPONDERANCE"
\u4DFE "HEXAGRAM FOR AFTER COMPLETION"
\u4DFF "HEXAGRAM FOR BEFORE COMPLETION"
\uA000 "YI SYLLABLE IT"
\uA001 "YI SYLLABLE IX"
\uA002 "YI SYLLABLE I"
\uA003 "YI SYLLABLE IP"
\uA004 "YI SYLLABLE IET"
\uA005 "YI SYLLABLE IEX"
\uA006 "YI SYLLABLE IE"
\uA007 "YI SYLLABLE IEP"
\uA008 "YI SYLLABLE AT"
\uA009 "YI SYLLABLE AX"
\uA00A "YI SYLLABLE A"
\uA00B "YI SYLLABLE AP"
\uA00C "YI SYLLABLE UOX"
\uA00D "YI SYLLABLE UO"
\uA00E "YI SYLLABLE UOP"
\uA00F "YI SYLLABLE OT"
\uA010 "YI SYLLABLE OX"
\uA011 "YI SYLLABLE O"
\uA012 "YI SYLLABLE OP"
\uA013 "YI SYLLABLE EX"
\uA014 "YI SYLLABLE E"
\uA015 "YI SYLLABLE WU"
\uA016 "YI SYLLABLE BIT"
\uA017 "YI SYLLABLE BIX"
\uA018 "YI SYLLABLE BI"
\uA019 "YI SYLLABLE BIP"
\uA01A "YI SYLLABLE BIET"
\uA01B "YI SYLLABLE BIEX"
\uA01C "YI SYLLABLE BIE"
\uA01D "YI SYLLABLE BIEP"
\uA01E "YI SYLLABLE BAT"
\uA01F "YI SYLLABLE BAX"
\uA020 "YI SYLLABLE BA"
\uA021 "YI SYLLABLE BAP"
\uA022 "YI SYLLABLE BUOX"
\uA023 "YI SYLLABLE BUO"
\uA024 "YI SYLLABLE BUOP"
\uA025 "YI SYLLABLE BOT"
\uA026 "YI SYLLABLE BOX"
\uA027 "YI SYLLABLE BO"
\uA028 "YI SYLLABLE BOP"
\uA029 "YI SYLLABLE BEX"
\uA02A "YI SYLLABLE BE"
\uA02B "YI SYLLABLE BEP"
\uA02C "YI SYLLABLE BUT"
\uA02D "YI SYLLABLE BUX"
\uA02E "YI SYLLABLE BU"
\uA02F "YI SYLLABLE BUP"
\uA030 "YI SYLLABLE BURX"
\uA031 "YI SYLLABLE BUR"
\uA032 "YI SYLLABLE BYT"
\uA033 "YI SYLLABLE BYX"
\uA034 "YI SYLLABLE BY"
\uA035 "YI SYLLABLE BYP"
\uA036 "YI SYLLABLE BYRX"
\uA037 "YI SYLLABLE BYR"
\uA038 "YI SYLLABLE PIT"
\uA039 "YI SYLLABLE PIX"
\uA03A "YI SYLLABLE PI"
\uA03B "YI SYLLABLE PIP"
\uA03C "YI SYLLABLE PIEX"
\uA03D "YI SYLLABLE PIE"
\uA03E "YI SYLLABLE PIEP"
\uA03F "YI SYLLABLE PAT"
\uA040 "YI SYLLABLE PAX"
\uA041 "YI SYLLABLE PA"
\uA042 "YI SYLLABLE PAP"
\uA043 "YI SYLLABLE PUOX"
\uA044 "YI SYLLABLE PUO"
\uA045 "YI SYLLABLE PUOP"
\uA046 "YI SYLLABLE POT"
\uA047 "YI SYLLABLE POX"
\uA048 "YI SYLLABLE PO"
\uA049 "YI SYLLABLE POP"
\uA04A "YI SYLLABLE PUT"
\uA04B "YI SYLLABLE PUX"
\uA04C "YI SYLLABLE PU"
\uA04D "YI SYLLABLE PUP"
\uA04E "YI SYLLABLE PURX"
\uA04F "YI SYLLABLE PUR"
\uA050 "YI SYLLABLE PYT"
\uA051 "YI SYLLABLE PYX"
\uA052 "YI SYLLABLE PY"
\uA053 "YI SYLLABLE PYP"
\uA054 "YI SYLLABLE PYRX"
\uA055 "YI SYLLABLE PYR"
\uA056 "YI SYLLABLE BBIT"
\uA057 "YI SYLLABLE BBIX"
\uA058 "YI SYLLABLE BBI"
\uA059 "YI SYLLABLE BBIP"
\uA05A "YI SYLLABLE BBIET"
\uA05B "YI SYLLABLE BBIEX"
\uA05C "YI SYLLABLE BBIE"
\uA05D "YI SYLLABLE BBIEP"
\uA05E "YI SYLLABLE BBAT"
\uA05F "YI SYLLABLE BBAX"
\uA060 "YI SYLLABLE BBA"
\uA061 "YI SYLLABLE BBAP"
\uA062 "YI SYLLABLE BBUOX"
\uA063 "YI SYLLABLE BBUO"
\uA064 "YI SYLLABLE BBUOP"
\uA065 "YI SYLLABLE BBOT"
\uA066 "YI SYLLABLE BBOX"
\uA067 "YI SYLLABLE BBO"
\uA068 "YI SYLLABLE BBOP"
\uA069 "YI SYLLABLE BBEX"
\uA06A "YI SYLLABLE BBE"
\uA06B "YI SYLLABLE BBEP"
\uA06C "YI SYLLABLE BBUT"
\uA06D "YI SYLLABLE BBUX"
\uA06E "YI SYLLABLE BBU"
\uA06F "YI SYLLABLE BBUP"
\uA070 "YI SYLLABLE BBURX"
\uA071 "YI SYLLABLE BBUR"
\uA072 "YI SYLLABLE BBYT"
\uA073 "YI SYLLABLE BBYX"
\uA074 "YI SYLLABLE BBY"
\uA075 "YI SYLLABLE BBYP"
\uA076 "YI SYLLABLE NBIT"
\uA077 "YI SYLLABLE NBIX"
\uA078 "YI SYLLABLE NBI"
\uA079 "YI SYLLABLE NBIP"
\uA07A "YI SYLLABLE NBIEX"
\uA07B "YI SYLLABLE NBIE"
\uA07C "YI SYLLABLE NBIEP"
\uA07D "YI SYLLABLE NBAT"
\uA07E "YI SYLLABLE NBAX"
\uA07F "YI SYLLABLE NBA"
\uA080 "YI SYLLABLE NBAP"
\uA081 "YI SYLLABLE NBOT"
\uA082 "YI SYLLABLE NBOX"
\uA083 "YI SYLLABLE NBO"
\uA084 "YI SYLLABLE NBOP"
\uA085 "YI SYLLABLE NBUT"
\uA086 "YI SYLLABLE NBUX"
\uA087 "YI SYLLABLE NBU"
\uA088 "YI SYLLABLE NBUP"
\uA089 "YI SYLLABLE NBURX"
\uA08A "YI SYLLABLE NBUR"
\uA08B "YI SYLLABLE NBYT"
\uA08C "YI SYLLABLE NBYX"
\uA08D "YI SYLLABLE NBY"
\uA08E "YI SYLLABLE NBYP"
\uA08F "YI SYLLABLE NBYRX"
\uA090 "YI SYLLABLE NBYR"
\uA091 "YI SYLLABLE HMIT"
\uA092 "YI SYLLABLE HMIX"
\uA093 "YI SYLLABLE HMI"
\uA094 "YI SYLLABLE HMIP"
\uA095 "YI SYLLABLE HMIEX"
\uA096 "YI SYLLABLE HMIE"
\uA097 "YI SYLLABLE HMIEP"
\uA098 "YI SYLLABLE HMAT"
\uA099 "YI SYLLABLE HMAX"
\uA09A "YI SYLLABLE HMA"
\uA09B "YI SYLLABLE HMAP"
\uA09C "YI SYLLABLE HMUOX"
\uA09D "YI SYLLABLE HMUO"
\uA09E "YI SYLLABLE HMUOP"
\uA09F "YI SYLLABLE HMOT"
\uA0A0 "YI SYLLABLE HMOX"
\uA0A1 "YI SYLLABLE HMO"
\uA0A2 "YI SYLLABLE HMOP"
\uA0A3 "YI SYLLABLE HMUT"
\uA0A4 "YI SYLLABLE HMUX"
\uA0A5 "YI SYLLABLE HMU"
\uA0A6 "YI SYLLABLE HMUP"
\uA0A7 "YI SYLLABLE HMURX"
\uA0A8 "YI SYLLABLE HMUR"
\uA0A9 "YI SYLLABLE HMYX"
\uA0AA "YI SYLLABLE HMY"
\uA0AB "YI SYLLABLE HMYP"
\uA0AC "YI SYLLABLE HMYRX"
\uA0AD "YI SYLLABLE HMYR"
\uA0AE "YI SYLLABLE MIT"
\uA0AF "YI SYLLABLE MIX"
\uA0B0 "YI SYLLABLE MI"
\uA0B1 "YI SYLLABLE MIP"
\uA0B2 "YI SYLLABLE MIEX"
\uA0B3 "YI SYLLABLE MIE"
\uA0B4 "YI SYLLABLE MIEP"
\uA0B5 "YI SYLLABLE MAT"
\uA0B6 "YI SYLLABLE MAX"
\uA0B7 "YI SYLLABLE MA"
\uA0B8 "YI SYLLABLE MAP"
\uA0B9 "YI SYLLABLE MUOT"
\uA0BA "YI SYLLABLE MUOX"
\uA0BB "YI SYLLABLE MUO"
\uA0BC "YI SYLLABLE MUOP"
\uA0BD "YI SYLLABLE MOT"
\uA0BE "YI SYLLABLE MOX"
\uA0BF "YI SYLLABLE MO"
\uA0C0 "YI SYLLABLE MOP"
\uA0C1 "YI SYLLABLE MEX"
\uA0C2 "YI SYLLABLE ME"
\uA0C3 "YI SYLLABLE MUT"
\uA0C4 "YI SYLLABLE MUX"
\uA0C5 "YI SYLLABLE MU"
\uA0C6 "YI SYLLABLE MUP"
\uA0C7 "YI SYLLABLE MURX"
\uA0C8 "YI SYLLABLE MUR"
\uA0C9 "YI SYLLABLE MYT"
\uA0CA "YI SYLLABLE MYX"
\uA0CB "YI SYLLABLE MY"
\uA0CC "YI SYLLABLE MYP"
\uA0CD "YI SYLLABLE FIT"
\uA0CE "YI SYLLABLE FIX"
\uA0CF "YI SYLLABLE FI"
\uA0D0 "YI SYLLABLE FIP"
\uA0D1 "YI SYLLABLE FAT"
\uA0D2 "YI SYLLABLE FAX"
\uA0D3 "YI SYLLABLE FA"
\uA0D4 "YI SYLLABLE FAP"
\uA0D5 "YI SYLLABLE FOX"
\uA0D6 "YI SYLLABLE FO"
\uA0D7 "YI SYLLABLE FOP"
\uA0D8 "YI SYLLABLE FUT"
\uA0D9 "YI SYLLABLE FUX"
\uA0DA "YI SYLLABLE FU"
\uA0DB "YI SYLLABLE FUP"
\uA0DC "YI SYLLABLE FURX"
\uA0DD "YI SYLLABLE FUR"
\uA0DE "YI SYLLABLE FYT"
\uA0DF "YI SYLLABLE FYX"
\uA0E0 "YI SYLLABLE FY"
\uA0E1 "YI SYLLABLE FYP"
\uA0E2 "YI SYLLABLE VIT"
\uA0E3 "YI SYLLABLE VIX"
\uA0E4 "YI SYLLABLE VI"
\uA0E5 "YI SYLLABLE VIP"
\uA0E6 "YI SYLLABLE VIET"
\uA0E7 "YI SYLLABLE VIEX"
\uA0E8 "YI SYLLABLE VIE"
\uA0E9 "YI SYLLABLE VIEP"
\uA0EA "YI SYLLABLE VAT"
\uA0EB "YI SYLLABLE VAX"
\uA0EC "YI SYLLABLE VA"
\uA0ED "YI SYLLABLE VAP"
\uA0EE "YI SYLLABLE VOT"
\uA0EF "YI SYLLABLE VOX"
\uA0F0 "YI SYLLABLE VO"
\uA0F1 "YI SYLLABLE VOP"
\uA0F2 "YI SYLLABLE VEX"
\uA0F3 "YI SYLLABLE VEP"
\uA0F4 "YI SYLLABLE VUT"
\uA0F5 "YI SYLLABLE VUX"
\uA0F6 "YI SYLLABLE VU"
\uA0F7 "YI SYLLABLE VUP"
\uA0F8 "YI SYLLABLE VURX"
\uA0F9 "YI SYLLABLE VUR"
\uA0FA "YI SYLLABLE VYT"
\uA0FB "YI SYLLABLE VYX"
\uA0FC "YI SYLLABLE VY"
\uA0FD "YI SYLLABLE VYP"
\uA0FE "YI SYLLABLE VYRX"
\uA0FF "YI SYLLABLE VYR"
\uA100 "YI SYLLABLE DIT"
\uA101 "YI SYLLABLE DIX"
\uA102 "YI SYLLABLE DI"
\uA103 "YI SYLLABLE DIP"
\uA104 "YI SYLLABLE DIEX"
\uA105 "YI SYLLABLE DIE"
\uA106 "YI SYLLABLE DIEP"
\uA107 "YI SYLLABLE DAT"
\uA108 "YI SYLLABLE DAX"
\uA109 "YI SYLLABLE DA"
\uA10A "YI SYLLABLE DAP"
\uA10B "YI SYLLABLE DUOX"
\uA10C "YI SYLLABLE DUO"
\uA10D "YI SYLLABLE DOT"
\uA10E "YI SYLLABLE DOX"
\uA10F "YI SYLLABLE DO"
\uA110 "YI SYLLABLE DOP"
\uA111 "YI SYLLABLE DEX"
\uA112 "YI SYLLABLE DE"
\uA113 "YI SYLLABLE DEP"
\uA114 "YI SYLLABLE DUT"
\uA115 "YI SYLLABLE DUX"
\uA116 "YI SYLLABLE DU"
\uA117 "YI SYLLABLE DUP"
\uA118 "YI SYLLABLE DURX"
\uA119 "YI SYLLABLE DUR"
\uA11A "YI SYLLABLE TIT"
\uA11B "YI SYLLABLE TIX"
\uA11C "YI SYLLABLE TI"
\uA11D "YI SYLLABLE TIP"
\uA11E "YI SYLLABLE TIEX"
\uA11F "YI SYLLABLE TIE"
\uA120 "YI SYLLABLE TIEP"
\uA121 "YI SYLLABLE TAT"
\uA122 "YI SYLLABLE TAX"
\uA123 "YI SYLLABLE TA"
\uA124 "YI SYLLABLE TAP"
\uA125 "YI SYLLABLE TUOT"
\uA126 "YI SYLLABLE TUOX"
\uA127 "YI SYLLABLE TUO"
\uA128 "YI SYLLABLE TUOP"
\uA129 "YI SYLLABLE TOT"
\uA12A "YI SYLLABLE TOX"
\uA12B "YI SYLLABLE TO"
\uA12C "YI SYLLABLE TOP"
\uA12D "YI SYLLABLE TEX"
\uA12E "YI SYLLABLE TE"
\uA12F "YI SYLLABLE TEP"
\uA130 "YI SYLLABLE TUT"
\uA131 "YI SYLLABLE TUX"
\uA132 "YI SYLLABLE TU"
\uA133 "YI SYLLABLE TUP"
\uA134 "YI SYLLABLE TURX"
\uA135 "YI SYLLABLE TUR"
\uA136 "YI SYLLABLE DDIT"
\uA137 "YI SYLLABLE DDIX"
\uA138 "YI SYLLABLE DDI"
\uA139 "YI SYLLABLE DDIP"
\uA13A "YI SYLLABLE DDIEX"
\uA13B "YI SYLLABLE DDIE"
\uA13C "YI SYLLABLE DDIEP"
\uA13D "YI SYLLABLE DDAT"
\uA13E "YI SYLLABLE DDAX"
\uA13F "YI SYLLABLE DDA"
\uA140 "YI SYLLABLE DDAP"
\uA141 "YI SYLLABLE DDUOX"
\uA142 "YI SYLLABLE DDUO"
\uA143 "YI SYLLABLE DDUOP"
\uA144 "YI SYLLABLE DDOT"
\uA145 "YI SYLLABLE DDOX"
\uA146 "YI SYLLABLE DDO"
\uA147 "YI SYLLABLE DDOP"
\uA148 "YI SYLLABLE DDEX"
\uA149 "YI SYLLABLE DDE"
\uA14A "YI SYLLABLE DDEP"
\uA14B "YI SYLLABLE DDUT"
\uA14C "YI SYLLABLE DDUX"
\uA14D "YI SYLLABLE DDU"
\uA14E "YI SYLLABLE DDUP"
\uA14F "YI SYLLABLE DDURX"
\uA150 "YI SYLLABLE DDUR"
\uA151 "YI SYLLABLE NDIT"
\uA152 "YI SYLLABLE NDIX"
\uA153 "YI SYLLABLE NDI"
\uA154 "YI SYLLABLE NDIP"
\uA155 "YI SYLLABLE NDIEX"
\uA156 "YI SYLLABLE NDIE"
\uA157 "YI SYLLABLE NDAT"
\uA158 "YI SYLLABLE NDAX"
\uA159 "YI SYLLABLE NDA"
\uA15A "YI SYLLABLE NDAP"
\uA15B "YI SYLLABLE NDOT"
\uA15C "YI SYLLABLE NDOX"
\uA15D "YI SYLLABLE NDO"
\uA15E "YI SYLLABLE NDOP"
\uA15F "YI SYLLABLE NDEX"
\uA160 "YI SYLLABLE NDE"
\uA161 "YI SYLLABLE NDEP"
\uA162 "YI SYLLABLE NDUT"
\uA163 "YI SYLLABLE NDUX"
\uA164 "YI SYLLABLE NDU"
\uA165 "YI SYLLABLE NDUP"
\uA166 "YI SYLLABLE NDURX"
\uA167 "YI SYLLABLE NDUR"
\uA168 "YI SYLLABLE HNIT"
\uA169 "YI SYLLABLE HNIX"
\uA16A "YI SYLLABLE HNI"
\uA16B "YI SYLLABLE HNIP"
\uA16C "YI SYLLABLE HNIET"
\uA16D "YI SYLLABLE HNIEX"
\uA16E "YI SYLLABLE HNIE"
\uA16F "YI SYLLABLE HNIEP"
\uA170 "YI SYLLABLE HNAT"
\uA171 "YI SYLLABLE HNAX"
\uA172 "YI SYLLABLE HNA"
\uA173 "YI SYLLABLE HNAP"
\uA174 "YI SYLLABLE HNUOX"
\uA175 "YI SYLLABLE HNUO"
\uA176 "YI SYLLABLE HNOT"
\uA177 "YI SYLLABLE HNOX"
\uA178 "YI SYLLABLE HNOP"
\uA179 "YI SYLLABLE HNEX"
\uA17A "YI SYLLABLE HNE"
\uA17B "YI SYLLABLE HNEP"
\uA17C "YI SYLLABLE HNUT"
\uA17D "YI SYLLABLE NIT"
\uA17E "YI SYLLABLE NIX"
\uA17F "YI SYLLABLE NI"
\uA180 "YI SYLLABLE NIP"
\uA181 "YI SYLLABLE NIEX"
\uA182 "YI SYLLABLE NIE"
\uA183 "YI SYLLABLE NIEP"
\uA184 "YI SYLLABLE NAX"
\uA185 "YI SYLLABLE NA"
\uA186 "YI SYLLABLE NAP"
\uA187 "YI SYLLABLE NUOX"
\uA188 "YI SYLLABLE NUO"
\uA189 "YI SYLLABLE NUOP"
\uA18A "YI SYLLABLE NOT"
\uA18B "YI SYLLABLE NOX"
\uA18C "YI SYLLABLE NO"
\uA18D "YI SYLLABLE NOP"
\uA18E "YI SYLLABLE NEX"
\uA18F "YI SYLLABLE NE"
\uA190 "YI SYLLABLE NEP"
\uA191 "YI SYLLABLE NUT"
\uA192 "YI SYLLABLE NUX"
\uA193 "YI SYLLABLE NU"
\uA194 "YI SYLLABLE NUP"
\uA195 "YI SYLLABLE NURX"
\uA196 "YI SYLLABLE NUR"
\uA197 "YI SYLLABLE HLIT"
\uA198 "YI SYLLABLE HLIX"
\uA199 "YI SYLLABLE HLI"
\uA19A "YI SYLLABLE HLIP"
\uA19B "YI SYLLABLE HLIEX"
\uA19C "YI SYLLABLE HLIE"
\uA19D "YI SYLLABLE HLIEP"
\uA19E "YI SYLLABLE HLAT"
\uA19F "YI SYLLABLE HLAX"
\uA1A0 "YI SYLLABLE HLA"
\uA1A1 "YI SYLLABLE HLAP"
\uA1A2 "YI SYLLABLE HLUOX"
\uA1A3 "YI SYLLABLE HLUO"
\uA1A4 "YI SYLLABLE HLUOP"
\uA1A5 "YI SYLLABLE HLOX"
\uA1A6 "YI SYLLABLE HLO"
\uA1A7 "YI SYLLABLE HLOP"
\uA1A8 "YI SYLLABLE HLEX"
\uA1A9 "YI SYLLABLE HLE"
\uA1AA "YI SYLLABLE HLEP"
\uA1AB "YI SYLLABLE HLUT"
\uA1AC "YI SYLLABLE HLUX"
\uA1AD "YI SYLLABLE HLU"
\uA1AE "YI SYLLABLE HLUP"
\uA1AF "YI SYLLABLE HLURX"
\uA1B0 "YI SYLLABLE HLUR"
\uA1B1 "YI SYLLABLE HLYT"
\uA1B2 "YI SYLLABLE HLYX"
\uA1B3 "YI SYLLABLE HLY"
\uA1B4 "YI SYLLABLE HLYP"
\uA1B5 "YI SYLLABLE HLYRX"
\uA1B6 "YI SYLLABLE HLYR"
\uA1B7 "YI SYLLABLE LIT"
\uA1B8 "YI SYLLABLE LIX"
\uA1B9 "YI SYLLABLE LI"
\uA1BA "YI SYLLABLE LIP"
\uA1BB "YI SYLLABLE LIET"
\uA1BC "YI SYLLABLE LIEX"
\uA1BD "YI SYLLABLE LIE"
\uA1BE "YI SYLLABLE LIEP"
\uA1BF "YI SYLLABLE LAT"
\uA1C0 "YI SYLLABLE LAX"
\uA1C1 "YI SYLLABLE LA"
\uA1C2 "YI SYLLABLE LAP"
\uA1C3 "YI SYLLABLE LUOT"
\uA1C4 "YI SYLLABLE LUOX"
\uA1C5 "YI SYLLABLE LUO"
\uA1C6 "YI SYLLABLE LUOP"
\uA1C7 "YI SYLLABLE LOT"
\uA1C8 "YI SYLLABLE LOX"
\uA1C9 "YI SYLLABLE LO"
\uA1CA "YI SYLLABLE LOP"
\uA1CB "YI SYLLABLE LEX"
\uA1CC "YI SYLLABLE LE"
\uA1CD "YI SYLLABLE LEP"
\uA1CE "YI SYLLABLE LUT"
\uA1CF "YI SYLLABLE LUX"
\uA1D0 "YI SYLLABLE LU"
\uA1D1 "YI SYLLABLE LUP"
\uA1D2 "YI SYLLABLE LURX"
\uA1D3 "YI SYLLABLE LUR"
\uA1D4 "YI SYLLABLE LYT"
\uA1D5 "YI SYLLABLE LYX"
\uA1D6 "YI SYLLABLE LY"
\uA1D7 "YI SYLLABLE LYP"
\uA1D8 "YI SYLLABLE LYRX"
\uA1D9 "YI SYLLABLE LYR"
\uA1DA "YI SYLLABLE GIT"
\uA1DB "YI SYLLABLE GIX"
\uA1DC "YI SYLLABLE GI"
\uA1DD "YI SYLLABLE GIP"
\uA1DE "YI SYLLABLE GIET"
\uA1DF "YI SYLLABLE GIEX"
\uA1E0 "YI SYLLABLE GIE"
\uA1E1 "YI SYLLABLE GIEP"
\uA1E2 "YI SYLLABLE GAT"
\uA1E3 "YI SYLLABLE GAX"
\uA1E4 "YI SYLLABLE GA"
\uA1E5 "YI SYLLABLE GAP"
\uA1E6 "YI SYLLABLE GUOT"
\uA1E7 "YI SYLLABLE GUOX"
\uA1E8 "YI SYLLABLE GUO"
\uA1E9 "YI SYLLABLE GUOP"
\uA1EA "YI SYLLABLE GOT"
\uA1EB "YI SYLLABLE GOX"
\uA1EC "YI SYLLABLE GO"
\uA1ED "YI SYLLABLE GOP"
\uA1EE "YI SYLLABLE GET"
\uA1EF "YI SYLLABLE GEX"
\uA1F0 "YI SYLLABLE GE"
\uA1F1 "YI SYLLABLE GEP"
\uA1F2 "YI SYLLABLE GUT"
\uA1F3 "YI SYLLABLE GUX"
\uA1F4 "YI SYLLABLE GU"
\uA1F5 "YI SYLLABLE GUP"
\uA1F6 "YI SYLLABLE GURX"
\uA1F7 "YI SYLLABLE GUR"
\uA1F8 "YI SYLLABLE KIT"
\uA1F9 "YI SYLLABLE KIX"
\uA1FA "YI SYLLABLE KI"
\uA1FB "YI SYLLABLE KIP"
\uA1FC "YI SYLLABLE KIEX"
\uA1FD "YI SYLLABLE KIE"
\uA1FE "YI SYLLABLE KIEP"
\uA1FF "YI SYLLABLE KAT"
\uA200 "YI SYLLABLE KAX"
\uA201 "YI SYLLABLE KA"
\uA202 "YI SYLLABLE KAP"
\uA203 "YI SYLLABLE KUOX"
\uA204 "YI SYLLABLE KUO"
\uA205 "YI SYLLABLE KUOP"
\uA206 "YI SYLLABLE KOT"
\uA207 "YI SYLLABLE KOX"
\uA208 "YI SYLLABLE KO"
\uA209 "YI SYLLABLE KOP"
\uA20A "YI SYLLABLE KET"
\uA20B "YI SYLLABLE KEX"
\uA20C "YI SYLLABLE KE"
\uA20D "YI SYLLABLE KEP"
\uA20E "YI SYLLABLE KUT"
\uA20F "YI SYLLABLE KUX"
\uA210 "YI SYLLABLE KU"
\uA211 "YI SYLLABLE KUP"
\uA212 "YI SYLLABLE KURX"
\uA213 "YI SYLLABLE KUR"
\uA214 "YI SYLLABLE GGIT"
\uA215 "YI SYLLABLE GGIX"
\uA216 "YI SYLLABLE GGI"
\uA217 "YI SYLLABLE GGIEX"
\uA218 "YI SYLLABLE GGIE"
\uA219 "YI SYLLABLE GGIEP"
\uA21A "YI SYLLABLE GGAT"
\uA21B "YI SYLLABLE GGAX"
\uA21C "YI SYLLABLE GGA"
\uA21D "YI SYLLABLE GGAP"
\uA21E "YI SYLLABLE GGUOT"
\uA21F "YI SYLLABLE GGUOX"
\uA220 "YI SYLLABLE GGUO"
\uA221 "YI SYLLABLE GGUOP"
\uA222 "YI SYLLABLE GGOT"
\uA223 "YI SYLLABLE GGOX"
\uA224 "YI SYLLABLE GGO"
\uA225 "YI SYLLABLE GGOP"
\uA226 "YI SYLLABLE GGET"
\uA227 "YI SYLLABLE GGEX"
\uA228 "YI SYLLABLE GGE"
\uA229 "YI SYLLABLE GGEP"
\uA22A "YI SYLLABLE GGUT"
\uA22B "YI SYLLABLE GGUX"
\uA22C "YI SYLLABLE GGU"
\uA22D "YI SYLLABLE GGUP"
\uA22E "YI SYLLABLE GGURX"
\uA22F "YI SYLLABLE GGUR"
\uA230 "YI SYLLABLE MGIEX"
\uA231 "YI SYLLABLE MGIE"
\uA232 "YI SYLLABLE MGAT"
\uA233 "YI SYLLABLE MGAX"
\uA234 "YI SYLLABLE MGA"
\uA235 "YI SYLLABLE MGAP"
\uA236 "YI SYLLABLE MGUOX"
\uA237 "YI SYLLABLE MGUO"
\uA238 "YI SYLLABLE MGUOP"
\uA239 "YI SYLLABLE MGOT"
\uA23A "YI SYLLABLE MGOX"
\uA23B "YI SYLLABLE MGO"
\uA23C "YI SYLLABLE MGOP"
\uA23D "YI SYLLABLE MGEX"
\uA23E "YI SYLLABLE MGE"
\uA23F "YI SYLLABLE MGEP"
\uA240 "YI SYLLABLE MGUT"
\uA241 "YI SYLLABLE MGUX"
\uA242 "YI SYLLABLE MGU"
\uA243 "YI SYLLABLE MGUP"
\uA244 "YI SYLLABLE MGURX"
\uA245 "YI SYLLABLE MGUR"
\uA246 "YI SYLLABLE HXIT"
\uA247 "YI SYLLABLE HXIX"
\uA248 "YI SYLLABLE HXI"
\uA249 "YI SYLLABLE HXIP"
\uA24A "YI SYLLABLE HXIET"
\uA24B "YI SYLLABLE HXIEX"
\uA24C "YI SYLLABLE HXIE"
\uA24D "YI SYLLABLE HXIEP"
\uA24E "YI SYLLABLE HXAT"
\uA24F "YI SYLLABLE HXAX"
\uA250 "YI SYLLABLE HXA"
\uA251 "YI SYLLABLE HXAP"
\uA252 "YI SYLLABLE HXUOT"
\uA253 "YI SYLLABLE HXUOX"
\uA254 "YI SYLLABLE HXUO"
\uA255 "YI SYLLABLE HXUOP"
\uA256 "YI SYLLABLE HXOT"
\uA257 "YI SYLLABLE HXOX"
\uA258 "YI SYLLABLE HXO"
\uA259 "YI SYLLABLE HXOP"
\uA25A "YI SYLLABLE HXEX"
\uA25B "YI SYLLABLE HXE"
\uA25C "YI SYLLABLE HXEP"
\uA25D "YI SYLLABLE NGIEX"
\uA25E "YI SYLLABLE NGIE"
\uA25F "YI SYLLABLE NGIEP"
\uA260 "YI SYLLABLE NGAT"
\uA261 "YI SYLLABLE NGAX"
\uA262 "YI SYLLABLE NGA"
\uA263 "YI SYLLABLE NGAP"
\uA264 "YI SYLLABLE NGUOT"
\uA265 "YI SYLLABLE NGUOX"
\uA266 "YI SYLLABLE NGUO"
\uA267 "YI SYLLABLE NGOT"
\uA268 "YI SYLLABLE NGOX"
\uA269 "YI SYLLABLE NGO"
\uA26A "YI SYLLABLE NGOP"
\uA26B "YI SYLLABLE NGEX"
\uA26C "YI SYLLABLE NGE"
\uA26D "YI SYLLABLE NGEP"
\uA26E "YI SYLLABLE HIT"
\uA26F "YI SYLLABLE HIEX"
\uA270 "YI SYLLABLE HIE"
\uA271 "YI SYLLABLE HAT"
\uA272 "YI SYLLABLE HAX"
\uA273 "YI SYLLABLE HA"
\uA274 "YI SYLLABLE HAP"
\uA275 "YI SYLLABLE HUOT"
\uA276 "YI SYLLABLE HUOX"
\uA277 "YI SYLLABLE HUO"
\uA278 "YI SYLLABLE HUOP"
\uA279 "YI SYLLABLE HOT"
\uA27A "YI SYLLABLE HOX"
\uA27B "YI SYLLABLE HO"
\uA27C "YI SYLLABLE HOP"
\uA27D "YI SYLLABLE HEX"
\uA27E "YI SYLLABLE HE"
\uA27F "YI SYLLABLE HEP"
\uA280 "YI SYLLABLE WAT"
\uA281 "YI SYLLABLE WAX"
\uA282 "YI SYLLABLE WA"
\uA283 "YI SYLLABLE WAP"
\uA284 "YI SYLLABLE WUOX"
\uA285 "YI SYLLABLE WUO"
\uA286 "YI SYLLABLE WUOP"
\uA287 "YI SYLLABLE WOX"
\uA288 "YI SYLLABLE WO"
\uA289 "YI SYLLABLE WOP"
\uA28A "YI SYLLABLE WEX"
\uA28B "YI SYLLABLE WE"
\uA28C "YI SYLLABLE WEP"
\uA28D "YI SYLLABLE ZIT"
\uA28E "YI SYLLABLE ZIX"
\uA28F "YI SYLLABLE ZI"
\uA290 "YI SYLLABLE ZIP"
\uA291 "YI SYLLABLE ZIEX"
\uA292 "YI SYLLABLE ZIE"
\uA293 "YI SYLLABLE ZIEP"
\uA294 "YI SYLLABLE ZAT"
\uA295 "YI SYLLABLE ZAX"
\uA296 "YI SYLLABLE ZA"
\uA297 "YI SYLLABLE ZAP"
\uA298 "YI SYLLABLE ZUOX"
\uA299 "YI SYLLABLE ZUO"
\uA29A "YI SYLLABLE ZUOP"
\uA29B "YI SYLLABLE ZOT"
\uA29C "YI SYLLABLE ZOX"
\uA29D "YI SYLLABLE ZO"
\uA29E "YI SYLLABLE ZOP"
\uA29F "YI SYLLABLE ZEX"
\uA2A0 "YI SYLLABLE ZE"
\uA2A1 "YI SYLLABLE ZEP"
\uA2A2 "YI SYLLABLE ZUT"
\uA2A3 "YI SYLLABLE ZUX"
\uA2A4 "YI SYLLABLE ZU"
\uA2A5 "YI SYLLABLE ZUP"
\uA2A6 "YI SYLLABLE ZURX"
\uA2A7 "YI SYLLABLE ZUR"
\uA2A8 "YI SYLLABLE ZYT"
\uA2A9 "YI SYLLABLE ZYX"
\uA2AA "YI SYLLABLE ZY"
\uA2AB "YI SYLLABLE ZYP"
\uA2AC "YI SYLLABLE ZYRX"
\uA2AD "YI SYLLABLE ZYR"
\uA2AE "YI SYLLABLE CIT"
\uA2AF "YI SYLLABLE CIX"
\uA2B0 "YI SYLLABLE CI"
\uA2B1 "YI SYLLABLE CIP"
\uA2B2 "YI SYLLABLE CIET"
\uA2B3 "YI SYLLABLE CIEX"
\uA2B4 "YI SYLLABLE CIE"
\uA2B5 "YI SYLLABLE CIEP"
\uA2B6 "YI SYLLABLE CAT"
\uA2B7 "YI SYLLABLE CAX"
\uA2B8 "YI SYLLABLE CA"
\uA2B9 "YI SYLLABLE CAP"
\uA2BA "YI SYLLABLE CUOX"
\uA2BB "YI SYLLABLE CUO"
\uA2BC "YI SYLLABLE CUOP"
\uA2BD "YI SYLLABLE COT"
\uA2BE "YI SYLLABLE COX"
\uA2BF "YI SYLLABLE CO"
\uA2C0 "YI SYLLABLE COP"
\uA2C1 "YI SYLLABLE CEX"
\uA2C2 "YI SYLLABLE CE"
\uA2C3 "YI SYLLABLE CEP"
\uA2C4 "YI SYLLABLE CUT"
\uA2C5 "YI SYLLABLE CUX"
\uA2C6 "YI SYLLABLE CU"
\uA2C7 "YI SYLLABLE CUP"
\uA2C8 "YI SYLLABLE CURX"
\uA2C9 "YI SYLLABLE CUR"
\uA2CA "YI SYLLABLE CYT"
\uA2CB "YI SYLLABLE CYX"
\uA2CC "YI SYLLABLE CY"
\uA2CD "YI SYLLABLE CYP"
\uA2CE "YI SYLLABLE CYRX"
\uA2CF "YI SYLLABLE CYR"
\uA2D0 "YI SYLLABLE ZZIT"
\uA2D1 "YI SYLLABLE ZZIX"
\uA2D2 "YI SYLLABLE ZZI"
\uA2D3 "YI SYLLABLE ZZIP"
\uA2D4 "YI SYLLABLE ZZIET"
\uA2D5 "YI SYLLABLE ZZIEX"
\uA2D6 "YI SYLLABLE ZZIE"
\uA2D7 "YI SYLLABLE ZZIEP"
\uA2D8 "YI SYLLABLE ZZAT"
\uA2D9 "YI SYLLABLE ZZAX"
\uA2DA "YI SYLLABLE ZZA"
\uA2DB "YI SYLLABLE ZZAP"
\uA2DC "YI SYLLABLE ZZOX"
\uA2DD "YI SYLLABLE ZZO"
\uA2DE "YI SYLLABLE ZZOP"
\uA2DF "YI SYLLABLE ZZEX"
\uA2E0 "YI SYLLABLE ZZE"
\uA2E1 "YI SYLLABLE ZZEP"
\uA2E2 "YI SYLLABLE ZZUX"
\uA2E3 "YI SYLLABLE ZZU"
\uA2E4 "YI SYLLABLE ZZUP"
\uA2E5 "YI SYLLABLE ZZURX"
\uA2E6 "YI SYLLABLE ZZUR"
\uA2E7 "YI SYLLABLE ZZYT"
\uA2E8 "YI SYLLABLE ZZYX"
\uA2E9 "YI SYLLABLE ZZY"
\uA2EA "YI SYLLABLE ZZYP"
\uA2EB "YI SYLLABLE ZZYRX"
\uA2EC "YI SYLLABLE ZZYR"
\uA2ED "YI SYLLABLE NZIT"
\uA2EE "YI SYLLABLE NZIX"
\uA2EF "YI SYLLABLE NZI"
\uA2F0 "YI SYLLABLE NZIP"
\uA2F1 "YI SYLLABLE NZIEX"
\uA2F2 "YI SYLLABLE NZIE"
\uA2F3 "YI SYLLABLE NZIEP"
\uA2F4 "YI SYLLABLE NZAT"
\uA2F5 "YI SYLLABLE NZAX"
\uA2F6 "YI SYLLABLE NZA"
\uA2F7 "YI SYLLABLE NZAP"
\uA2F8 "YI SYLLABLE NZUOX"
\uA2F9 "YI SYLLABLE NZUO"
\uA2FA "YI SYLLABLE NZOX"
\uA2FB "YI SYLLABLE NZOP"
\uA2FC "YI SYLLABLE NZEX"
\uA2FD "YI SYLLABLE NZE"
\uA2FE "YI SYLLABLE NZUX"
\uA2FF "YI SYLLABLE NZU"
\uA300 "YI SYLLABLE NZUP"
\uA301 "YI SYLLABLE NZURX"
\uA302 "YI SYLLABLE NZUR"
\uA303 "YI SYLLABLE NZYT"
\uA304 "YI SYLLABLE NZYX"
\uA305 "YI SYLLABLE NZY"
\uA306 "YI SYLLABLE NZYP"
\uA307 "YI SYLLABLE NZYRX"
\uA308 "YI SYLLABLE NZYR"
\uA309 "YI SYLLABLE SIT"
\uA30A "YI SYLLABLE SIX"
\uA30B "YI SYLLABLE SI"
\uA30C "YI SYLLABLE SIP"
\uA30D "YI SYLLABLE SIEX"
\uA30E "YI SYLLABLE SIE"
\uA30F "YI SYLLABLE SIEP"
\uA310 "YI SYLLABLE SAT"
\uA311 "YI SYLLABLE SAX"
\uA312 "YI SYLLABLE SA"
\uA313 "YI SYLLABLE SAP"
\uA314 "YI SYLLABLE SUOX"
\uA315 "YI SYLLABLE SUO"
\uA316 "YI SYLLABLE SUOP"
\uA317 "YI SYLLABLE SOT"
\uA318 "YI SYLLABLE SOX"
\uA319 "YI SYLLABLE SO"
\uA31A "YI SYLLABLE SOP"
\uA31B "YI SYLLABLE SEX"
\uA31C "YI SYLLABLE SE"
\uA31D "YI SYLLABLE SEP"
\uA31E "YI SYLLABLE SUT"
\uA31F "YI SYLLABLE SUX"
\uA320 "YI SYLLABLE SU"
\uA321 "YI SYLLABLE SUP"
\uA322 "YI SYLLABLE SURX"
\uA323 "YI SYLLABLE SUR"
\uA324 "YI SYLLABLE SYT"
\uA325 "YI SYLLABLE SYX"
\uA326 "YI SYLLABLE SY"
\uA327 "YI SYLLABLE SYP"
\uA328 "YI SYLLABLE SYRX"
\uA329 "YI SYLLABLE SYR"
\uA32A "YI SYLLABLE SSIT"
\uA32B "YI SYLLABLE SSIX"
\uA32C "YI SYLLABLE SSI"
\uA32D "YI SYLLABLE SSIP"
\uA32E "YI SYLLABLE SSIEX"
\uA32F "YI SYLLABLE SSIE"
\uA330 "YI SYLLABLE SSIEP"
\uA331 "YI SYLLABLE SSAT"
\uA332 "YI SYLLABLE SSAX"
\uA333 "YI SYLLABLE SSA"
\uA334 "YI SYLLABLE SSAP"
\uA335 "YI SYLLABLE SSOT"
\uA336 "YI SYLLABLE SSOX"
\uA337 "YI SYLLABLE SSO"
\uA338 "YI SYLLABLE SSOP"
\uA339 "YI SYLLABLE SSEX"
\uA33A "YI SYLLABLE SSE"
\uA33B "YI SYLLABLE SSEP"
\uA33C "YI SYLLABLE SSUT"
\uA33D "YI SYLLABLE SSUX"
\uA33E "YI SYLLABLE SSU"
\uA33F "YI SYLLABLE SSUP"
\uA340 "YI SYLLABLE SSYT"
\uA341 "YI SYLLABLE SSYX"
\uA342 "YI SYLLABLE SSY"
\uA343 "YI SYLLABLE SSYP"
\uA344 "YI SYLLABLE SSYRX"
\uA345 "YI SYLLABLE SSYR"
\uA346 "YI SYLLABLE ZHAT"
\uA347 "YI SYLLABLE ZHAX"
\uA348 "YI SYLLABLE ZHA"
\uA349 "YI SYLLABLE ZHAP"
\uA34A "YI SYLLABLE ZHUOX"
\uA34B "YI SYLLABLE ZHUO"
\uA34C "YI SYLLABLE ZHUOP"
\uA34D "YI SYLLABLE ZHOT"
\uA34E "YI SYLLABLE ZHOX"
\uA34F "YI SYLLABLE ZHO"
\uA350 "YI SYLLABLE ZHOP"
\uA351 "YI SYLLABLE ZHET"
\uA352 "YI SYLLABLE ZHEX"
\uA353 "YI SYLLABLE ZHE"
\uA354 "YI SYLLABLE ZHEP"
\uA355 "YI SYLLABLE ZHUT"
\uA356 "YI SYLLABLE ZHUX"
\uA357 "YI SYLLABLE ZHU"
\uA358 "YI SYLLABLE ZHUP"
\uA359 "YI SYLLABLE ZHURX"
\uA35A "YI SYLLABLE ZHUR"
\uA35B "YI SYLLABLE ZHYT"
\uA35C "YI SYLLABLE ZHYX"
\uA35D "YI SYLLABLE ZHY"
\uA35E "YI SYLLABLE ZHYP"
\uA35F "YI SYLLABLE ZHYRX"
\uA360 "YI SYLLABLE ZHYR"
\uA361 "YI SYLLABLE CHAT"
\uA362 "YI SYLLABLE CHAX"
\uA363 "YI SYLLABLE CHA"
\uA364 "YI SYLLABLE CHAP"
\uA365 "YI SYLLABLE CHUOT"
\uA366 "YI SYLLABLE CHUOX"
\uA367 "YI SYLLABLE CHUO"
\uA368 "YI SYLLABLE CHUOP"
\uA369 "YI SYLLABLE CHOT"
\uA36A "YI SYLLABLE CHOX"
\uA36B "YI SYLLABLE CHO"
\uA36C "YI SYLLABLE CHOP"
\uA36D "YI SYLLABLE CHET"
\uA36E "YI SYLLABLE CHEX"
\uA36F "YI SYLLABLE CHE"
\uA370 "YI SYLLABLE CHEP"
\uA371 "YI SYLLABLE CHUX"
\uA372 "YI SYLLABLE CHU"
\uA373 "YI SYLLABLE CHUP"
\uA374 "YI SYLLABLE CHURX"
\uA375 "YI SYLLABLE CHUR"
\uA376 "YI SYLLABLE CHYT"
\uA377 "YI SYLLABLE CHYX"
\uA378 "YI SYLLABLE CHY"
\uA379 "YI SYLLABLE CHYP"
\uA37A "YI SYLLABLE CHYRX"
\uA37B "YI SYLLABLE CHYR"
\uA37C "YI SYLLABLE RRAX"
\uA37D "YI SYLLABLE RRA"
\uA37E "YI SYLLABLE RRUOX"
\uA37F "YI SYLLABLE RRUO"
\uA380 "YI SYLLABLE RROT"
\uA381 "YI SYLLABLE RROX"
\uA382 "YI SYLLABLE RRO"
\uA383 "YI SYLLABLE RROP"
\uA384 "YI SYLLABLE RRET"
\uA385 "YI SYLLABLE RREX"
\uA386 "YI SYLLABLE RRE"
\uA387 "YI SYLLABLE RREP"
\uA388 "YI SYLLABLE RRUT"
\uA389 "YI SYLLABLE RRUX"
\uA38A "YI SYLLABLE RRU"
\uA38B "YI SYLLABLE RRUP"
\uA38C "YI SYLLABLE RRURX"
\uA38D "YI SYLLABLE RRUR"
\uA38E "YI SYLLABLE RRYT"
\uA38F "YI SYLLABLE RRYX"
\uA390 "YI SYLLABLE RRY"
\uA391 "YI SYLLABLE RRYP"
\uA392 "YI SYLLABLE RRYRX"
\uA393 "YI SYLLABLE RRYR"
\uA394 "YI SYLLABLE NRAT"
\uA395 "YI SYLLABLE NRAX"
\uA396 "YI SYLLABLE NRA"
\uA397 "YI SYLLABLE NRAP"
\uA398 "YI SYLLABLE NROX"
\uA399 "YI SYLLABLE NRO"
\uA39A "YI SYLLABLE NROP"
\uA39B "YI SYLLABLE NRET"
\uA39C "YI SYLLABLE NREX"
\uA39D "YI SYLLABLE NRE"
\uA39E "YI SYLLABLE NREP"
\uA39F "YI SYLLABLE NRUT"
\uA3A0 "YI SYLLABLE NRUX"
\uA3A1 "YI SYLLABLE NRU"
\uA3A2 "YI SYLLABLE NRUP"
\uA3A3 "YI SYLLABLE NRURX"
\uA3A4 "YI SYLLABLE NRUR"
\uA3A5 "YI SYLLABLE NRYT"
\uA3A6 "YI SYLLABLE NRYX"
\uA3A7 "YI SYLLABLE NRY"
\uA3A8 "YI SYLLABLE NRYP"
\uA3A9 "YI SYLLABLE NRYRX"
\uA3AA "YI SYLLABLE NRYR"
\uA3AB "YI SYLLABLE SHAT"
\uA3AC "YI SYLLABLE SHAX"
\uA3AD "YI SYLLABLE SHA"
\uA3AE "YI SYLLABLE SHAP"
\uA3AF "YI SYLLABLE SHUOX"
\uA3B0 "YI SYLLABLE SHUO"
\uA3B1 "YI SYLLABLE SHUOP"
\uA3B2 "YI SYLLABLE SHOT"
\uA3B3 "YI SYLLABLE SHOX"
\uA3B4 "YI SYLLABLE SHO"
\uA3B5 "YI SYLLABLE SHOP"
\uA3B6 "YI SYLLABLE SHET"
\uA3B7 "YI SYLLABLE SHEX"
\uA3B8 "YI SYLLABLE SHE"
\uA3B9 "YI SYLLABLE SHEP"
\uA3BA "YI SYLLABLE SHUT"
\uA3BB "YI SYLLABLE SHUX"
\uA3BC "YI SYLLABLE SHU"
\uA3BD "YI SYLLABLE SHUP"
\uA3BE "YI SYLLABLE SHURX"
\uA3BF "YI SYLLABLE SHUR"
\uA3C0 "YI SYLLABLE SHYT"
\uA3C1 "YI SYLLABLE SHYX"
\uA3C2 "YI SYLLABLE SHY"
\uA3C3 "YI SYLLABLE SHYP"
\uA3C4 "YI SYLLABLE SHYRX"
\uA3C5 "YI SYLLABLE SHYR"
\uA3C6 "YI SYLLABLE RAT"
\uA3C7 "YI SYLLABLE RAX"
\uA3C8 "YI SYLLABLE RA"
\uA3C9 "YI SYLLABLE RAP"
\uA3CA "YI SYLLABLE RUOX"
\uA3CB "YI SYLLABLE RUO"
\uA3CC "YI SYLLABLE RUOP"
\uA3CD "YI SYLLABLE ROT"
\uA3CE "YI SYLLABLE ROX"
\uA3CF "YI SYLLABLE RO"
\uA3D0 "YI SYLLABLE ROP"
\uA3D1 "YI SYLLABLE REX"
\uA3D2 "YI SYLLABLE RE"
\uA3D3 "YI SYLLABLE REP"
\uA3D4 "YI SYLLABLE RUT"
\uA3D5 "YI SYLLABLE RUX"
\uA3D6 "YI SYLLABLE RU"
\uA3D7 "YI SYLLABLE RUP"
\uA3D8 "YI SYLLABLE RURX"
\uA3D9 "YI SYLLABLE RUR"
\uA3DA "YI SYLLABLE RYT"
\uA3DB "YI SYLLABLE RYX"
\uA3DC "YI SYLLABLE RY"
\uA3DD "YI SYLLABLE RYP"
\uA3DE "YI SYLLABLE RYRX"
\uA3DF "YI SYLLABLE RYR"
\uA3E0 "YI SYLLABLE JIT"
\uA3E1 "YI SYLLABLE JIX"
\uA3E2 "YI SYLLABLE JI"
\uA3E3 "YI SYLLABLE JIP"
\uA3E4 "YI SYLLABLE JIET"
\uA3E5 "YI SYLLABLE JIEX"
\uA3E6 "YI SYLLABLE JIE"
\uA3E7 "YI SYLLABLE JIEP"
\uA3E8 "YI SYLLABLE JUOT"
\uA3E9 "YI SYLLABLE JUOX"
\uA3EA "YI SYLLABLE JUO"
\uA3EB "YI SYLLABLE JUOP"
\uA3EC "YI SYLLABLE JOT"
\uA3ED "YI SYLLABLE JOX"
\uA3EE "YI SYLLABLE JO"
\uA3EF "YI SYLLABLE JOP"
\uA3F0 "YI SYLLABLE JUT"
\uA3F1 "YI SYLLABLE JUX"
\uA3F2 "YI SYLLABLE JU"
\uA3F3 "YI SYLLABLE JUP"
\uA3F4 "YI SYLLABLE JURX"
\uA3F5 "YI SYLLABLE JUR"
\uA3F6 "YI SYLLABLE JYT"
\uA3F7 "YI SYLLABLE JYX"
\uA3F8 "YI SYLLABLE JY"
\uA3F9 "YI SYLLABLE JYP"
\uA3FA "YI SYLLABLE JYRX"
\uA3FB "YI SYLLABLE JYR"
\uA3FC "YI SYLLABLE QIT"
\uA3FD "YI SYLLABLE QIX"
\uA3FE "YI SYLLABLE QI"
\uA3FF "YI SYLLABLE QIP"
\uA400 "YI SYLLABLE QIET"
\uA401 "YI SYLLABLE QIEX"
\uA402 "YI SYLLABLE QIE"
\uA403 "YI SYLLABLE QIEP"
\uA404 "YI SYLLABLE QUOT"
\uA405 "YI SYLLABLE QUOX"
\uA406 "YI SYLLABLE QUO"
\uA407 "YI SYLLABLE QUOP"
\uA408 "YI SYLLABLE QOT"
\uA409 "YI SYLLABLE QOX"
\uA40A "YI SYLLABLE QO"
\uA40B "YI SYLLABLE QOP"
\uA40C "YI SYLLABLE QUT"
\uA40D "YI SYLLABLE QUX"
\uA40E "YI SYLLABLE QU"
\uA40F "YI SYLLABLE QUP"
\uA410 "YI SYLLABLE QURX"
\uA411 "YI SYLLABLE QUR"
\uA412 "YI SYLLABLE QYT"
\uA413 "YI SYLLABLE QYX"
\uA414 "YI SYLLABLE QY"
\uA415 "YI SYLLABLE QYP"
\uA416 "YI SYLLABLE QYRX"
\uA417 "YI SYLLABLE QYR"
\uA418 "YI SYLLABLE JJIT"
\uA419 "YI SYLLABLE JJIX"
\uA41A "YI SYLLABLE JJI"
\uA41B "YI SYLLABLE JJIP"
\uA41C "YI SYLLABLE JJIET"
\uA41D "YI SYLLABLE JJIEX"
\uA41E "YI SYLLABLE JJIE"
\uA41F "YI SYLLABLE JJIEP"
\uA420 "YI SYLLABLE JJUOX"
\uA421 "YI SYLLABLE JJUO"
\uA422 "YI SYLLABLE JJUOP"
\uA423 "YI SYLLABLE JJOT"
\uA424 "YI SYLLABLE JJOX"
\uA425 "YI SYLLABLE JJO"
\uA426 "YI SYLLABLE JJOP"
\uA427 "YI SYLLABLE JJUT"
\uA428 "YI SYLLABLE JJUX"
\uA429 "YI SYLLABLE JJU"
\uA42A "YI SYLLABLE JJUP"
\uA42B "YI SYLLABLE JJURX"
\uA42C "YI SYLLABLE JJUR"
\uA42D "YI SYLLABLE JJYT"
\uA42E "YI SYLLABLE JJYX"
\uA42F "YI SYLLABLE JJY"
\uA430 "YI SYLLABLE JJYP"
\uA431 "YI SYLLABLE NJIT"
\uA432 "YI SYLLABLE NJIX"
\uA433 "YI SYLLABLE NJI"
\uA434 "YI SYLLABLE NJIP"
\uA435 "YI SYLLABLE NJIET"
\uA436 "YI SYLLABLE NJIEX"
\uA437 "YI SYLLABLE NJIE"
\uA438 "YI SYLLABLE NJIEP"
\uA439 "YI SYLLABLE NJUOX"
\uA43A "YI SYLLABLE NJUO"
\uA43B "YI SYLLABLE NJOT"
\uA43C "YI SYLLABLE NJOX"
\uA43D "YI SYLLABLE NJO"
\uA43E "YI SYLLABLE NJOP"
\uA43F "YI SYLLABLE NJUX"
\uA440 "YI SYLLABLE NJU"
\uA441 "YI SYLLABLE NJUP"
\uA442 "YI SYLLABLE NJURX"
\uA443 "YI SYLLABLE NJUR"
\uA444 "YI SYLLABLE NJYT"
\uA445 "YI SYLLABLE NJYX"
\uA446 "YI SYLLABLE NJY"
\uA447 "YI SYLLABLE NJYP"
\uA448 "YI SYLLABLE NJYRX"
\uA449 "YI SYLLABLE NJYR"
\uA44A "YI SYLLABLE NYIT"
\uA44B "YI SYLLABLE NYIX"
\uA44C "YI SYLLABLE NYI"
\uA44D "YI SYLLABLE NYIP"
\uA44E "YI SYLLABLE NYIET"
\uA44F "YI SYLLABLE NYIEX"
\uA450 "YI SYLLABLE NYIE"
\uA451 "YI SYLLABLE NYIEP"
\uA452 "YI SYLLABLE NYUOX"
\uA453 "YI SYLLABLE NYUO"
\uA454 "YI SYLLABLE NYUOP"
\uA455 "YI SYLLABLE NYOT"
\uA456 "YI SYLLABLE NYOX"
\uA457 "YI SYLLABLE NYO"
\uA458 "YI SYLLABLE NYOP"
\uA459 "YI SYLLABLE NYUT"
\uA45A "YI SYLLABLE NYUX"
\uA45B "YI SYLLABLE NYU"
\uA45C "YI SYLLABLE NYUP"
\uA45D "YI SYLLABLE XIT"
\uA45E "YI SYLLABLE XIX"
\uA45F "YI SYLLABLE XI"
\uA460 "YI SYLLABLE XIP"
\uA461 "YI SYLLABLE XIET"
\uA462 "YI SYLLABLE XIEX"
\uA463 "YI SYLLABLE XIE"
\uA464 "YI SYLLABLE XIEP"
\uA465 "YI SYLLABLE XUOX"
\uA466 "YI SYLLABLE XUO"
\uA467 "YI SYLLABLE XOT"
\uA468 "YI SYLLABLE XOX"
\uA469 "YI SYLLABLE XO"
\uA46A "YI SYLLABLE XOP"
\uA46B "YI SYLLABLE XYT"
\uA46C "YI SYLLABLE XYX"
\uA46D "YI SYLLABLE XY"
\uA46E "YI SYLLABLE XYP"
\uA46F "YI SYLLABLE XYRX"
\uA470 "YI SYLLABLE XYR"
\uA471 "YI SYLLABLE YIT"
\uA472 "YI SYLLABLE YIX"
\uA473 "YI SYLLABLE YI"
\uA474 "YI SYLLABLE YIP"
\uA475 "YI SYLLABLE YIET"
\uA476 "YI SYLLABLE YIEX"
\uA477 "YI SYLLABLE YIE"
\uA478 "YI SYLLABLE YIEP"
\uA479 "YI SYLLABLE YUOT"
\uA47A "YI SYLLABLE YUOX"
\uA47B "YI SYLLABLE YUO"
\uA47C "YI SYLLABLE YUOP"
\uA47D "YI SYLLABLE YOT"
\uA47E "YI SYLLABLE YOX"
\uA47F "YI SYLLABLE YO"
\uA480 "YI SYLLABLE YOP"
\uA481 "YI SYLLABLE YUT"
\uA482 "YI SYLLABLE YUX"
\uA483 "YI SYLLABLE YU"
\uA484 "YI SYLLABLE YUP"
\uA485 "YI SYLLABLE YURX"
\uA486 "YI SYLLABLE YUR"
\uA487 "YI SYLLABLE YYT"
\uA488 "YI SYLLABLE YYX"
\uA489 "YI SYLLABLE YY"
\uA48A "YI SYLLABLE YYP"
\uA48B "YI SYLLABLE YYRX"
\uA48C "YI SYLLABLE YYR"
\uA490 "YI RADICAL QOT"
\uA491 "YI RADICAL LI"
\uA492 "YI RADICAL KIT"
\uA493 "YI RADICAL NYIP"
\uA494 "YI RADICAL CYP"
\uA495 "YI RADICAL SSI"
\uA496 "YI RADICAL GGOP"
\uA497 "YI RADICAL GEP"
\uA498 "YI RADICAL MI"
\uA499 "YI RADICAL HXIT"
\uA49A "YI RADICAL LYR"
\uA49B "YI RADICAL BBUT"
\uA49C "YI RADICAL MOP"
\uA49D "YI RADICAL YO"
\uA49E "YI RADICAL PUT"
\uA49F "YI RADICAL HXUO"
\uA4A0 "YI RADICAL TAT"
\uA4A1 "YI RADICAL GA"
\uA4A2 "YI RADICAL ZUP"
\uA4A3 "YI RADICAL CYT"
\uA4A4 "YI RADICAL DDUR"
\uA4A5 "YI RADICAL BUR"
\uA4A6 "YI RADICAL GGUO"
\uA4A7 "YI RADICAL NYOP"
\uA4A8 "YI RADICAL TU"
\uA4A9 "YI RADICAL OP"
\uA4AA "YI RADICAL JJUT"
\uA4AB "YI RADICAL ZOT"
\uA4AC "YI RADICAL PYT"
\uA4AD "YI RADICAL HMO"
\uA4AE "YI RADICAL YIT"
\uA4AF "YI RADICAL VUR"
\uA4B0 "YI RADICAL SHY"
\uA4B1 "YI RADICAL VEP"
\uA4B2 "YI RADICAL ZA"
\uA4B3 "YI RADICAL JO"
\uA4B4 "YI RADICAL NZUP"
\uA4B5 "YI RADICAL JJY"
\uA4B6 "YI RADICAL GOT"
\uA4B7 "YI RADICAL JJIE"
\uA4B8 "YI RADICAL WO"
\uA4B9 "YI RADICAL DU"
\uA4BA "YI RADICAL SHUR"
\uA4BB "YI RADICAL LIE"
\uA4BC "YI RADICAL CY"
\uA4BD "YI RADICAL CUOP"
\uA4BE "YI RADICAL CIP"
\uA4BF "YI RADICAL HXOP"
\uA4C0 "YI RADICAL SHAT"
\uA4C1 "YI RADICAL ZUR"
\uA4C2 "YI RADICAL SHOP"
\uA4C3 "YI RADICAL CHE"
\uA4C4 "YI RADICAL ZZIET"
\uA4C5 "YI RADICAL NBIE"
\uA4C6 "YI RADICAL KE"
\uA500 "VAI SYLLABLE EE"
\uA501 "VAI SYLLABLE EEN"
\uA502 "VAI SYLLABLE HEE"
\uA503 "VAI SYLLABLE WEE"
\uA504 "VAI SYLLABLE WEEN"
\uA505 "VAI SYLLABLE PEE"
\uA506 "VAI SYLLABLE BHEE"
\uA507 "VAI SYLLABLE BEE"
\uA508 "VAI SYLLABLE MBEE"
\uA509 "VAI SYLLABLE KPEE"
\uA50A "VAI SYLLABLE MGBEE"
\uA50B "VAI SYLLABLE GBEE"
\uA50C "VAI SYLLABLE FEE"
\uA50D "VAI SYLLABLE VEE"
\uA50E "VAI SYLLABLE TEE"
\uA50F "VAI SYLLABLE THEE"
\uA510 "VAI SYLLABLE DHEE"
\uA511 "VAI SYLLABLE DHHEE"
\uA512 "VAI SYLLABLE LEE"
\uA513 "VAI SYLLABLE REE"
\uA514 "VAI SYLLABLE DEE"
\uA515 "VAI SYLLABLE NDEE"
\uA516 "VAI SYLLABLE SEE"
\uA517 "VAI SYLLABLE SHEE"
\uA518 "VAI SYLLABLE ZEE"
\uA519 "VAI SYLLABLE ZHEE"
\uA51A "VAI SYLLABLE CEE"
\uA51B "VAI SYLLABLE JEE"
\uA51C "VAI SYLLABLE NJEE"
\uA51D "VAI SYLLABLE YEE"
\uA51E "VAI SYLLABLE KEE"
\uA51F "VAI SYLLABLE NGGEE"
\uA520 "VAI SYLLABLE GEE"
\uA521 "VAI SYLLABLE MEE"
\uA522 "VAI SYLLABLE NEE"
\uA523 "VAI SYLLABLE NYEE"
\uA524 "VAI SYLLABLE I"
\uA525 "VAI SYLLABLE IN"
\uA526 "VAI SYLLABLE HI"
\uA527 "VAI SYLLABLE HIN"
\uA528 "VAI SYLLABLE WI"
\uA529 "VAI SYLLABLE WIN"
\uA52A "VAI SYLLABLE PI"
\uA52B "VAI SYLLABLE BHI"
\uA52C "VAI SYLLABLE BI"
\uA52D "VAI SYLLABLE MBI"
\uA52E "VAI SYLLABLE KPI"
\uA52F "VAI SYLLABLE MGBI"
\uA530 "VAI SYLLABLE GBI"
\uA531 "VAI SYLLABLE FI"
\uA532 "VAI SYLLABLE VI"
\uA533 "VAI SYLLABLE TI"
\uA534 "VAI SYLLABLE THI"
\uA535 "VAI SYLLABLE DHI"
\uA536 "VAI SYLLABLE DHHI"
\uA537 "VAI SYLLABLE LI"
\uA538 "VAI SYLLABLE RI"
\uA539 "VAI SYLLABLE DI"
\uA53A "VAI SYLLABLE NDI"
\uA53B "VAI SYLLABLE SI"
\uA53C "VAI SYLLABLE SHI"
\uA53D "VAI SYLLABLE ZI"
\uA53E "VAI SYLLABLE ZHI"
\uA53F "VAI SYLLABLE CI"
\uA540 "VAI SYLLABLE JI"
\uA541 "VAI SYLLABLE NJI"
\uA542 "VAI SYLLABLE YI"
\uA543 "VAI SYLLABLE KI"
\uA544 "VAI SYLLABLE NGGI"
\uA545 "VAI SYLLABLE GI"
\uA546 "VAI SYLLABLE MI"
\uA547 "VAI SYLLABLE NI"
\uA548 "VAI SYLLABLE NYI"
\uA549 "VAI SYLLABLE A"
\uA54A "VAI SYLLABLE AN"
\uA54B "VAI SYLLABLE NGAN"
\uA54C "VAI SYLLABLE HA"
\uA54D "VAI SYLLABLE HAN"
\uA54E "VAI SYLLABLE WA"
\uA54F "VAI SYLLABLE WAN"
\uA550 "VAI SYLLABLE PA"
\uA551 "VAI SYLLABLE BHA"
\uA552 "VAI SYLLABLE BA"
\uA553 "VAI SYLLABLE MBA"
\uA554 "VAI SYLLABLE KPA"
\uA555 "VAI SYLLABLE KPAN"
\uA556 "VAI SYLLABLE MGBA"
\uA557 "VAI SYLLABLE GBA"
\uA558 "VAI SYLLABLE FA"
\uA559 "VAI SYLLABLE VA"
\uA55A "VAI SYLLABLE TA"
\uA55B "VAI SYLLABLE THA"
\uA55C "VAI SYLLABLE DHA"
\uA55D "VAI SYLLABLE DHHA"
\uA55E "VAI SYLLABLE LA"
\uA55F "VAI SYLLABLE RA"
\uA560 "VAI SYLLABLE DA"
\uA561 "VAI SYLLABLE NDA"
\uA562 "VAI SYLLABLE SA"
\uA563 "VAI SYLLABLE SHA"
\uA564 "VAI SYLLABLE ZA"
\uA565 "VAI SYLLABLE ZHA"
\uA566 "VAI SYLLABLE CA"
\uA567 "VAI SYLLABLE JA"
\uA568 "VAI SYLLABLE NJA"
\uA569 "VAI SYLLABLE YA"
\uA56A "VAI SYLLABLE KA"
\uA56B "VAI SYLLABLE KAN"
\uA56C "VAI SYLLABLE NGGA"
\uA56D "VAI SYLLABLE GA"
\uA56E "VAI SYLLABLE MA"
\uA56F "VAI SYLLABLE NA"
\uA570 "VAI SYLLABLE NYA"
\uA571 "VAI SYLLABLE OO"
\uA572 "VAI SYLLABLE OON"
\uA573 "VAI SYLLABLE HOO"
\uA574 "VAI SYLLABLE WOO"
\uA575 "VAI SYLLABLE WOON"
\uA576 "VAI SYLLABLE POO"
\uA577 "VAI SYLLABLE BHOO"
\uA578 "VAI SYLLABLE BOO"
\uA579 "VAI SYLLABLE MBOO"
\uA57A "VAI SYLLABLE KPOO"
\uA57B "VAI SYLLABLE MGBOO"
\uA57C "VAI SYLLABLE GBOO"
\uA57D "VAI SYLLABLE FOO"
\uA57E "VAI SYLLABLE VOO"
\uA57F "VAI SYLLABLE TOO"
\uA580 "VAI SYLLABLE THOO"
\uA581 "VAI SYLLABLE DHOO"
\uA582 "VAI SYLLABLE DHHOO"
\uA583 "VAI SYLLABLE LOO"
\uA584 "VAI SYLLABLE ROO"
\uA585 "VAI SYLLABLE DOO"
\uA586 "VAI SYLLABLE NDOO"
\uA587 "VAI SYLLABLE SOO"
\uA588 "VAI SYLLABLE SHOO"
\uA589 "VAI SYLLABLE ZOO"
\uA58A "VAI SYLLABLE ZHOO"
\uA58B "VAI SYLLABLE COO"
\uA58C "VAI SYLLABLE JOO"
\uA58D "VAI SYLLABLE NJOO"
\uA58E "VAI SYLLABLE YOO"
\uA58F "VAI SYLLABLE KOO"
\uA590 "VAI SYLLABLE NGGOO"
\uA591 "VAI SYLLABLE GOO"
\uA592 "VAI SYLLABLE MOO"
\uA593 "VAI SYLLABLE NOO"
\uA594 "VAI SYLLABLE NYOO"
\uA595 "VAI SYLLABLE U"
\uA596 "VAI SYLLABLE UN"
\uA597 "VAI SYLLABLE HU"
\uA598 "VAI SYLLABLE HUN"
\uA599 "VAI SYLLABLE WU"
\uA59A "VAI SYLLABLE WUN"
\uA59B "VAI SYLLABLE PU"
\uA59C "VAI SYLLABLE BHU"
\uA59D "VAI SYLLABLE BU"
\uA59E "VAI SYLLABLE MBU"
\uA59F "VAI SYLLABLE KPU"
\uA5A0 "VAI SYLLABLE MGBU"
\uA5A1 "VAI SYLLABLE GBU"
\uA5A2 "VAI SYLLABLE FU"
\uA5A3 "VAI SYLLABLE VU"
\uA5A4 "VAI SYLLABLE TU"
\uA5A5 "VAI SYLLABLE THU"
\uA5A6 "VAI SYLLABLE DHU"
\uA5A7 "VAI SYLLABLE DHHU"
\uA5A8 "VAI SYLLABLE LU"
\uA5A9 "VAI SYLLABLE RU"
\uA5AA "VAI SYLLABLE DU"
\uA5AB "VAI SYLLABLE NDU"
\uA5AC "VAI SYLLABLE SU"
\uA5AD "VAI SYLLABLE SHU"
\uA5AE "VAI SYLLABLE ZU"
\uA5AF "VAI SYLLABLE ZHU"
\uA5B0 "VAI SYLLABLE CU"
\uA5B1 "VAI SYLLABLE JU"
\uA5B2 "VAI SYLLABLE NJU"
\uA5B3 "VAI SYLLABLE YU"
\uA5B4 "VAI SYLLABLE KU"
\uA5B5 "VAI SYLLABLE NGGU"
\uA5B6 "VAI SYLLABLE GU"
\uA5B7 "VAI SYLLABLE MU"
\uA5B8 "VAI SYLLABLE NU"
\uA5B9 "VAI SYLLABLE NYU"
\uA5BA "VAI SYLLABLE O"
\uA5BB "VAI SYLLABLE ON"
\uA5BC "VAI SYLLABLE NGON"
\uA5BD "VAI SYLLABLE HO"
\uA5BE "VAI SYLLABLE HON"
\uA5BF "VAI SYLLABLE WO"
\uA5C0 "VAI SYLLABLE WON"
\uA5C1 "VAI SYLLABLE PO"
\uA5C2 "VAI SYLLABLE BHO"
\uA5C3 "VAI SYLLABLE BO"
\uA5C4 "VAI SYLLABLE MBO"
\uA5C5 "VAI SYLLABLE KPO"
\uA5C6 "VAI SYLLABLE MGBO"
\uA5C7 "VAI SYLLABLE GBO"
\uA5C8 "VAI SYLLABLE GBON"
\uA5C9 "VAI SYLLABLE FO"
\uA5CA "VAI SYLLABLE VO"
\uA5CB "VAI SYLLABLE TO"
\uA5CC "VAI SYLLABLE THO"
\uA5CD "VAI SYLLABLE DHO"
\uA5CE "VAI SYLLABLE DHHO"
\uA5CF "VAI SYLLABLE LO"
\uA5D0 "VAI SYLLABLE RO"
\uA5D1 "VAI SYLLABLE DO"
\uA5D2 "VAI SYLLABLE NDO"
\uA5D3 "VAI SYLLABLE SO"
\uA5D4 "VAI SYLLABLE SHO"
\uA5D5 "VAI SYLLABLE ZO"
\uA5D6 "VAI SYLLABLE ZHO"
\uA5D7 "VAI SYLLABLE CO"
\uA5D8 "VAI SYLLABLE JO"
\uA5D9 "VAI SYLLABLE NJO"
\uA5DA "VAI SYLLABLE YO"
\uA5DB "VAI SYLLABLE KO"
\uA5DC "VAI SYLLABLE NGGO"
\uA5DD "VAI SYLLABLE GO"
\uA5DE "VAI SYLLABLE MO"
\uA5DF "VAI SYLLABLE NO"
\uA5E0 "VAI SYLLABLE NYO"
\uA5E1 "VAI SYLLABLE E"
\uA5E2 "VAI SYLLABLE EN"
\uA5E3 "VAI SYLLABLE NGEN"
\uA5E4 "VAI SYLLABLE HE"
\uA5E5 "VAI SYLLABLE HEN"
\uA5E6 "VAI SYLLABLE WE"
\uA5E7 "VAI SYLLABLE WEN"
\uA5E8 "VAI SYLLABLE PE"
\uA5E9 "VAI SYLLABLE BHE"
\uA5EA "VAI SYLLABLE BE"
\uA5EB "VAI SYLLABLE MBE"
\uA5EC "VAI SYLLABLE KPE"
\uA5ED "VAI SYLLABLE KPEN"
\uA5EE "VAI SYLLABLE MGBE"
\uA5EF "VAI SYLLABLE GBE"
\uA5F0 "VAI SYLLABLE GBEN"
\uA5F1 "VAI SYLLABLE FE"
\uA5F2 "VAI SYLLABLE VE"
\uA5F3 "VAI SYLLABLE TE"
\uA5F4 "VAI SYLLABLE THE"
\uA5F5 "VAI SYLLABLE DHE"
\uA5F6 "VAI SYLLABLE DHHE"
\uA5F7 "VAI SYLLABLE LE"
\uA5F8 "VAI SYLLABLE RE"
\uA5F9 "VAI SYLLABLE DE"
\uA5FA "VAI SYLLABLE NDE"
\uA5FB "VAI SYLLABLE SE"
\uA5FC "VAI SYLLABLE SHE"
\uA5FD "VAI SYLLABLE ZE"
\uA5FE "VAI SYLLABLE ZHE"
\uA5FF "VAI SYLLABLE CE"
\uA600 "VAI SYLLABLE JE"
\uA601 "VAI SYLLABLE NJE"
\uA602 "VAI SYLLABLE YE"
\uA603 "VAI SYLLABLE KE"
\uA604 "VAI SYLLABLE NGGE"
\uA605 "VAI SYLLABLE NGGEN"
\uA606 "VAI SYLLABLE GE"
\uA607 "VAI SYLLABLE GEN"
\uA608 "VAI SYLLABLE ME"
\uA609 "VAI SYLLABLE NE"
\uA60A "VAI SYLLABLE NYE"
\uA60B "VAI SYLLABLE NG"
\uA60C "VAI SYLLABLE LENGTHENER"
\uA60D "VAI COMMA"
\uA60E "VAI FULL STOP"
\uA60F "VAI QUESTION MARK"
\uA610 "VAI SYLLABLE NDOLE FA"
\uA611 "VAI SYLLABLE NDOLE KA"
\uA612 "VAI SYLLABLE NDOLE SOO"
\uA613 "VAI SYMBOL FEENG"
\uA614 "VAI SYMBOL KEENG"
\uA615 "VAI SYMBOL TING"
\uA616 "VAI SYMBOL NII"
\uA617 "VAI SYMBOL BANG"
\uA618 "VAI SYMBOL FAA"
\uA619 "VAI SYMBOL TAA"
\uA61A "VAI SYMBOL DANG"
\uA61B "VAI SYMBOL DOONG"
\uA61C "VAI SYMBOL KUNG"
\uA61D "VAI SYMBOL TONG"
\uA61E "VAI SYMBOL DO-O"
\uA61F "VAI SYMBOL JONG"
\uA620 "VAI DIGIT ZERO"
\uA621 "VAI DIGIT ONE"
\uA622 "VAI DIGIT TWO"
\uA623 "VAI DIGIT THREE"
\uA624 "VAI DIGIT FOUR"
\uA625 "VAI DIGIT FIVE"
\uA626 "VAI DIGIT SIX"
\uA627 "VAI DIGIT SEVEN"
\uA628 "VAI DIGIT EIGHT"
\uA629 "VAI DIGIT NINE"
\uA62A "VAI SYLLABLE NDOLE MA"
\uA62B "VAI SYLLABLE NDOLE DO"
\uA640 "CYRILLIC CAPITAL LETTER ZEMLYA"
\uA641 "CYRILLIC SMALL LETTER ZEMLYA"
\uA642 "CYRILLIC CAPITAL LETTER DZELO"
\uA643 "CYRILLIC SMALL LETTER DZELO"
\uA644 "CYRILLIC CAPITAL LETTER REVERSED DZE"
\uA645 "CYRILLIC SMALL LETTER REVERSED DZE"
\uA646 "CYRILLIC CAPITAL LETTER IOTA"
\uA647 "CYRILLIC SMALL LETTER IOTA"
\uA648 "CYRILLIC CAPITAL LETTER DJERV"
\uA649 "CYRILLIC SMALL LETTER DJERV"
\uA64A "CYRILLIC CAPITAL LETTER MONOGRAPH UK"
\uA64B "CYRILLIC SMALL LETTER MONOGRAPH UK"
\uA64C "CYRILLIC CAPITAL LETTER BROAD OMEGA"
\uA64D "CYRILLIC SMALL LETTER BROAD OMEGA"
\uA64E "CYRILLIC CAPITAL LETTER NEUTRAL YER"
\uA64F "CYRILLIC SMALL LETTER NEUTRAL YER"
\uA650 "CYRILLIC CAPITAL LETTER YERU WITH BACK YER"
\uA651 "CYRILLIC SMALL LETTER YERU WITH BACK YER"
\uA652 "CYRILLIC CAPITAL LETTER IOTIFIED YAT"
\uA653 "CYRILLIC SMALL LETTER IOTIFIED YAT"
\uA654 "CYRILLIC CAPITAL LETTER REVERSED YU"
\uA655 "CYRILLIC SMALL LETTER REVERSED YU"
\uA656 "CYRILLIC CAPITAL LETTER IOTIFIED A"
\uA657 "CYRILLIC SMALL LETTER IOTIFIED A"
\uA658 "CYRILLIC CAPITAL LETTER CLOSED LITTLE YUS"
\uA659 "CYRILLIC SMALL LETTER CLOSED LITTLE YUS"
\uA65A "CYRILLIC CAPITAL LETTER BLENDED YUS"
\uA65B "CYRILLIC SMALL LETTER BLENDED YUS"
\uA65C "CYRILLIC CAPITAL LETTER IOTIFIED CLOSED LITTLE YUS"
\uA65D "CYRILLIC SMALL LETTER IOTIFIED CLOSED LITTLE YUS"
\uA65E "CYRILLIC CAPITAL LETTER YN"
\uA65F "CYRILLIC SMALL LETTER YN"
\uA662 "CYRILLIC CAPITAL LETTER SOFT DE"
\uA663 "CYRILLIC SMALL LETTER SOFT DE"
\uA664 "CYRILLIC CAPITAL LETTER SOFT EL"
\uA665 "CYRILLIC SMALL LETTER SOFT EL"
\uA666 "CYRILLIC CAPITAL LETTER SOFT EM"
\uA667 "CYRILLIC SMALL LETTER SOFT EM"
\uA668 "CYRILLIC CAPITAL LETTER MONOCULAR O"
\uA669 "CYRILLIC SMALL LETTER MONOCULAR O"
\uA66A "CYRILLIC CAPITAL LETTER BINOCULAR O"
\uA66B "CYRILLIC SMALL LETTER BINOCULAR O"
\uA66C "CYRILLIC CAPITAL LETTER DOUBLE MONOCULAR O"
\uA66D "CYRILLIC SMALL LETTER DOUBLE MONOCULAR O"
\uA66E "CYRILLIC LETTER MULTIOCULAR O"
\uA66F "COMBINING CYRILLIC VZMET"
\uA670 "COMBINING CYRILLIC TEN MILLIONS SIGN"
\uA671 "COMBINING CYRILLIC HUNDRED MILLIONS SIGN"
\uA672 "COMBINING CYRILLIC THOUSAND MILLIONS SIGN"
\uA673 "SLAVONIC ASTERISK"
\uA67C "COMBINING CYRILLIC KAVYKA"
\uA67D "COMBINING CYRILLIC PAYEROK"
\uA67E "CYRILLIC KAVYKA"
\uA67F "CYRILLIC PAYEROK"
\uA680 "CYRILLIC CAPITAL LETTER DWE"
\uA681 "CYRILLIC SMALL LETTER DWE"
\uA682 "CYRILLIC CAPITAL LETTER DZWE"
\uA683 "CYRILLIC SMALL LETTER DZWE"
\uA684 "CYRILLIC CAPITAL LETTER ZHWE"
\uA685 "CYRILLIC SMALL LETTER ZHWE"
\uA686 "CYRILLIC CAPITAL LETTER CCHE"
\uA687 "CYRILLIC SMALL LETTER CCHE"
\uA688 "CYRILLIC CAPITAL LETTER DZZE"
\uA689 "CYRILLIC SMALL LETTER DZZE"
\uA68A "CYRILLIC CAPITAL LETTER TE WITH MIDDLE HOOK"
\uA68B "CYRILLIC SMALL LETTER TE WITH MIDDLE HOOK"
\uA68C "CYRILLIC CAPITAL LETTER TWE"
\uA68D "CYRILLIC SMALL LETTER TWE"
\uA68E "CYRILLIC CAPITAL LETTER TSWE"
\uA68F "CYRILLIC SMALL LETTER TSWE"
\uA690 "CYRILLIC CAPITAL LETTER TSSE"
\uA691 "CYRILLIC SMALL LETTER TSSE"
\uA692 "CYRILLIC CAPITAL LETTER TCHE"
\uA693 "CYRILLIC SMALL LETTER TCHE"
\uA694 "CYRILLIC CAPITAL LETTER HWE"
\uA695 "CYRILLIC SMALL LETTER HWE"
\uA696 "CYRILLIC CAPITAL LETTER SHWE"
\uA697 "CYRILLIC SMALL LETTER SHWE"
\uA700 "MODIFIER LETTER CHINESE TONE YIN PING"
\uA701 "MODIFIER LETTER CHINESE TONE YANG PING"
\uA702 "MODIFIER LETTER CHINESE TONE YIN SHANG"
\uA703 "MODIFIER LETTER CHINESE TONE YANG SHANG"
\uA704 "MODIFIER LETTER CHINESE TONE YIN QU"
\uA705 "MODIFIER LETTER CHINESE TONE YANG QU"
\uA706 "MODIFIER LETTER CHINESE TONE YIN RU"
\uA707 "MODIFIER LETTER CHINESE TONE YANG RU"
\uA708 "MODIFIER LETTER EXTRA-HIGH DOTTED TONE BAR"
\uA709 "MODIFIER LETTER HIGH DOTTED TONE BAR"
\uA70A "MODIFIER LETTER MID DOTTED TONE BAR"
\uA70B "MODIFIER LETTER LOW DOTTED TONE BAR"
\uA70C "MODIFIER LETTER EXTRA-LOW DOTTED TONE BAR"
\uA70D "MODIFIER LETTER EXTRA-HIGH DOTTED LEFT-STEM TONE BAR"
\uA70E "MODIFIER LETTER HIGH DOTTED LEFT-STEM TONE BAR"
\uA70F "MODIFIER LETTER MID DOTTED LEFT-STEM TONE BAR"
\uA710 "MODIFIER LETTER LOW DOTTED LEFT-STEM TONE BAR"
\uA711 "MODIFIER LETTER EXTRA-LOW DOTTED LEFT-STEM TONE BAR"
\uA712 "MODIFIER LETTER EXTRA-HIGH LEFT-STEM TONE BAR"
\uA713 "MODIFIER LETTER HIGH LEFT-STEM TONE BAR"
\uA714 "MODIFIER LETTER MID LEFT-STEM TONE BAR"
\uA715 "MODIFIER LETTER LOW LEFT-STEM TONE BAR"
\uA716 "MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR"
\uA717 "MODIFIER LETTER DOT VERTICAL BAR"
\uA718 "MODIFIER LETTER DOT SLASH"
\uA719 "MODIFIER LETTER DOT HORIZONTAL BAR"
\uA71A "MODIFIER LETTER LOWER RIGHT CORNER ANGLE"
\uA71B "MODIFIER LETTER RAISED UP ARROW"
\uA71C "MODIFIER LETTER RAISED DOWN ARROW"
\uA71D "MODIFIER LETTER RAISED EXCLAMATION MARK"
\uA71E "MODIFIER LETTER RAISED INVERTED EXCLAMATION MARK"
\uA71F "MODIFIER LETTER LOW INVERTED EXCLAMATION MARK"
\uA720 "MODIFIER LETTER STRESS AND HIGH TONE"
\uA721 "MODIFIER LETTER STRESS AND LOW TONE"
\uA722 "LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF"
\uA723 "LATIN SMALL LETTER EGYPTOLOGICAL ALEF"
\uA724 "LATIN CAPITAL LETTER EGYPTOLOGICAL AIN"
\uA725 "LATIN SMALL LETTER EGYPTOLOGICAL AIN"
\uA726 "LATIN CAPITAL LETTER HENG"
\uA727 "LATIN SMALL LETTER HENG"
\uA728 "LATIN CAPITAL LETTER TZ"
\uA729 "LATIN SMALL LETTER TZ"
\uA72A "LATIN CAPITAL LETTER TRESILLO"
\uA72B "LATIN SMALL LETTER TRESILLO"
\uA72C "LATIN CAPITAL LETTER CUATRILLO"
\uA72D "LATIN SMALL LETTER CUATRILLO"
\uA72E "LATIN CAPITAL LETTER CUATRILLO WITH COMMA"
\uA72F "LATIN SMALL LETTER CUATRILLO WITH COMMA"
\uA730 "LATIN LETTER SMALL CAPITAL F"
\uA731 "LATIN LETTER SMALL CAPITAL S"
\uA732 "LATIN CAPITAL LETTER AA"
\uA733 "LATIN SMALL LETTER AA"
\uA734 "LATIN CAPITAL LETTER AO"
\uA735 "LATIN SMALL LETTER AO"
\uA736 "LATIN CAPITAL LETTER AU"
\uA737 "LATIN SMALL LETTER AU"
\uA738 "LATIN CAPITAL LETTER AV"
\uA739 "LATIN SMALL LETTER AV"
\uA73A "LATIN CAPITAL LETTER AV WITH HORIZONTAL BAR"
\uA73B "LATIN SMALL LETTER AV WITH HORIZONTAL BAR"
\uA73C "LATIN CAPITAL LETTER AY"
\uA73D "LATIN SMALL LETTER AY"
\uA73E "LATIN CAPITAL LETTER REVERSED C WITH DOT"
\uA73F "LATIN SMALL LETTER REVERSED C WITH DOT"
\uA740 "LATIN CAPITAL LETTER K WITH STROKE"
\uA741 "LATIN SMALL LETTER K WITH STROKE"
\uA742 "LATIN CAPITAL LETTER K WITH DIAGONAL STROKE"
\uA743 "LATIN SMALL LETTER K WITH DIAGONAL STROKE"
\uA744 "LATIN CAPITAL LETTER K WITH STROKE AND DIAGONAL STROKE"
\uA745 "LATIN SMALL LETTER K WITH STROKE AND DIAGONAL STROKE"
\uA746 "LATIN CAPITAL LETTER BROKEN L"
\uA747 "LATIN SMALL LETTER BROKEN L"
\uA748 "LATIN CAPITAL LETTER L WITH HIGH STROKE"
\uA749 "LATIN SMALL LETTER L WITH HIGH STROKE"
\uA74A "LATIN CAPITAL LETTER O WITH LONG STROKE OVERLAY"
\uA74B "LATIN SMALL LETTER O WITH LONG STROKE OVERLAY"
\uA74C "LATIN CAPITAL LETTER O WITH LOOP"
\uA74D "LATIN SMALL LETTER O WITH LOOP"
\uA74E "LATIN CAPITAL LETTER OO"
\uA74F "LATIN SMALL LETTER OO"
\uA750 "LATIN CAPITAL LETTER P WITH STROKE THROUGH DESCENDER"
\uA751 "LATIN SMALL LETTER P WITH STROKE THROUGH DESCENDER"
\uA752 "LATIN CAPITAL LETTER P WITH FLOURISH"
\uA753 "LATIN SMALL LETTER P WITH FLOURISH"
\uA754 "LATIN CAPITAL LETTER P WITH SQUIRREL TAIL"
\uA755 "LATIN SMALL LETTER P WITH SQUIRREL TAIL"
\uA756 "LATIN CAPITAL LETTER Q WITH STROKE THROUGH DESCENDER"
\uA757 "LATIN SMALL LETTER Q WITH STROKE THROUGH DESCENDER"
\uA758 "LATIN CAPITAL LETTER Q WITH DIAGONAL STROKE"
\uA759 "LATIN SMALL LETTER Q WITH DIAGONAL STROKE"
\uA75A "LATIN CAPITAL LETTER R ROTUNDA"
\uA75B "LATIN SMALL LETTER R ROTUNDA"
\uA75C "LATIN CAPITAL LETTER RUM ROTUNDA"
\uA75D "LATIN SMALL LETTER RUM ROTUNDA"
\uA75E "LATIN CAPITAL LETTER V WITH DIAGONAL STROKE"
\uA75F "LATIN SMALL LETTER V WITH DIAGONAL STROKE"
\uA760 "LATIN CAPITAL LETTER VY"
\uA761 "LATIN SMALL LETTER VY"
\uA762 "LATIN CAPITAL LETTER VISIGOTHIC Z"
\uA763 "LATIN SMALL LETTER VISIGOTHIC Z"
\uA764 "LATIN CAPITAL LETTER THORN WITH STROKE"
\uA765 "LATIN SMALL LETTER THORN WITH STROKE"
\uA766 "LATIN CAPITAL LETTER THORN WITH STROKE THROUGH DESCENDER"
\uA767 "LATIN SMALL LETTER THORN WITH STROKE THROUGH DESCENDER"
\uA768 "LATIN CAPITAL LETTER VEND"
\uA769 "LATIN SMALL LETTER VEND"
\uA76A "LATIN CAPITAL LETTER ET"
\uA76B "LATIN SMALL LETTER ET"
\uA76C "LATIN CAPITAL LETTER IS"
\uA76D "LATIN SMALL LETTER IS"
\uA76E "LATIN CAPITAL LETTER CON"
\uA76F "LATIN SMALL LETTER CON"
\uA770 "MODIFIER LETTER US"
\uA771 "LATIN SMALL LETTER DUM"
\uA772 "LATIN SMALL LETTER LUM"
\uA773 "LATIN SMALL LETTER MUM"
\uA774 "LATIN SMALL LETTER NUM"
\uA775 "LATIN SMALL LETTER RUM"
\uA776 "LATIN LETTER SMALL CAPITAL RUM"
\uA777 "LATIN SMALL LETTER TUM"
\uA778 "LATIN SMALL LETTER UM"
\uA779 "LATIN CAPITAL LETTER INSULAR D"
\uA77A "LATIN SMALL LETTER INSULAR D"
\uA77B "LATIN CAPITAL LETTER INSULAR F"
\uA77C "LATIN SMALL LETTER INSULAR F"
\uA77D "LATIN CAPITAL LETTER INSULAR G"
\uA77E "LATIN CAPITAL LETTER TURNED INSULAR G"
\uA77F "LATIN SMALL LETTER TURNED INSULAR G"
\uA780 "LATIN CAPITAL LETTER TURNED L"
\uA781 "LATIN SMALL LETTER TURNED L"
\uA782 "LATIN CAPITAL LETTER INSULAR R"
\uA783 "LATIN SMALL LETTER INSULAR R"
\uA784 "LATIN CAPITAL LETTER INSULAR S"
\uA785 "LATIN SMALL LETTER INSULAR S"
\uA786 "LATIN CAPITAL LETTER INSULAR T"
\uA787 "LATIN SMALL LETTER INSULAR T"
\uA788 "MODIFIER LETTER LOW CIRCUMFLEX ACCENT"
\uA789 "MODIFIER LETTER COLON"
\uA78A "MODIFIER LETTER SHORT EQUALS SIGN"
\uA78B "LATIN CAPITAL LETTER SALTILLO"
\uA78C "LATIN SMALL LETTER SALTILLO"
\uA7FB "LATIN EPIGRAPHIC LETTER REVERSED F"
\uA7FC "LATIN EPIGRAPHIC LETTER REVERSED P"
\uA7FD "LATIN EPIGRAPHIC LETTER INVERTED M"
\uA7FE "LATIN EPIGRAPHIC LETTER I LONGA"
\uA7FF "LATIN EPIGRAPHIC LETTER ARCHAIC M"
\uA800 "SYLOTI NAGRI LETTER A"
\uA801 "SYLOTI NAGRI LETTER I"
\uA802 "SYLOTI NAGRI SIGN DVISVARA"
\uA803 "SYLOTI NAGRI LETTER U"
\uA804 "SYLOTI NAGRI LETTER E"
\uA805 "SYLOTI NAGRI LETTER O"
\uA806 "SYLOTI NAGRI SIGN HASANTA"
\uA807 "SYLOTI NAGRI LETTER KO"
\uA808 "SYLOTI NAGRI LETTER KHO"
\uA809 "SYLOTI NAGRI LETTER GO"
\uA80A "SYLOTI NAGRI LETTER GHO"
\uA80B "SYLOTI NAGRI SIGN ANUSVARA"
\uA80C "SYLOTI NAGRI LETTER CO"
\uA80D "SYLOTI NAGRI LETTER CHO"
\uA80E "SYLOTI NAGRI LETTER JO"
\uA80F "SYLOTI NAGRI LETTER JHO"
\uA810 "SYLOTI NAGRI LETTER TTO"
\uA811 "SYLOTI NAGRI LETTER TTHO"
\uA812 "SYLOTI NAGRI LETTER DDO"
\uA813 "SYLOTI NAGRI LETTER DDHO"
\uA814 "SYLOTI NAGRI LETTER TO"
\uA815 "SYLOTI NAGRI LETTER THO"
\uA816 "SYLOTI NAGRI LETTER DO"
\uA817 "SYLOTI NAGRI LETTER DHO"
\uA818 "SYLOTI NAGRI LETTER NO"
\uA819 "SYLOTI NAGRI LETTER PO"
\uA81A "SYLOTI NAGRI LETTER PHO"
\uA81B "SYLOTI NAGRI LETTER BO"
\uA81C "SYLOTI NAGRI LETTER BHO"
\uA81D "SYLOTI NAGRI LETTER MO"
\uA81E "SYLOTI NAGRI LETTER RO"
\uA81F "SYLOTI NAGRI LETTER LO"
\uA820 "SYLOTI NAGRI LETTER RRO"
\uA821 "SYLOTI NAGRI LETTER SO"
\uA822 "SYLOTI NAGRI LETTER HO"
\uA823 "SYLOTI NAGRI VOWEL SIGN A"
\uA824 "SYLOTI NAGRI VOWEL SIGN I"
\uA825 "SYLOTI NAGRI VOWEL SIGN U"
\uA826 "SYLOTI NAGRI VOWEL SIGN E"
\uA827 "SYLOTI NAGRI VOWEL SIGN OO"
\uA828 "SYLOTI NAGRI POETRY MARK-1"
\uA829 "SYLOTI NAGRI POETRY MARK-2"
\uA82A "SYLOTI NAGRI POETRY MARK-3"
\uA82B "SYLOTI NAGRI POETRY MARK-4"
\uA840 "PHAGS-PA LETTER KA"
\uA841 "PHAGS-PA LETTER KHA"
\uA842 "PHAGS-PA LETTER GA"
\uA843 "PHAGS-PA LETTER NGA"
\uA844 "PHAGS-PA LETTER CA"
\uA845 "PHAGS-PA LETTER CHA"
\uA846 "PHAGS-PA LETTER JA"
\uA847 "PHAGS-PA LETTER NYA"
\uA848 "PHAGS-PA LETTER TA"
\uA849 "PHAGS-PA LETTER THA"
\uA84A "PHAGS-PA LETTER DA"
\uA84B "PHAGS-PA LETTER NA"
\uA84C "PHAGS-PA LETTER PA"
\uA84D "PHAGS-PA LETTER PHA"
\uA84E "PHAGS-PA LETTER BA"
\uA84F "PHAGS-PA LETTER MA"
\uA850 "PHAGS-PA LETTER TSA"
\uA851 "PHAGS-PA LETTER TSHA"
\uA852 "PHAGS-PA LETTER DZA"
\uA853 "PHAGS-PA LETTER WA"
\uA854 "PHAGS-PA LETTER ZHA"
\uA855 "PHAGS-PA LETTER ZA"
\uA856 "PHAGS-PA LETTER SMALL A"
\uA857 "PHAGS-PA LETTER YA"
\uA858 "PHAGS-PA LETTER RA"
\uA859 "PHAGS-PA LETTER LA"
\uA85A "PHAGS-PA LETTER SHA"
\uA85B "PHAGS-PA LETTER SA"
\uA85C "PHAGS-PA LETTER HA"
\uA85D "PHAGS-PA LETTER A"
\uA85E "PHAGS-PA LETTER I"
\uA85F "PHAGS-PA LETTER U"
\uA860 "PHAGS-PA LETTER E"
\uA861 "PHAGS-PA LETTER O"
\uA862 "PHAGS-PA LETTER QA"
\uA863 "PHAGS-PA LETTER XA"
\uA864 "PHAGS-PA LETTER FA"
\uA865 "PHAGS-PA LETTER GGA"
\uA866 "PHAGS-PA LETTER EE"
\uA867 "PHAGS-PA SUBJOINED LETTER WA"
\uA868 "PHAGS-PA SUBJOINED LETTER YA"
\uA869 "PHAGS-PA LETTER TTA"
\uA86A "PHAGS-PA LETTER TTHA"
\uA86B "PHAGS-PA LETTER DDA"
\uA86C "PHAGS-PA LETTER NNA"
\uA86D "PHAGS-PA LETTER ALTERNATE YA"
\uA86E "PHAGS-PA LETTER VOICELESS SHA"
\uA86F "PHAGS-PA LETTER VOICED HA"
\uA870 "PHAGS-PA LETTER ASPIRATED FA"
\uA871 "PHAGS-PA SUBJOINED LETTER RA"
\uA872 "PHAGS-PA SUPERFIXED LETTER RA"
\uA873 "PHAGS-PA LETTER CANDRABINDU"
\uA874 "PHAGS-PA SINGLE HEAD MARK"
\uA875 "PHAGS-PA DOUBLE HEAD MARK"
\uA876 "PHAGS-PA MARK SHAD"
\uA877 "PHAGS-PA MARK DOUBLE SHAD"
\uA880 "SAURASHTRA SIGN ANUSVARA"
\uA881 "SAURASHTRA SIGN VISARGA"
\uA882 "SAURASHTRA LETTER A"
\uA883 "SAURASHTRA LETTER AA"
\uA884 "SAURASHTRA LETTER I"
\uA885 "SAURASHTRA LETTER II"
\uA886 "SAURASHTRA LETTER U"
\uA887 "SAURASHTRA LETTER UU"
\uA888 "SAURASHTRA LETTER VOCALIC R"
\uA889 "SAURASHTRA LETTER VOCALIC RR"
\uA88A "SAURASHTRA LETTER VOCALIC L"
\uA88B "SAURASHTRA LETTER VOCALIC LL"
\uA88C "SAURASHTRA LETTER E"
\uA88D "SAURASHTRA LETTER EE"
\uA88E "SAURASHTRA LETTER AI"
\uA88F "SAURASHTRA LETTER O"
\uA890 "SAURASHTRA LETTER OO"
\uA891 "SAURASHTRA LETTER AU"
\uA892 "SAURASHTRA LETTER KA"
\uA893 "SAURASHTRA LETTER KHA"
\uA894 "SAURASHTRA LETTER GA"
\uA895 "SAURASHTRA LETTER GHA"
\uA896 "SAURASHTRA LETTER NGA"
\uA897 "SAURASHTRA LETTER CA"
\uA898 "SAURASHTRA LETTER CHA"
\uA899 "SAURASHTRA LETTER JA"
\uA89A "SAURASHTRA LETTER JHA"
\uA89B "SAURASHTRA LETTER NYA"
\uA89C "SAURASHTRA LETTER TTA"
\uA89D "SAURASHTRA LETTER TTHA"
\uA89E "SAURASHTRA LETTER DDA"
\uA89F "SAURASHTRA LETTER DDHA"
\uA8A0 "SAURASHTRA LETTER NNA"
\uA8A1 "SAURASHTRA LETTER TA"
\uA8A2 "SAURASHTRA LETTER THA"
\uA8A3 "SAURASHTRA LETTER DA"
\uA8A4 "SAURASHTRA LETTER DHA"
\uA8A5 "SAURASHTRA LETTER NA"
\uA8A6 "SAURASHTRA LETTER PA"
\uA8A7 "SAURASHTRA LETTER PHA"
\uA8A8 "SAURASHTRA LETTER BA"
\uA8A9 "SAURASHTRA LETTER BHA"
\uA8AA "SAURASHTRA LETTER MA"
\uA8AB "SAURASHTRA LETTER YA"
\uA8AC "SAURASHTRA LETTER RA"
\uA8AD "SAURASHTRA LETTER LA"
\uA8AE "SAURASHTRA LETTER VA"
\uA8AF "SAURASHTRA LETTER SHA"
\uA8B0 "SAURASHTRA LETTER SSA"
\uA8B1 "SAURASHTRA LETTER SA"
\uA8B2 "SAURASHTRA LETTER HA"
\uA8B3 "SAURASHTRA LETTER LLA"
\uA8B4 "SAURASHTRA CONSONANT SIGN HAARU"
\uA8B5 "SAURASHTRA VOWEL SIGN AA"
\uA8B6 "SAURASHTRA VOWEL SIGN I"
\uA8B7 "SAURASHTRA VOWEL SIGN II"
\uA8B8 "SAURASHTRA VOWEL SIGN U"
\uA8B9 "SAURASHTRA VOWEL SIGN UU"
\uA8BA "SAURASHTRA VOWEL SIGN VOCALIC R"
\uA8BB "SAURASHTRA VOWEL SIGN VOCALIC RR"
\uA8BC "SAURASHTRA VOWEL SIGN VOCALIC L"
\uA8BD "SAURASHTRA VOWEL SIGN VOCALIC LL"
\uA8BE "SAURASHTRA VOWEL SIGN E"
\uA8BF "SAURASHTRA VOWEL SIGN EE"
\uA8C0 "SAURASHTRA VOWEL SIGN AI"
\uA8C1 "SAURASHTRA VOWEL SIGN O"
\uA8C2 "SAURASHTRA VOWEL SIGN OO"
\uA8C3 "SAURASHTRA VOWEL SIGN AU"
\uA8C4 "SAURASHTRA SIGN VIRAMA"
\uA8CE "SAURASHTRA DANDA"
\uA8CF "SAURASHTRA DOUBLE DANDA"
\uA8D0 "SAURASHTRA DIGIT ZERO"
\uA8D1 "SAURASHTRA DIGIT ONE"
\uA8D2 "SAURASHTRA DIGIT TWO"
\uA8D3 "SAURASHTRA DIGIT THREE"
\uA8D4 "SAURASHTRA DIGIT FOUR"
\uA8D5 "SAURASHTRA DIGIT FIVE"
\uA8D6 "SAURASHTRA DIGIT SIX"
\uA8D7 "SAURASHTRA DIGIT SEVEN"
\uA8D8 "SAURASHTRA DIGIT EIGHT"
\uA8D9 "SAURASHTRA DIGIT NINE"
\uA900 "KAYAH LI DIGIT ZERO"
\uA901 "KAYAH LI DIGIT ONE"
\uA902 "KAYAH LI DIGIT TWO"
\uA903 "KAYAH LI DIGIT THREE"
\uA904 "KAYAH LI DIGIT FOUR"
\uA905 "KAYAH LI DIGIT FIVE"
\uA906 "KAYAH LI DIGIT SIX"
\uA907 "KAYAH LI DIGIT SEVEN"
\uA908 "KAYAH LI DIGIT EIGHT"
\uA909 "KAYAH LI DIGIT NINE"
\uA90A "KAYAH LI LETTER KA"
\uA90B "KAYAH LI LETTER KHA"
\uA90C "KAYAH LI LETTER GA"
\uA90D "KAYAH LI LETTER NGA"
\uA90E "KAYAH LI LETTER SA"
\uA90F "KAYAH LI LETTER SHA"
\uA910 "KAYAH LI LETTER ZA"
\uA911 "KAYAH LI LETTER NYA"
\uA912 "KAYAH LI LETTER TA"
\uA913 "KAYAH LI LETTER HTA"
\uA914 "KAYAH LI LETTER NA"
\uA915 "KAYAH LI LETTER PA"
\uA916 "KAYAH LI LETTER PHA"
\uA917 "KAYAH LI LETTER MA"
\uA918 "KAYAH LI LETTER DA"
\uA919 "KAYAH LI LETTER BA"
\uA91A "KAYAH LI LETTER RA"
\uA91B "KAYAH LI LETTER YA"
\uA91C "KAYAH LI LETTER LA"
\uA91D "KAYAH LI LETTER WA"
\uA91E "KAYAH LI LETTER THA"
\uA91F "KAYAH LI LETTER HA"
\uA920 "KAYAH LI LETTER VA"
\uA921 "KAYAH LI LETTER CA"
\uA922 "KAYAH LI LETTER A"
\uA923 "KAYAH LI LETTER OE"
\uA924 "KAYAH LI LETTER I"
\uA925 "KAYAH LI LETTER OO"
\uA926 "KAYAH LI VOWEL UE"
\uA927 "KAYAH LI VOWEL E"
\uA928 "KAYAH LI VOWEL U"
\uA929 "KAYAH LI VOWEL EE"
\uA92A "KAYAH LI VOWEL O"
\uA92B "KAYAH LI TONE PLOPHU"
\uA92C "KAYAH LI TONE CALYA"
\uA92D "KAYAH LI TONE CALYA PLOPHU"
\uA92E "KAYAH LI SIGN CWI"
\uA92F "KAYAH LI SIGN SHYA"
\uA930 "REJANG LETTER KA"
\uA931 "REJANG LETTER GA"
\uA932 "REJANG LETTER NGA"
\uA933 "REJANG LETTER TA"
\uA934 "REJANG LETTER DA"
\uA935 "REJANG LETTER NA"
\uA936 "REJANG LETTER PA"
\uA937 "REJANG LETTER BA"
\uA938 "REJANG LETTER MA"
\uA939 "REJANG LETTER CA"
\uA93A "REJANG LETTER JA"
\uA93B "REJANG LETTER NYA"
\uA93C "REJANG LETTER SA"
\uA93D "REJANG LETTER RA"
\uA93E "REJANG LETTER LA"
\uA93F "REJANG LETTER YA"
\uA940 "REJANG LETTER WA"
\uA941 "REJANG LETTER HA"
\uA942 "REJANG LETTER MBA"
\uA943 "REJANG LETTER NGGA"
\uA944 "REJANG LETTER NDA"
\uA945 "REJANG LETTER NYJA"
\uA946 "REJANG LETTER A"
\uA947 "REJANG VOWEL SIGN I"
\uA948 "REJANG VOWEL SIGN U"
\uA949 "REJANG VOWEL SIGN E"
\uA94A "REJANG VOWEL SIGN AI"
\uA94B "REJANG VOWEL SIGN O"
\uA94C "REJANG VOWEL SIGN AU"
\uA94D "REJANG VOWEL SIGN EU"
\uA94E "REJANG VOWEL SIGN EA"
\uA94F "REJANG CONSONANT SIGN NG"
\uA950 "REJANG CONSONANT SIGN N"
\uA951 "REJANG CONSONANT SIGN R"
\uA952 "REJANG CONSONANT SIGN H"
\uA953 "REJANG VIRAMA"
\uA95F "REJANG SECTION MARK"
\uAA00 "CHAM LETTER A"
\uAA01 "CHAM LETTER I"
\uAA02 "CHAM LETTER U"
\uAA03 "CHAM LETTER E"
\uAA04 "CHAM LETTER AI"
\uAA05 "CHAM LETTER O"
\uAA06 "CHAM LETTER KA"
\uAA07 "CHAM LETTER KHA"
\uAA08 "CHAM LETTER GA"
\uAA09 "CHAM LETTER GHA"
\uAA0A "CHAM LETTER NGUE"
\uAA0B "CHAM LETTER NGA"
\uAA0C "CHAM LETTER CHA"
\uAA0D "CHAM LETTER CHHA"
\uAA0E "CHAM LETTER JA"
\uAA0F "CHAM LETTER JHA"
\uAA10 "CHAM LETTER NHUE"
\uAA11 "CHAM LETTER NHA"
\uAA12 "CHAM LETTER NHJA"
\uAA13 "CHAM LETTER TA"
\uAA14 "CHAM LETTER THA"
\uAA15 "CHAM LETTER DA"
\uAA16 "CHAM LETTER DHA"
\uAA17 "CHAM LETTER NUE"
\uAA18 "CHAM LETTER NA"
\uAA19 "CHAM LETTER DDA"
\uAA1A "CHAM LETTER PA"
\uAA1B "CHAM LETTER PPA"
\uAA1C "CHAM LETTER PHA"
\uAA1D "CHAM LETTER BA"
\uAA1E "CHAM LETTER BHA"
\uAA1F "CHAM LETTER MUE"
\uAA20 "CHAM LETTER MA"
\uAA21 "CHAM LETTER BBA"
\uAA22 "CHAM LETTER YA"
\uAA23 "CHAM LETTER RA"
\uAA24 "CHAM LETTER LA"
\uAA25 "CHAM LETTER VA"
\uAA26 "CHAM LETTER SSA"
\uAA27 "CHAM LETTER SA"
\uAA28 "CHAM LETTER HA"
\uAA29 "CHAM VOWEL SIGN AA"
\uAA2A "CHAM VOWEL SIGN I"
\uAA2B "CHAM VOWEL SIGN II"
\uAA2C "CHAM VOWEL SIGN EI"
\uAA2D "CHAM VOWEL SIGN U"
\uAA2E "CHAM VOWEL SIGN OE"
\uAA2F "CHAM VOWEL SIGN O"
\uAA30 "CHAM VOWEL SIGN AI"
\uAA31 "CHAM VOWEL SIGN AU"
\uAA32 "CHAM VOWEL SIGN UE"
\uAA33 "CHAM CONSONANT SIGN YA"
\uAA34 "CHAM CONSONANT SIGN RA"
\uAA35 "CHAM CONSONANT SIGN LA"
\uAA36 "CHAM CONSONANT SIGN WA"
\uAA40 "CHAM LETTER FINAL K"
\uAA41 "CHAM LETTER FINAL G"
\uAA42 "CHAM LETTER FINAL NG"
\uAA43 "CHAM CONSONANT SIGN FINAL NG"
\uAA44 "CHAM LETTER FINAL CH"
\uAA45 "CHAM LETTER FINAL T"
\uAA46 "CHAM LETTER FINAL N"
\uAA47 "CHAM LETTER FINAL P"
\uAA48 "CHAM LETTER FINAL Y"
\uAA49 "CHAM LETTER FINAL R"
\uAA4A "CHAM LETTER FINAL L"
\uAA4B "CHAM LETTER FINAL SS"
\uAA4C "CHAM CONSONANT SIGN FINAL M"
\uAA4D "CHAM CONSONANT SIGN FINAL H"
\uAA50 "CHAM DIGIT ZERO"
\uAA51 "CHAM DIGIT ONE"
\uAA52 "CHAM DIGIT TWO"
\uAA53 "CHAM DIGIT THREE"
\uAA54 "CHAM DIGIT FOUR"
\uAA55 "CHAM DIGIT FIVE"
\uAA56 "CHAM DIGIT SIX"
\uAA57 "CHAM DIGIT SEVEN"
\uAA58 "CHAM DIGIT EIGHT"
\uAA59 "CHAM DIGIT NINE"
\uAA5C "CHAM PUNCTUATION SPIRAL"
\uAA5D "CHAM PUNCTUATION DANDA"
\uAA5E "CHAM PUNCTUATION DOUBLE DANDA"
\uAA5F "CHAM PUNCTUATION TRIPLE DANDA"
\uF900 "CJK COMPATIBILITY IDEOGRAPH-F900"
\uF901 "CJK COMPATIBILITY IDEOGRAPH-F901"
\uF902 "CJK COMPATIBILITY IDEOGRAPH-F902"
\uF903 "CJK COMPATIBILITY IDEOGRAPH-F903"
\uF904 "CJK COMPATIBILITY IDEOGRAPH-F904"
\uF905 "CJK COMPATIBILITY IDEOGRAPH-F905"
\uF906 "CJK COMPATIBILITY IDEOGRAPH-F906"
\uF907 "CJK COMPATIBILITY IDEOGRAPH-F907"
\uF908 "CJK COMPATIBILITY IDEOGRAPH-F908"
\uF909 "CJK COMPATIBILITY IDEOGRAPH-F909"
\uF90A "CJK COMPATIBILITY IDEOGRAPH-F90A"
\uF90B "CJK COMPATIBILITY IDEOGRAPH-F90B"
\uF90C "CJK COMPATIBILITY IDEOGRAPH-F90C"
\uF90D "CJK COMPATIBILITY IDEOGRAPH-F90D"
\uF90E "CJK COMPATIBILITY IDEOGRAPH-F90E"
\uF90F "CJK COMPATIBILITY IDEOGRAPH-F90F"
\uF910 "CJK COMPATIBILITY IDEOGRAPH-F910"
\uF911 "CJK COMPATIBILITY IDEOGRAPH-F911"
\uF912 "CJK COMPATIBILITY IDEOGRAPH-F912"
\uF913 "CJK COMPATIBILITY IDEOGRAPH-F913"
\uF914 "CJK COMPATIBILITY IDEOGRAPH-F914"
\uF915 "CJK COMPATIBILITY IDEOGRAPH-F915"
\uF916 "CJK COMPATIBILITY IDEOGRAPH-F916"
\uF917 "CJK COMPATIBILITY IDEOGRAPH-F917"
\uF918 "CJK COMPATIBILITY IDEOGRAPH-F918"
\uF919 "CJK COMPATIBILITY IDEOGRAPH-F919"
\uF91A "CJK COMPATIBILITY IDEOGRAPH-F91A"
\uF91B "CJK COMPATIBILITY IDEOGRAPH-F91B"
\uF91C "CJK COMPATIBILITY IDEOGRAPH-F91C"
\uF91D "CJK COMPATIBILITY IDEOGRAPH-F91D"
\uF91E "CJK COMPATIBILITY IDEOGRAPH-F91E"
\uF91F "CJK COMPATIBILITY IDEOGRAPH-F91F"
\uF920 "CJK COMPATIBILITY IDEOGRAPH-F920"
\uF921 "CJK COMPATIBILITY IDEOGRAPH-F921"
\uF922 "CJK COMPATIBILITY IDEOGRAPH-F922"
\uF923 "CJK COMPATIBILITY IDEOGRAPH-F923"
\uF924 "CJK COMPATIBILITY IDEOGRAPH-F924"
\uF925 "CJK COMPATIBILITY IDEOGRAPH-F925"
\uF926 "CJK COMPATIBILITY IDEOGRAPH-F926"
\uF927 "CJK COMPATIBILITY IDEOGRAPH-F927"
\uF928 "CJK COMPATIBILITY IDEOGRAPH-F928"
\uF929 "CJK COMPATIBILITY IDEOGRAPH-F929"
\uF92A "CJK COMPATIBILITY IDEOGRAPH-F92A"
\uF92B "CJK COMPATIBILITY IDEOGRAPH-F92B"
\uF92C "CJK COMPATIBILITY IDEOGRAPH-F92C"
\uF92D "CJK COMPATIBILITY IDEOGRAPH-F92D"
\uF92E "CJK COMPATIBILITY IDEOGRAPH-F92E"
\uF92F "CJK COMPATIBILITY IDEOGRAPH-F92F"
\uF930 "CJK COMPATIBILITY IDEOGRAPH-F930"
\uF931 "CJK COMPATIBILITY IDEOGRAPH-F931"
\uF932 "CJK COMPATIBILITY IDEOGRAPH-F932"
\uF933 "CJK COMPATIBILITY IDEOGRAPH-F933"
\uF934 "CJK COMPATIBILITY IDEOGRAPH-F934"
\uF935 "CJK COMPATIBILITY IDEOGRAPH-F935"
\uF936 "CJK COMPATIBILITY IDEOGRAPH-F936"
\uF937 "CJK COMPATIBILITY IDEOGRAPH-F937"
\uF938 "CJK COMPATIBILITY IDEOGRAPH-F938"
\uF939 "CJK COMPATIBILITY IDEOGRAPH-F939"
\uF93A "CJK COMPATIBILITY IDEOGRAPH-F93A"
\uF93B "CJK COMPATIBILITY IDEOGRAPH-F93B"
\uF93C "CJK COMPATIBILITY IDEOGRAPH-F93C"
\uF93D "CJK COMPATIBILITY IDEOGRAPH-F93D"
\uF93E "CJK COMPATIBILITY IDEOGRAPH-F93E"
\uF93F "CJK COMPATIBILITY IDEOGRAPH-F93F"
\uF940 "CJK COMPATIBILITY IDEOGRAPH-F940"
\uF941 "CJK COMPATIBILITY IDEOGRAPH-F941"
\uF942 "CJK COMPATIBILITY IDEOGRAPH-F942"
\uF943 "CJK COMPATIBILITY IDEOGRAPH-F943"
\uF944 "CJK COMPATIBILITY IDEOGRAPH-F944"
\uF945 "CJK COMPATIBILITY IDEOGRAPH-F945"
\uF946 "CJK COMPATIBILITY IDEOGRAPH-F946"
\uF947 "CJK COMPATIBILITY IDEOGRAPH-F947"
\uF948 "CJK COMPATIBILITY IDEOGRAPH-F948"
\uF949 "CJK COMPATIBILITY IDEOGRAPH-F949"
\uF94A "CJK COMPATIBILITY IDEOGRAPH-F94A"
\uF94B "CJK COMPATIBILITY IDEOGRAPH-F94B"
\uF94C "CJK COMPATIBILITY IDEOGRAPH-F94C"
\uF94D "CJK COMPATIBILITY IDEOGRAPH-F94D"
\uF94E "CJK COMPATIBILITY IDEOGRAPH-F94E"
\uF94F "CJK COMPATIBILITY IDEOGRAPH-F94F"
\uF950 "CJK COMPATIBILITY IDEOGRAPH-F950"
\uF951 "CJK COMPATIBILITY IDEOGRAPH-F951"
\uF952 "CJK COMPATIBILITY IDEOGRAPH-F952"
\uF953 "CJK COMPATIBILITY IDEOGRAPH-F953"
\uF954 "CJK COMPATIBILITY IDEOGRAPH-F954"
\uF955 "CJK COMPATIBILITY IDEOGRAPH-F955"
\uF956 "CJK COMPATIBILITY IDEOGRAPH-F956"
\uF957 "CJK COMPATIBILITY IDEOGRAPH-F957"
\uF958 "CJK COMPATIBILITY IDEOGRAPH-F958"
\uF959 "CJK COMPATIBILITY IDEOGRAPH-F959"
\uF95A "CJK COMPATIBILITY IDEOGRAPH-F95A"
\uF95B "CJK COMPATIBILITY IDEOGRAPH-F95B"
\uF95C "CJK COMPATIBILITY IDEOGRAPH-F95C"
\uF95D "CJK COMPATIBILITY IDEOGRAPH-F95D"
\uF95E "CJK COMPATIBILITY IDEOGRAPH-F95E"
\uF95F "CJK COMPATIBILITY IDEOGRAPH-F95F"
\uF960 "CJK COMPATIBILITY IDEOGRAPH-F960"
\uF961 "CJK COMPATIBILITY IDEOGRAPH-F961"
\uF962 "CJK COMPATIBILITY IDEOGRAPH-F962"
\uF963 "CJK COMPATIBILITY IDEOGRAPH-F963"
\uF964 "CJK COMPATIBILITY IDEOGRAPH-F964"
\uF965 "CJK COMPATIBILITY IDEOGRAPH-F965"
\uF966 "CJK COMPATIBILITY IDEOGRAPH-F966"
\uF967 "CJK COMPATIBILITY IDEOGRAPH-F967"
\uF968 "CJK COMPATIBILITY IDEOGRAPH-F968"
\uF969 "CJK COMPATIBILITY IDEOGRAPH-F969"
\uF96A "CJK COMPATIBILITY IDEOGRAPH-F96A"
\uF96B "CJK COMPATIBILITY IDEOGRAPH-F96B"
\uF96C "CJK COMPATIBILITY IDEOGRAPH-F96C"
\uF96D "CJK COMPATIBILITY IDEOGRAPH-F96D"
\uF96E "CJK COMPATIBILITY IDEOGRAPH-F96E"
\uF96F "CJK COMPATIBILITY IDEOGRAPH-F96F"
\uF970 "CJK COMPATIBILITY IDEOGRAPH-F970"
\uF971 "CJK COMPATIBILITY IDEOGRAPH-F971"
\uF972 "CJK COMPATIBILITY IDEOGRAPH-F972"
\uF973 "CJK COMPATIBILITY IDEOGRAPH-F973"
\uF974 "CJK COMPATIBILITY IDEOGRAPH-F974"
\uF975 "CJK COMPATIBILITY IDEOGRAPH-F975"
\uF976 "CJK COMPATIBILITY IDEOGRAPH-F976"
\uF977 "CJK COMPATIBILITY IDEOGRAPH-F977"
\uF978 "CJK COMPATIBILITY IDEOGRAPH-F978"
\uF979 "CJK COMPATIBILITY IDEOGRAPH-F979"
\uF97A "CJK COMPATIBILITY IDEOGRAPH-F97A"
\uF97B "CJK COMPATIBILITY IDEOGRAPH-F97B"
\uF97C "CJK COMPATIBILITY IDEOGRAPH-F97C"
\uF97D "CJK COMPATIBILITY IDEOGRAPH-F97D"
\uF97E "CJK COMPATIBILITY IDEOGRAPH-F97E"
\uF97F "CJK COMPATIBILITY IDEOGRAPH-F97F"
\uF980 "CJK COMPATIBILITY IDEOGRAPH-F980"
\uF981 "CJK COMPATIBILITY IDEOGRAPH-F981"
\uF982 "CJK COMPATIBILITY IDEOGRAPH-F982"
\uF983 "CJK COMPATIBILITY IDEOGRAPH-F983"
\uF984 "CJK COMPATIBILITY IDEOGRAPH-F984"
\uF985 "CJK COMPATIBILITY IDEOGRAPH-F985"
\uF986 "CJK COMPATIBILITY IDEOGRAPH-F986"
\uF987 "CJK COMPATIBILITY IDEOGRAPH-F987"
\uF988 "CJK COMPATIBILITY IDEOGRAPH-F988"
\uF989 "CJK COMPATIBILITY IDEOGRAPH-F989"
\uF98A "CJK COMPATIBILITY IDEOGRAPH-F98A"
\uF98B "CJK COMPATIBILITY IDEOGRAPH-F98B"
\uF98C "CJK COMPATIBILITY IDEOGRAPH-F98C"
\uF98D "CJK COMPATIBILITY IDEOGRAPH-F98D"
\uF98E "CJK COMPATIBILITY IDEOGRAPH-F98E"
\uF98F "CJK COMPATIBILITY IDEOGRAPH-F98F"
\uF990 "CJK COMPATIBILITY IDEOGRAPH-F990"
\uF991 "CJK COMPATIBILITY IDEOGRAPH-F991"
\uF992 "CJK COMPATIBILITY IDEOGRAPH-F992"
\uF993 "CJK COMPATIBILITY IDEOGRAPH-F993"
\uF994 "CJK COMPATIBILITY IDEOGRAPH-F994"
\uF995 "CJK COMPATIBILITY IDEOGRAPH-F995"
\uF996 "CJK COMPATIBILITY IDEOGRAPH-F996"
\uF997 "CJK COMPATIBILITY IDEOGRAPH-F997"
\uF998 "CJK COMPATIBILITY IDEOGRAPH-F998"
\uF999 "CJK COMPATIBILITY IDEOGRAPH-F999"
\uF99A "CJK COMPATIBILITY IDEOGRAPH-F99A"
\uF99B "CJK COMPATIBILITY IDEOGRAPH-F99B"
\uF99C "CJK COMPATIBILITY IDEOGRAPH-F99C"
\uF99D "CJK COMPATIBILITY IDEOGRAPH-F99D"
\uF99E "CJK COMPATIBILITY IDEOGRAPH-F99E"
\uF99F "CJK COMPATIBILITY IDEOGRAPH-F99F"
\uF9A0 "CJK COMPATIBILITY IDEOGRAPH-F9A0"
\uF9A1 "CJK COMPATIBILITY IDEOGRAPH-F9A1"
\uF9A2 "CJK COMPATIBILITY IDEOGRAPH-F9A2"
\uF9A3 "CJK COMPATIBILITY IDEOGRAPH-F9A3"
\uF9A4 "CJK COMPATIBILITY IDEOGRAPH-F9A4"
\uF9A5 "CJK COMPATIBILITY IDEOGRAPH-F9A5"
\uF9A6 "CJK COMPATIBILITY IDEOGRAPH-F9A6"
\uF9A7 "CJK COMPATIBILITY IDEOGRAPH-F9A7"
\uF9A8 "CJK COMPATIBILITY IDEOGRAPH-F9A8"
\uF9A9 "CJK COMPATIBILITY IDEOGRAPH-F9A9"
\uF9AA "CJK COMPATIBILITY IDEOGRAPH-F9AA"
\uF9AB "CJK COMPATIBILITY IDEOGRAPH-F9AB"
\uF9AC "CJK COMPATIBILITY IDEOGRAPH-F9AC"
\uF9AD "CJK COMPATIBILITY IDEOGRAPH-F9AD"
\uF9AE "CJK COMPATIBILITY IDEOGRAPH-F9AE"
\uF9AF "CJK COMPATIBILITY IDEOGRAPH-F9AF"
\uF9B0 "CJK COMPATIBILITY IDEOGRAPH-F9B0"
\uF9B1 "CJK COMPATIBILITY IDEOGRAPH-F9B1"
\uF9B2 "CJK COMPATIBILITY IDEOGRAPH-F9B2"
\uF9B3 "CJK COMPATIBILITY IDEOGRAPH-F9B3"
\uF9B4 "CJK COMPATIBILITY IDEOGRAPH-F9B4"
\uF9B5 "CJK COMPATIBILITY IDEOGRAPH-F9B5"
\uF9B6 "CJK COMPATIBILITY IDEOGRAPH-F9B6"
\uF9B7 "CJK COMPATIBILITY IDEOGRAPH-F9B7"
\uF9B8 "CJK COMPATIBILITY IDEOGRAPH-F9B8"
\uF9B9 "CJK COMPATIBILITY IDEOGRAPH-F9B9"
\uF9BA "CJK COMPATIBILITY IDEOGRAPH-F9BA"
\uF9BB "CJK COMPATIBILITY IDEOGRAPH-F9BB"
\uF9BC "CJK COMPATIBILITY IDEOGRAPH-F9BC"
\uF9BD "CJK COMPATIBILITY IDEOGRAPH-F9BD"
\uF9BE "CJK COMPATIBILITY IDEOGRAPH-F9BE"
\uF9BF "CJK COMPATIBILITY IDEOGRAPH-F9BF"
\uF9C0 "CJK COMPATIBILITY IDEOGRAPH-F9C0"
\uF9C1 "CJK COMPATIBILITY IDEOGRAPH-F9C1"
\uF9C2 "CJK COMPATIBILITY IDEOGRAPH-F9C2"
\uF9C3 "CJK COMPATIBILITY IDEOGRAPH-F9C3"
\uF9C4 "CJK COMPATIBILITY IDEOGRAPH-F9C4"
\uF9C5 "CJK COMPATIBILITY IDEOGRAPH-F9C5"
\uF9C6 "CJK COMPATIBILITY IDEOGRAPH-F9C6"
\uF9C7 "CJK COMPATIBILITY IDEOGRAPH-F9C7"
\uF9C8 "CJK COMPATIBILITY IDEOGRAPH-F9C8"
\uF9C9 "CJK COMPATIBILITY IDEOGRAPH-F9C9"
\uF9CA "CJK COMPATIBILITY IDEOGRAPH-F9CA"
\uF9CB "CJK COMPATIBILITY IDEOGRAPH-F9CB"
\uF9CC "CJK COMPATIBILITY IDEOGRAPH-F9CC"
\uF9CD "CJK COMPATIBILITY IDEOGRAPH-F9CD"
\uF9CE "CJK COMPATIBILITY IDEOGRAPH-F9CE"
\uF9CF "CJK COMPATIBILITY IDEOGRAPH-F9CF"
\uF9D0 "CJK COMPATIBILITY IDEOGRAPH-F9D0"
\uF9D1 "CJK COMPATIBILITY IDEOGRAPH-F9D1"
\uF9D2 "CJK COMPATIBILITY IDEOGRAPH-F9D2"
\uF9D3 "CJK COMPATIBILITY IDEOGRAPH-F9D3"
\uF9D4 "CJK COMPATIBILITY IDEOGRAPH-F9D4"
\uF9D5 "CJK COMPATIBILITY IDEOGRAPH-F9D5"
\uF9D6 "CJK COMPATIBILITY IDEOGRAPH-F9D6"
\uF9D7 "CJK COMPATIBILITY IDEOGRAPH-F9D7"
\uF9D8 "CJK COMPATIBILITY IDEOGRAPH-F9D8"
\uF9D9 "CJK COMPATIBILITY IDEOGRAPH-F9D9"
\uF9DA "CJK COMPATIBILITY IDEOGRAPH-F9DA"
\uF9DB "CJK COMPATIBILITY IDEOGRAPH-F9DB"
\uF9DC "CJK COMPATIBILITY IDEOGRAPH-F9DC"
\uF9DD "CJK COMPATIBILITY IDEOGRAPH-F9DD"
\uF9DE "CJK COMPATIBILITY IDEOGRAPH-F9DE"
\uF9DF "CJK COMPATIBILITY IDEOGRAPH-F9DF"
\uF9E0 "CJK COMPATIBILITY IDEOGRAPH-F9E0"
\uF9E1 "CJK COMPATIBILITY IDEOGRAPH-F9E1"
\uF9E2 "CJK COMPATIBILITY IDEOGRAPH-F9E2"
\uF9E3 "CJK COMPATIBILITY IDEOGRAPH-F9E3"
\uF9E4 "CJK COMPATIBILITY IDEOGRAPH-F9E4"
\uF9E5 "CJK COMPATIBILITY IDEOGRAPH-F9E5"
\uF9E6 "CJK COMPATIBILITY IDEOGRAPH-F9E6"
\uF9E7 "CJK COMPATIBILITY IDEOGRAPH-F9E7"
\uF9E8 "CJK COMPATIBILITY IDEOGRAPH-F9E8"
\uF9E9 "CJK COMPATIBILITY IDEOGRAPH-F9E9"
\uF9EA "CJK COMPATIBILITY IDEOGRAPH-F9EA"
\uF9EB "CJK COMPATIBILITY IDEOGRAPH-F9EB"
\uF9EC "CJK COMPATIBILITY IDEOGRAPH-F9EC"
\uF9ED "CJK COMPATIBILITY IDEOGRAPH-F9ED"
\uF9EE "CJK COMPATIBILITY IDEOGRAPH-F9EE"
\uF9EF "CJK COMPATIBILITY IDEOGRAPH-F9EF"
\uF9F0 "CJK COMPATIBILITY IDEOGRAPH-F9F0"
\uF9F1 "CJK COMPATIBILITY IDEOGRAPH-F9F1"
\uF9F2 "CJK COMPATIBILITY IDEOGRAPH-F9F2"
\uF9F3 "CJK COMPATIBILITY IDEOGRAPH-F9F3"
\uF9F4 "CJK COMPATIBILITY IDEOGRAPH-F9F4"
\uF9F5 "CJK COMPATIBILITY IDEOGRAPH-F9F5"
\uF9F6 "CJK COMPATIBILITY IDEOGRAPH-F9F6"
\uF9F7 "CJK COMPATIBILITY IDEOGRAPH-F9F7"
\uF9F8 "CJK COMPATIBILITY IDEOGRAPH-F9F8"
\uF9F9 "CJK COMPATIBILITY IDEOGRAPH-F9F9"
\uF9FA "CJK COMPATIBILITY IDEOGRAPH-F9FA"
\uF9FB "CJK COMPATIBILITY IDEOGRAPH-F9FB"
\uF9FC "CJK COMPATIBILITY IDEOGRAPH-F9FC"
\uF9FD "CJK COMPATIBILITY IDEOGRAPH-F9FD"
\uF9FE "CJK COMPATIBILITY IDEOGRAPH-F9FE"
\uF9FF "CJK COMPATIBILITY IDEOGRAPH-F9FF"
\uFA00 "CJK COMPATIBILITY IDEOGRAPH-FA00"
\uFA01 "CJK COMPATIBILITY IDEOGRAPH-FA01"
\uFA02 "CJK COMPATIBILITY IDEOGRAPH-FA02"
\uFA03 "CJK COMPATIBILITY IDEOGRAPH-FA03"
\uFA04 "CJK COMPATIBILITY IDEOGRAPH-FA04"
\uFA05 "CJK COMPATIBILITY IDEOGRAPH-FA05"
\uFA06 "CJK COMPATIBILITY IDEOGRAPH-FA06"
\uFA07 "CJK COMPATIBILITY IDEOGRAPH-FA07"
\uFA08 "CJK COMPATIBILITY IDEOGRAPH-FA08"
\uFA09 "CJK COMPATIBILITY IDEOGRAPH-FA09"
\uFA0A "CJK COMPATIBILITY IDEOGRAPH-FA0A"
\uFA0B "CJK COMPATIBILITY IDEOGRAPH-FA0B"
\uFA0C "CJK COMPATIBILITY IDEOGRAPH-FA0C"
\uFA0D "CJK COMPATIBILITY IDEOGRAPH-FA0D"
\uFA0E "CJK COMPATIBILITY IDEOGRAPH-FA0E"
\uFA0F "CJK COMPATIBILITY IDEOGRAPH-FA0F"
\uFA10 "CJK COMPATIBILITY IDEOGRAPH-FA10"
\uFA11 "CJK COMPATIBILITY IDEOGRAPH-FA11"
\uFA12 "CJK COMPATIBILITY IDEOGRAPH-FA12"
\uFA13 "CJK COMPATIBILITY IDEOGRAPH-FA13"
\uFA14 "CJK COMPATIBILITY IDEOGRAPH-FA14"
\uFA15 "CJK COMPATIBILITY IDEOGRAPH-FA15"
\uFA16 "CJK COMPATIBILITY IDEOGRAPH-FA16"
\uFA17 "CJK COMPATIBILITY IDEOGRAPH-FA17"
\uFA18 "CJK COMPATIBILITY IDEOGRAPH-FA18"
\uFA19 "CJK COMPATIBILITY IDEOGRAPH-FA19"
\uFA1A "CJK COMPATIBILITY IDEOGRAPH-FA1A"
\uFA1B "CJK COMPATIBILITY IDEOGRAPH-FA1B"
\uFA1C "CJK COMPATIBILITY IDEOGRAPH-FA1C"
\uFA1D "CJK COMPATIBILITY IDEOGRAPH-FA1D"
\uFA1E "CJK COMPATIBILITY IDEOGRAPH-FA1E"
\uFA1F "CJK COMPATIBILITY IDEOGRAPH-FA1F"
\uFA20 "CJK COMPATIBILITY IDEOGRAPH-FA20"
\uFA21 "CJK COMPATIBILITY IDEOGRAPH-FA21"
\uFA22 "CJK COMPATIBILITY IDEOGRAPH-FA22"
\uFA23 "CJK COMPATIBILITY IDEOGRAPH-FA23"
\uFA24 "CJK COMPATIBILITY IDEOGRAPH-FA24"
\uFA25 "CJK COMPATIBILITY IDEOGRAPH-FA25"
\uFA26 "CJK COMPATIBILITY IDEOGRAPH-FA26"
\uFA27 "CJK COMPATIBILITY IDEOGRAPH-FA27"
\uFA28 "CJK COMPATIBILITY IDEOGRAPH-FA28"
\uFA29 "CJK COMPATIBILITY IDEOGRAPH-FA29"
\uFA2A "CJK COMPATIBILITY IDEOGRAPH-FA2A"
\uFA2B "CJK COMPATIBILITY IDEOGRAPH-FA2B"
\uFA2C "CJK COMPATIBILITY IDEOGRAPH-FA2C"
\uFA2D "CJK COMPATIBILITY IDEOGRAPH-FA2D"
\uFA30 "CJK COMPATIBILITY IDEOGRAPH-FA30"
\uFA31 "CJK COMPATIBILITY IDEOGRAPH-FA31"
\uFA32 "CJK COMPATIBILITY IDEOGRAPH-FA32"
\uFA33 "CJK COMPATIBILITY IDEOGRAPH-FA33"
\uFA34 "CJK COMPATIBILITY IDEOGRAPH-FA34"
\uFA35 "CJK COMPATIBILITY IDEOGRAPH-FA35"
\uFA36 "CJK COMPATIBILITY IDEOGRAPH-FA36"
\uFA37 "CJK COMPATIBILITY IDEOGRAPH-FA37"
\uFA38 "CJK COMPATIBILITY IDEOGRAPH-FA38"
\uFA39 "CJK COMPATIBILITY IDEOGRAPH-FA39"
\uFA3A "CJK COMPATIBILITY IDEOGRAPH-FA3A"
\uFA3B "CJK COMPATIBILITY IDEOGRAPH-FA3B"
\uFA3C "CJK COMPATIBILITY IDEOGRAPH-FA3C"
\uFA3D "CJK COMPATIBILITY IDEOGRAPH-FA3D"
\uFA3E "CJK COMPATIBILITY IDEOGRAPH-FA3E"
\uFA3F "CJK COMPATIBILITY IDEOGRAPH-FA3F"
\uFA40 "CJK COMPATIBILITY IDEOGRAPH-FA40"
\uFA41 "CJK COMPATIBILITY IDEOGRAPH-FA41"
\uFA42 "CJK COMPATIBILITY IDEOGRAPH-FA42"
\uFA43 "CJK COMPATIBILITY IDEOGRAPH-FA43"
\uFA44 "CJK COMPATIBILITY IDEOGRAPH-FA44"
\uFA45 "CJK COMPATIBILITY IDEOGRAPH-FA45"
\uFA46 "CJK COMPATIBILITY IDEOGRAPH-FA46"
\uFA47 "CJK COMPATIBILITY IDEOGRAPH-FA47"
\uFA48 "CJK COMPATIBILITY IDEOGRAPH-FA48"
\uFA49 "CJK COMPATIBILITY IDEOGRAPH-FA49"
\uFA4A "CJK COMPATIBILITY IDEOGRAPH-FA4A"
\uFA4B "CJK COMPATIBILITY IDEOGRAPH-FA4B"
\uFA4C "CJK COMPATIBILITY IDEOGRAPH-FA4C"
\uFA4D "CJK COMPATIBILITY IDEOGRAPH-FA4D"
\uFA4E "CJK COMPATIBILITY IDEOGRAPH-FA4E"
\uFA4F "CJK COMPATIBILITY IDEOGRAPH-FA4F"
\uFA50 "CJK COMPATIBILITY IDEOGRAPH-FA50"
\uFA51 "CJK COMPATIBILITY IDEOGRAPH-FA51"
\uFA52 "CJK COMPATIBILITY IDEOGRAPH-FA52"
\uFA53 "CJK COMPATIBILITY IDEOGRAPH-FA53"
\uFA54 "CJK COMPATIBILITY IDEOGRAPH-FA54"
\uFA55 "CJK COMPATIBILITY IDEOGRAPH-FA55"
\uFA56 "CJK COMPATIBILITY IDEOGRAPH-FA56"
\uFA57 "CJK COMPATIBILITY IDEOGRAPH-FA57"
\uFA58 "CJK COMPATIBILITY IDEOGRAPH-FA58"
\uFA59 "CJK COMPATIBILITY IDEOGRAPH-FA59"
\uFA5A "CJK COMPATIBILITY IDEOGRAPH-FA5A"
\uFA5B "CJK COMPATIBILITY IDEOGRAPH-FA5B"
\uFA5C "CJK COMPATIBILITY IDEOGRAPH-FA5C"
\uFA5D "CJK COMPATIBILITY IDEOGRAPH-FA5D"
\uFA5E "CJK COMPATIBILITY IDEOGRAPH-FA5E"
\uFA5F "CJK COMPATIBILITY IDEOGRAPH-FA5F"
\uFA60 "CJK COMPATIBILITY IDEOGRAPH-FA60"
\uFA61 "CJK COMPATIBILITY IDEOGRAPH-FA61"
\uFA62 "CJK COMPATIBILITY IDEOGRAPH-FA62"
\uFA63 "CJK COMPATIBILITY IDEOGRAPH-FA63"
\uFA64 "CJK COMPATIBILITY IDEOGRAPH-FA64"
\uFA65 "CJK COMPATIBILITY IDEOGRAPH-FA65"
\uFA66 "CJK COMPATIBILITY IDEOGRAPH-FA66"
\uFA67 "CJK COMPATIBILITY IDEOGRAPH-FA67"
\uFA68 "CJK COMPATIBILITY IDEOGRAPH-FA68"
\uFA69 "CJK COMPATIBILITY IDEOGRAPH-FA69"
\uFA6A "CJK COMPATIBILITY IDEOGRAPH-FA6A"
\uFA70 "CJK COMPATIBILITY IDEOGRAPH-FA70"
\uFA71 "CJK COMPATIBILITY IDEOGRAPH-FA71"
\uFA72 "CJK COMPATIBILITY IDEOGRAPH-FA72"
\uFA73 "CJK COMPATIBILITY IDEOGRAPH-FA73"
\uFA74 "CJK COMPATIBILITY IDEOGRAPH-FA74"
\uFA75 "CJK COMPATIBILITY IDEOGRAPH-FA75"
\uFA76 "CJK COMPATIBILITY IDEOGRAPH-FA76"
\uFA77 "CJK COMPATIBILITY IDEOGRAPH-FA77"
\uFA78 "CJK COMPATIBILITY IDEOGRAPH-FA78"
\uFA79 "CJK COMPATIBILITY IDEOGRAPH-FA79"
\uFA7A "CJK COMPATIBILITY IDEOGRAPH-FA7A"
\uFA7B "CJK COMPATIBILITY IDEOGRAPH-FA7B"
\uFA7C "CJK COMPATIBILITY IDEOGRAPH-FA7C"
\uFA7D "CJK COMPATIBILITY IDEOGRAPH-FA7D"
\uFA7E "CJK COMPATIBILITY IDEOGRAPH-FA7E"
\uFA7F "CJK COMPATIBILITY IDEOGRAPH-FA7F"
\uFA80 "CJK COMPATIBILITY IDEOGRAPH-FA80"
\uFA81 "CJK COMPATIBILITY IDEOGRAPH-FA81"
\uFA82 "CJK COMPATIBILITY IDEOGRAPH-FA82"
\uFA83 "CJK COMPATIBILITY IDEOGRAPH-FA83"
\uFA84 "CJK COMPATIBILITY IDEOGRAPH-FA84"
\uFA85 "CJK COMPATIBILITY IDEOGRAPH-FA85"
\uFA86 "CJK COMPATIBILITY IDEOGRAPH-FA86"
\uFA87 "CJK COMPATIBILITY IDEOGRAPH-FA87"
\uFA88 "CJK COMPATIBILITY IDEOGRAPH-FA88"
\uFA89 "CJK COMPATIBILITY IDEOGRAPH-FA89"
\uFA8A "CJK COMPATIBILITY IDEOGRAPH-FA8A"
\uFA8B "CJK COMPATIBILITY IDEOGRAPH-FA8B"
\uFA8C "CJK COMPATIBILITY IDEOGRAPH-FA8C"
\uFA8D "CJK COMPATIBILITY IDEOGRAPH-FA8D"
\uFA8E "CJK COMPATIBILITY IDEOGRAPH-FA8E"
\uFA8F "CJK COMPATIBILITY IDEOGRAPH-FA8F"
\uFA90 "CJK COMPATIBILITY IDEOGRAPH-FA90"
\uFA91 "CJK COMPATIBILITY IDEOGRAPH-FA91"
\uFA92 "CJK COMPATIBILITY IDEOGRAPH-FA92"
\uFA93 "CJK COMPATIBILITY IDEOGRAPH-FA93"
\uFA94 "CJK COMPATIBILITY IDEOGRAPH-FA94"
\uFA95 "CJK COMPATIBILITY IDEOGRAPH-FA95"
\uFA96 "CJK COMPATIBILITY IDEOGRAPH-FA96"
\uFA97 "CJK COMPATIBILITY IDEOGRAPH-FA97"
\uFA98 "CJK COMPATIBILITY IDEOGRAPH-FA98"
\uFA99 "CJK COMPATIBILITY IDEOGRAPH-FA99"
\uFA9A "CJK COMPATIBILITY IDEOGRAPH-FA9A"
\uFA9B "CJK COMPATIBILITY IDEOGRAPH-FA9B"
\uFA9C "CJK COMPATIBILITY IDEOGRAPH-FA9C"
\uFA9D "CJK COMPATIBILITY IDEOGRAPH-FA9D"
\uFA9E "CJK COMPATIBILITY IDEOGRAPH-FA9E"
\uFA9F "CJK COMPATIBILITY IDEOGRAPH-FA9F"
\uFAA0 "CJK COMPATIBILITY IDEOGRAPH-FAA0"
\uFAA1 "CJK COMPATIBILITY IDEOGRAPH-FAA1"
\uFAA2 "CJK COMPATIBILITY IDEOGRAPH-FAA2"
\uFAA3 "CJK COMPATIBILITY IDEOGRAPH-FAA3"
\uFAA4 "CJK COMPATIBILITY IDEOGRAPH-FAA4"
\uFAA5 "CJK COMPATIBILITY IDEOGRAPH-FAA5"
\uFAA6 "CJK COMPATIBILITY IDEOGRAPH-FAA6"
\uFAA7 "CJK COMPATIBILITY IDEOGRAPH-FAA7"
\uFAA8 "CJK COMPATIBILITY IDEOGRAPH-FAA8"
\uFAA9 "CJK COMPATIBILITY IDEOGRAPH-FAA9"
\uFAAA "CJK COMPATIBILITY IDEOGRAPH-FAAA"
\uFAAB "CJK COMPATIBILITY IDEOGRAPH-FAAB"
\uFAAC "CJK COMPATIBILITY IDEOGRAPH-FAAC"
\uFAAD "CJK COMPATIBILITY IDEOGRAPH-FAAD"
\uFAAE "CJK COMPATIBILITY IDEOGRAPH-FAAE"
\uFAAF "CJK COMPATIBILITY IDEOGRAPH-FAAF"
\uFAB0 "CJK COMPATIBILITY IDEOGRAPH-FAB0"
\uFAB1 "CJK COMPATIBILITY IDEOGRAPH-FAB1"
\uFAB2 "CJK COMPATIBILITY IDEOGRAPH-FAB2"
\uFAB3 "CJK COMPATIBILITY IDEOGRAPH-FAB3"
\uFAB4 "CJK COMPATIBILITY IDEOGRAPH-FAB4"
\uFAB5 "CJK COMPATIBILITY IDEOGRAPH-FAB5"
\uFAB6 "CJK COMPATIBILITY IDEOGRAPH-FAB6"
\uFAB7 "CJK COMPATIBILITY IDEOGRAPH-FAB7"
\uFAB8 "CJK COMPATIBILITY IDEOGRAPH-FAB8"
\uFAB9 "CJK COMPATIBILITY IDEOGRAPH-FAB9"
\uFABA "CJK COMPATIBILITY IDEOGRAPH-FABA"
\uFABB "CJK COMPATIBILITY IDEOGRAPH-FABB"
\uFABC "CJK COMPATIBILITY IDEOGRAPH-FABC"
\uFABD "CJK COMPATIBILITY IDEOGRAPH-FABD"
\uFABE "CJK COMPATIBILITY IDEOGRAPH-FABE"
\uFABF "CJK COMPATIBILITY IDEOGRAPH-FABF"
\uFAC0 "CJK COMPATIBILITY IDEOGRAPH-FAC0"
\uFAC1 "CJK COMPATIBILITY IDEOGRAPH-FAC1"
\uFAC2 "CJK COMPATIBILITY IDEOGRAPH-FAC2"
\uFAC3 "CJK COMPATIBILITY IDEOGRAPH-FAC3"
\uFAC4 "CJK COMPATIBILITY IDEOGRAPH-FAC4"
\uFAC5 "CJK COMPATIBILITY IDEOGRAPH-FAC5"
\uFAC6 "CJK COMPATIBILITY IDEOGRAPH-FAC6"
\uFAC7 "CJK COMPATIBILITY IDEOGRAPH-FAC7"
\uFAC8 "CJK COMPATIBILITY IDEOGRAPH-FAC8"
\uFAC9 "CJK COMPATIBILITY IDEOGRAPH-FAC9"
\uFACA "CJK COMPATIBILITY IDEOGRAPH-FACA"
\uFACB "CJK COMPATIBILITY IDEOGRAPH-FACB"
\uFACC "CJK COMPATIBILITY IDEOGRAPH-FACC"
\uFACD "CJK COMPATIBILITY IDEOGRAPH-FACD"
\uFACE "CJK COMPATIBILITY IDEOGRAPH-FACE"
\uFACF "CJK COMPATIBILITY IDEOGRAPH-FACF"
\uFAD0 "CJK COMPATIBILITY IDEOGRAPH-FAD0"
\uFAD1 "CJK COMPATIBILITY IDEOGRAPH-FAD1"
\uFAD2 "CJK COMPATIBILITY IDEOGRAPH-FAD2"
\uFAD3 "CJK COMPATIBILITY IDEOGRAPH-FAD3"
\uFAD4 "CJK COMPATIBILITY IDEOGRAPH-FAD4"
\uFAD5 "CJK COMPATIBILITY IDEOGRAPH-FAD5"
\uFAD6 "CJK COMPATIBILITY IDEOGRAPH-FAD6"
\uFAD7 "CJK COMPATIBILITY IDEOGRAPH-FAD7"
\uFAD8 "CJK COMPATIBILITY IDEOGRAPH-FAD8"
\uFAD9 "CJK COMPATIBILITY IDEOGRAPH-FAD9"
\uFB00 "LATIN SMALL LIGATURE FF"
\uFB01 "LATIN SMALL LIGATURE FI"
\uFB02 "LATIN SMALL LIGATURE FL"
\uFB03 "LATIN SMALL LIGATURE FFI"
\uFB04 "LATIN SMALL LIGATURE FFL"
\uFB05 "LATIN SMALL LIGATURE LONG S T"
\uFB06 "LATIN SMALL LIGATURE ST"
\uFB13 "ARMENIAN SMALL LIGATURE MEN NOW"
\uFB14 "ARMENIAN SMALL LIGATURE MEN ECH"
\uFB15 "ARMENIAN SMALL LIGATURE MEN INI"
\uFB16 "ARMENIAN SMALL LIGATURE VEW NOW"
\uFB17 "ARMENIAN SMALL LIGATURE MEN XEH"
\uFB1D "HEBREW LETTER YOD WITH HIRIQ"
\uFB1E "HEBREW POINT JUDEO-SPANISH VARIKA"
\uFB1F "HEBREW LIGATURE YIDDISH YOD YOD PATAH"
\uFB20 "HEBREW LETTER ALTERNATIVE AYIN"
\uFB21 "HEBREW LETTER WIDE ALEF"
\uFB22 "HEBREW LETTER WIDE DALET"
\uFB23 "HEBREW LETTER WIDE HE"
\uFB24 "HEBREW LETTER WIDE KAF"
\uFB25 "HEBREW LETTER WIDE LAMED"
\uFB26 "HEBREW LETTER WIDE FINAL MEM"
\uFB27 "HEBREW LETTER WIDE RESH"
\uFB28 "HEBREW LETTER WIDE TAV"
\uFB29 "HEBREW LETTER ALTERNATIVE PLUS SIGN"
\uFB2A "HEBREW LETTER SHIN WITH SHIN DOT"
\uFB2B "HEBREW LETTER SHIN WITH SIN DOT"
\uFB2C "HEBREW LETTER SHIN WITH DAGESH AND SHIN DOT"
\uFB2D "HEBREW LETTER SHIN WITH DAGESH AND SIN DOT"
\uFB2E "HEBREW LETTER ALEF WITH PATAH"
\uFB2F "HEBREW LETTER ALEF WITH QAMATS"
\uFB30 "HEBREW LETTER ALEF WITH MAPIQ"
\uFB31 "HEBREW LETTER BET WITH DAGESH"
\uFB32 "HEBREW LETTER GIMEL WITH DAGESH"
\uFB33 "HEBREW LETTER DALET WITH DAGESH"
\uFB34 "HEBREW LETTER HE WITH MAPIQ"
\uFB35 "HEBREW LETTER VAV WITH DAGESH"
\uFB36 "HEBREW LETTER ZAYIN WITH DAGESH"
\uFB38 "HEBREW LETTER TET WITH DAGESH"
\uFB39 "HEBREW LETTER YOD WITH DAGESH"
\uFB3A "HEBREW LETTER FINAL KAF WITH DAGESH"
\uFB3B "HEBREW LETTER KAF WITH DAGESH"
\uFB3C "HEBREW LETTER LAMED WITH DAGESH"
\uFB3E "HEBREW LETTER MEM WITH DAGESH"
\uFB40 "HEBREW LETTER NUN WITH DAGESH"
\uFB41 "HEBREW LETTER SAMEKH WITH DAGESH"
\uFB43 "HEBREW LETTER FINAL PE WITH DAGESH"
\uFB44 "HEBREW LETTER PE WITH DAGESH"
\uFB46 "HEBREW LETTER TSADI WITH DAGESH"
\uFB47 "HEBREW LETTER QOF WITH DAGESH"
\uFB48 "HEBREW LETTER RESH WITH DAGESH"
\uFB49 "HEBREW LETTER SHIN WITH DAGESH"
\uFB4A "HEBREW LETTER TAV WITH DAGESH"
\uFB4B "HEBREW LETTER VAV WITH HOLAM"
\uFB4C "HEBREW LETTER BET WITH RAFE"
\uFB4D "HEBREW LETTER KAF WITH RAFE"
\uFB4E "HEBREW LETTER PE WITH RAFE"
\uFB4F "HEBREW LIGATURE ALEF LAMED"
\uFB50 "ARABIC LETTER ALEF WASLA ISOLATED FORM"
\uFB51 "ARABIC LETTER ALEF WASLA FINAL FORM"
\uFB52 "ARABIC LETTER BEEH ISOLATED FORM"
\uFB53 "ARABIC LETTER BEEH FINAL FORM"
\uFB54 "ARABIC LETTER BEEH INITIAL FORM"
\uFB55 "ARABIC LETTER BEEH MEDIAL FORM"
\uFB56 "ARABIC LETTER PEH ISOLATED FORM"
\uFB57 "ARABIC LETTER PEH FINAL FORM"
\uFB58 "ARABIC LETTER PEH INITIAL FORM"
\uFB59 "ARABIC LETTER PEH MEDIAL FORM"
\uFB5A "ARABIC LETTER BEHEH ISOLATED FORM"
\uFB5B "ARABIC LETTER BEHEH FINAL FORM"
\uFB5C "ARABIC LETTER BEHEH INITIAL FORM"
\uFB5D "ARABIC LETTER BEHEH MEDIAL FORM"
\uFB5E "ARABIC LETTER TTEHEH ISOLATED FORM"
\uFB5F "ARABIC LETTER TTEHEH FINAL FORM"
\uFB60 "ARABIC LETTER TTEHEH INITIAL FORM"
\uFB61 "ARABIC LETTER TTEHEH MEDIAL FORM"
\uFB62 "ARABIC LETTER TEHEH ISOLATED FORM"
\uFB63 "ARABIC LETTER TEHEH FINAL FORM"
\uFB64 "ARABIC LETTER TEHEH INITIAL FORM"
\uFB65 "ARABIC LETTER TEHEH MEDIAL FORM"
\uFB66 "ARABIC LETTER TTEH ISOLATED FORM"
\uFB67 "ARABIC LETTER TTEH FINAL FORM"
\uFB68 "ARABIC LETTER TTEH INITIAL FORM"
\uFB69 "ARABIC LETTER TTEH MEDIAL FORM"
\uFB6A "ARABIC LETTER VEH ISOLATED FORM"
\uFB6B "ARABIC LETTER VEH FINAL FORM"
\uFB6C "ARABIC LETTER VEH INITIAL FORM"
\uFB6D "ARABIC LETTER VEH MEDIAL FORM"
\uFB6E "ARABIC LETTER PEHEH ISOLATED FORM"
\uFB6F "ARABIC LETTER PEHEH FINAL FORM"
\uFB70 "ARABIC LETTER PEHEH INITIAL FORM"
\uFB71 "ARABIC LETTER PEHEH MEDIAL FORM"
\uFB72 "ARABIC LETTER DYEH ISOLATED FORM"
\uFB73 "ARABIC LETTER DYEH FINAL FORM"
\uFB74 "ARABIC LETTER DYEH INITIAL FORM"
\uFB75 "ARABIC LETTER DYEH MEDIAL FORM"
\uFB76 "ARABIC LETTER NYEH ISOLATED FORM"
\uFB77 "ARABIC LETTER NYEH FINAL FORM"
\uFB78 "ARABIC LETTER NYEH INITIAL FORM"
\uFB79 "ARABIC LETTER NYEH MEDIAL FORM"
\uFB7A "ARABIC LETTER TCHEH ISOLATED FORM"
\uFB7B "ARABIC LETTER TCHEH FINAL FORM"
\uFB7C "ARABIC LETTER TCHEH INITIAL FORM"
\uFB7D "ARABIC LETTER TCHEH MEDIAL FORM"
\uFB7E "ARABIC LETTER TCHEHEH ISOLATED FORM"
\uFB7F "ARABIC LETTER TCHEHEH FINAL FORM"
\uFB80 "ARABIC LETTER TCHEHEH INITIAL FORM"
\uFB81 "ARABIC LETTER TCHEHEH MEDIAL FORM"
\uFB82 "ARABIC LETTER DDAHAL ISOLATED FORM"
\uFB83 "ARABIC LETTER DDAHAL FINAL FORM"
\uFB84 "ARABIC LETTER DAHAL ISOLATED FORM"
\uFB85 "ARABIC LETTER DAHAL FINAL FORM"
\uFB86 "ARABIC LETTER DUL ISOLATED FORM"
\uFB87 "ARABIC LETTER DUL FINAL FORM"
\uFB88 "ARABIC LETTER DDAL ISOLATED FORM"
\uFB89 "ARABIC LETTER DDAL FINAL FORM"
\uFB8A "ARABIC LETTER JEH ISOLATED FORM"
\uFB8B "ARABIC LETTER JEH FINAL FORM"
\uFB8C "ARABIC LETTER RREH ISOLATED FORM"
\uFB8D "ARABIC LETTER RREH FINAL FORM"
\uFB8E "ARABIC LETTER KEHEH ISOLATED FORM"
\uFB8F "ARABIC LETTER KEHEH FINAL FORM"
\uFB90 "ARABIC LETTER KEHEH INITIAL FORM"
\uFB91 "ARABIC LETTER KEHEH MEDIAL FORM"
\uFB92 "ARABIC LETTER GAF ISOLATED FORM"
\uFB93 "ARABIC LETTER GAF FINAL FORM"
\uFB94 "ARABIC LETTER GAF INITIAL FORM"
\uFB95 "ARABIC LETTER GAF MEDIAL FORM"
\uFB96 "ARABIC LETTER GUEH ISOLATED FORM"
\uFB97 "ARABIC LETTER GUEH FINAL FORM"
\uFB98 "ARABIC LETTER GUEH INITIAL FORM"
\uFB99 "ARABIC LETTER GUEH MEDIAL FORM"
\uFB9A "ARABIC LETTER NGOEH ISOLATED FORM"
\uFB9B "ARABIC LETTER NGOEH FINAL FORM"
\uFB9C "ARABIC LETTER NGOEH INITIAL FORM"
\uFB9D "ARABIC LETTER NGOEH MEDIAL FORM"
\uFB9E "ARABIC LETTER NOON GHUNNA ISOLATED FORM"
\uFB9F "ARABIC LETTER NOON GHUNNA FINAL FORM"
\uFBA0 "ARABIC LETTER RNOON ISOLATED FORM"
\uFBA1 "ARABIC LETTER RNOON FINAL FORM"
\uFBA2 "ARABIC LETTER RNOON INITIAL FORM"
\uFBA3 "ARABIC LETTER RNOON MEDIAL FORM"
\uFBA4 "ARABIC LETTER HEH WITH YEH ABOVE ISOLATED FORM"
\uFBA5 "ARABIC LETTER HEH WITH YEH ABOVE FINAL FORM"
\uFBA6 "ARABIC LETTER HEH GOAL ISOLATED FORM"
\uFBA7 "ARABIC LETTER HEH GOAL FINAL FORM"
\uFBA8 "ARABIC LETTER HEH GOAL INITIAL FORM"
\uFBA9 "ARABIC LETTER HEH GOAL MEDIAL FORM"
\uFBAA "ARABIC LETTER HEH DOACHASHMEE ISOLATED FORM"
\uFBAB "ARABIC LETTER HEH DOACHASHMEE FINAL FORM"
\uFBAC "ARABIC LETTER HEH DOACHASHMEE INITIAL FORM"
\uFBAD "ARABIC LETTER HEH DOACHASHMEE MEDIAL FORM"
\uFBAE "ARABIC LETTER YEH BARREE ISOLATED FORM"
\uFBAF "ARABIC LETTER YEH BARREE FINAL FORM"
\uFBB0 "ARABIC LETTER YEH BARREE WITH HAMZA ABOVE ISOLATED FORM"
\uFBB1 "ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM"
\uFBD3 "ARABIC LETTER NG ISOLATED FORM"
\uFBD4 "ARABIC LETTER NG FINAL FORM"
\uFBD5 "ARABIC LETTER NG INITIAL FORM"
\uFBD6 "ARABIC LETTER NG MEDIAL FORM"
\uFBD7 "ARABIC LETTER U ISOLATED FORM"
\uFBD8 "ARABIC LETTER U FINAL FORM"
\uFBD9 "ARABIC LETTER OE ISOLATED FORM"
\uFBDA "ARABIC LETTER OE FINAL FORM"
\uFBDB "ARABIC LETTER YU ISOLATED FORM"
\uFBDC "ARABIC LETTER YU FINAL FORM"
\uFBDD "ARABIC LETTER U WITH HAMZA ABOVE ISOLATED FORM"
\uFBDE "ARABIC LETTER VE ISOLATED FORM"
\uFBDF "ARABIC LETTER VE FINAL FORM"
\uFBE0 "ARABIC LETTER KIRGHIZ OE ISOLATED FORM"
\uFBE1 "ARABIC LETTER KIRGHIZ OE FINAL FORM"
\uFBE2 "ARABIC LETTER KIRGHIZ YU ISOLATED FORM"
\uFBE3 "ARABIC LETTER KIRGHIZ YU FINAL FORM"
\uFBE4 "ARABIC LETTER E ISOLATED FORM"
\uFBE5 "ARABIC LETTER E FINAL FORM"
\uFBE6 "ARABIC LETTER E INITIAL FORM"
\uFBE7 "ARABIC LETTER E MEDIAL FORM"
\uFBE8 "ARABIC LETTER UIGHUR KAZAKH KIRGHIZ ALEF MAKSURA INITIAL FORM"
\uFBE9 "ARABIC LETTER UIGHUR KAZAKH KIRGHIZ ALEF MAKSURA MEDIAL FORM"
\uFBEA "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF ISOLATED FORM"
\uFBEB "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF FINAL FORM"
\uFBEC "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH AE ISOLATED FORM"
\uFBED "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH AE FINAL FORM"
\uFBEE "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH WAW ISOLATED FORM"
\uFBEF "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH WAW FINAL FORM"
\uFBF0 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH U ISOLATED FORM"
\uFBF1 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH U FINAL FORM"
\uFBF2 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH OE ISOLATED FORM"
\uFBF3 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH OE FINAL FORM"
\uFBF4 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YU ISOLATED FORM"
\uFBF5 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YU FINAL FORM"
\uFBF6 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E ISOLATED FORM"
\uFBF7 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E FINAL FORM"
\uFBF8 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH E INITIAL FORM"
\uFBF9 "ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA ISOLATED FORM"
\uFBFA "ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA FINAL FORM"
\uFBFB "ARABIC LIGATURE UIGHUR KIRGHIZ YEH WITH HAMZA ABOVE WITH ALEF MAKSURA INITIAL FORM"
\uFBFC "ARABIC LETTER FARSI YEH ISOLATED FORM"
\uFBFD "ARABIC LETTER FARSI YEH FINAL FORM"
\uFBFE "ARABIC LETTER FARSI YEH INITIAL FORM"
\uFBFF "ARABIC LETTER FARSI YEH MEDIAL FORM"
\uFC00 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH JEEM ISOLATED FORM"
\uFC01 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HAH ISOLATED FORM"
\uFC02 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM ISOLATED FORM"
\uFC03 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF MAKSURA ISOLATED FORM"
\uFC04 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YEH ISOLATED FORM"
\uFC05 "ARABIC LIGATURE BEH WITH JEEM ISOLATED FORM"
\uFC06 "ARABIC LIGATURE BEH WITH HAH ISOLATED FORM"
\uFC07 "ARABIC LIGATURE BEH WITH KHAH ISOLATED FORM"
\uFC08 "ARABIC LIGATURE BEH WITH MEEM ISOLATED FORM"
\uFC09 "ARABIC LIGATURE BEH WITH ALEF MAKSURA ISOLATED FORM"
\uFC0A "ARABIC LIGATURE BEH WITH YEH ISOLATED FORM"
\uFC0B "ARABIC LIGATURE TEH WITH JEEM ISOLATED FORM"
\uFC0C "ARABIC LIGATURE TEH WITH HAH ISOLATED FORM"
\uFC0D "ARABIC LIGATURE TEH WITH KHAH ISOLATED FORM"
\uFC0E "ARABIC LIGATURE TEH WITH MEEM ISOLATED FORM"
\uFC0F "ARABIC LIGATURE TEH WITH ALEF MAKSURA ISOLATED FORM"
\uFC10 "ARABIC LIGATURE TEH WITH YEH ISOLATED FORM"
\uFC11 "ARABIC LIGATURE THEH WITH JEEM ISOLATED FORM"
\uFC12 "ARABIC LIGATURE THEH WITH MEEM ISOLATED FORM"
\uFC13 "ARABIC LIGATURE THEH WITH ALEF MAKSURA ISOLATED FORM"
\uFC14 "ARABIC LIGATURE THEH WITH YEH ISOLATED FORM"
\uFC15 "ARABIC LIGATURE JEEM WITH HAH ISOLATED FORM"
\uFC16 "ARABIC LIGATURE JEEM WITH MEEM ISOLATED FORM"
\uFC17 "ARABIC LIGATURE HAH WITH JEEM ISOLATED FORM"
\uFC18 "ARABIC LIGATURE HAH WITH MEEM ISOLATED FORM"
\uFC19 "ARABIC LIGATURE KHAH WITH JEEM ISOLATED FORM"
\uFC1A "ARABIC LIGATURE KHAH WITH HAH ISOLATED FORM"
\uFC1B "ARABIC LIGATURE KHAH WITH MEEM ISOLATED FORM"
\uFC1C "ARABIC LIGATURE SEEN WITH JEEM ISOLATED FORM"
\uFC1D "ARABIC LIGATURE SEEN WITH HAH ISOLATED FORM"
\uFC1E "ARABIC LIGATURE SEEN WITH KHAH ISOLATED FORM"
\uFC1F "ARABIC LIGATURE SEEN WITH MEEM ISOLATED FORM"
\uFC20 "ARABIC LIGATURE SAD WITH HAH ISOLATED FORM"
\uFC21 "ARABIC LIGATURE SAD WITH MEEM ISOLATED FORM"
\uFC22 "ARABIC LIGATURE DAD WITH JEEM ISOLATED FORM"
\uFC23 "ARABIC LIGATURE DAD WITH HAH ISOLATED FORM"
\uFC24 "ARABIC LIGATURE DAD WITH KHAH ISOLATED FORM"
\uFC25 "ARABIC LIGATURE DAD WITH MEEM ISOLATED FORM"
\uFC26 "ARABIC LIGATURE TAH WITH HAH ISOLATED FORM"
\uFC27 "ARABIC LIGATURE TAH WITH MEEM ISOLATED FORM"
\uFC28 "ARABIC LIGATURE ZAH WITH MEEM ISOLATED FORM"
\uFC29 "ARABIC LIGATURE AIN WITH JEEM ISOLATED FORM"
\uFC2A "ARABIC LIGATURE AIN WITH MEEM ISOLATED FORM"
\uFC2B "ARABIC LIGATURE GHAIN WITH JEEM ISOLATED FORM"
\uFC2C "ARABIC LIGATURE GHAIN WITH MEEM ISOLATED FORM"
\uFC2D "ARABIC LIGATURE FEH WITH JEEM ISOLATED FORM"
\uFC2E "ARABIC LIGATURE FEH WITH HAH ISOLATED FORM"
\uFC2F "ARABIC LIGATURE FEH WITH KHAH ISOLATED FORM"
\uFC30 "ARABIC LIGATURE FEH WITH MEEM ISOLATED FORM"
\uFC31 "ARABIC LIGATURE FEH WITH ALEF MAKSURA ISOLATED FORM"
\uFC32 "ARABIC LIGATURE FEH WITH YEH ISOLATED FORM"
\uFC33 "ARABIC LIGATURE QAF WITH HAH ISOLATED FORM"
\uFC34 "ARABIC LIGATURE QAF WITH MEEM ISOLATED FORM"
\uFC35 "ARABIC LIGATURE QAF WITH ALEF MAKSURA ISOLATED FORM"
\uFC36 "ARABIC LIGATURE QAF WITH YEH ISOLATED FORM"
\uFC37 "ARABIC LIGATURE KAF WITH ALEF ISOLATED FORM"
\uFC38 "ARABIC LIGATURE KAF WITH JEEM ISOLATED FORM"
\uFC39 "ARABIC LIGATURE KAF WITH HAH ISOLATED FORM"
\uFC3A "ARABIC LIGATURE KAF WITH KHAH ISOLATED FORM"
\uFC3B "ARABIC LIGATURE KAF WITH LAM ISOLATED FORM"
\uFC3C "ARABIC LIGATURE KAF WITH MEEM ISOLATED FORM"
\uFC3D "ARABIC LIGATURE KAF WITH ALEF MAKSURA ISOLATED FORM"
\uFC3E "ARABIC LIGATURE KAF WITH YEH ISOLATED FORM"
\uFC3F "ARABIC LIGATURE LAM WITH JEEM ISOLATED FORM"
\uFC40 "ARABIC LIGATURE LAM WITH HAH ISOLATED FORM"
\uFC41 "ARABIC LIGATURE LAM WITH KHAH ISOLATED FORM"
\uFC42 "ARABIC LIGATURE LAM WITH MEEM ISOLATED FORM"
\uFC43 "ARABIC LIGATURE LAM WITH ALEF MAKSURA ISOLATED FORM"
\uFC44 "ARABIC LIGATURE LAM WITH YEH ISOLATED FORM"
\uFC45 "ARABIC LIGATURE MEEM WITH JEEM ISOLATED FORM"
\uFC46 "ARABIC LIGATURE MEEM WITH HAH ISOLATED FORM"
\uFC47 "ARABIC LIGATURE MEEM WITH KHAH ISOLATED FORM"
\uFC48 "ARABIC LIGATURE MEEM WITH MEEM ISOLATED FORM"
\uFC49 "ARABIC LIGATURE MEEM WITH ALEF MAKSURA ISOLATED FORM"
\uFC4A "ARABIC LIGATURE MEEM WITH YEH ISOLATED FORM"
\uFC4B "ARABIC LIGATURE NOON WITH JEEM ISOLATED FORM"
\uFC4C "ARABIC LIGATURE NOON WITH HAH ISOLATED FORM"
\uFC4D "ARABIC LIGATURE NOON WITH KHAH ISOLATED FORM"
\uFC4E "ARABIC LIGATURE NOON WITH MEEM ISOLATED FORM"
\uFC4F "ARABIC LIGATURE NOON WITH ALEF MAKSURA ISOLATED FORM"
\uFC50 "ARABIC LIGATURE NOON WITH YEH ISOLATED FORM"
\uFC51 "ARABIC LIGATURE HEH WITH JEEM ISOLATED FORM"
\uFC52 "ARABIC LIGATURE HEH WITH MEEM ISOLATED FORM"
\uFC53 "ARABIC LIGATURE HEH WITH ALEF MAKSURA ISOLATED FORM"
\uFC54 "ARABIC LIGATURE HEH WITH YEH ISOLATED FORM"
\uFC55 "ARABIC LIGATURE YEH WITH JEEM ISOLATED FORM"
\uFC56 "ARABIC LIGATURE YEH WITH HAH ISOLATED FORM"
\uFC57 "ARABIC LIGATURE YEH WITH KHAH ISOLATED FORM"
\uFC58 "ARABIC LIGATURE YEH WITH MEEM ISOLATED FORM"
\uFC59 "ARABIC LIGATURE YEH WITH ALEF MAKSURA ISOLATED FORM"
\uFC5A "ARABIC LIGATURE YEH WITH YEH ISOLATED FORM"
\uFC5B "ARABIC LIGATURE THAL WITH SUPERSCRIPT ALEF ISOLATED FORM"
\uFC5C "ARABIC LIGATURE REH WITH SUPERSCRIPT ALEF ISOLATED FORM"
\uFC5D "ARABIC LIGATURE ALEF MAKSURA WITH SUPERSCRIPT ALEF ISOLATED FORM"
\uFC5E "ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM"
\uFC5F "ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM"
\uFC60 "ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM"
\uFC61 "ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM"
\uFC62 "ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM"
\uFC63 "ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM"
\uFC64 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH REH FINAL FORM"
\uFC65 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ZAIN FINAL FORM"
\uFC66 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM FINAL FORM"
\uFC67 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH NOON FINAL FORM"
\uFC68 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH ALEF MAKSURA FINAL FORM"
\uFC69 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH YEH FINAL FORM"
\uFC6A "ARABIC LIGATURE BEH WITH REH FINAL FORM"
\uFC6B "ARABIC LIGATURE BEH WITH ZAIN FINAL FORM"
\uFC6C "ARABIC LIGATURE BEH WITH MEEM FINAL FORM"
\uFC6D "ARABIC LIGATURE BEH WITH NOON FINAL FORM"
\uFC6E "ARABIC LIGATURE BEH WITH ALEF MAKSURA FINAL FORM"
\uFC6F "ARABIC LIGATURE BEH WITH YEH FINAL FORM"
\uFC70 "ARABIC LIGATURE TEH WITH REH FINAL FORM"
\uFC71 "ARABIC LIGATURE TEH WITH ZAIN FINAL FORM"
\uFC72 "ARABIC LIGATURE TEH WITH MEEM FINAL FORM"
\uFC73 "ARABIC LIGATURE TEH WITH NOON FINAL FORM"
\uFC74 "ARABIC LIGATURE TEH WITH ALEF MAKSURA FINAL FORM"
\uFC75 "ARABIC LIGATURE TEH WITH YEH FINAL FORM"
\uFC76 "ARABIC LIGATURE THEH WITH REH FINAL FORM"
\uFC77 "ARABIC LIGATURE THEH WITH ZAIN FINAL FORM"
\uFC78 "ARABIC LIGATURE THEH WITH MEEM FINAL FORM"
\uFC79 "ARABIC LIGATURE THEH WITH NOON FINAL FORM"
\uFC7A "ARABIC LIGATURE THEH WITH ALEF MAKSURA FINAL FORM"
\uFC7B "ARABIC LIGATURE THEH WITH YEH FINAL FORM"
\uFC7C "ARABIC LIGATURE FEH WITH ALEF MAKSURA FINAL FORM"
\uFC7D "ARABIC LIGATURE FEH WITH YEH FINAL FORM"
\uFC7E "ARABIC LIGATURE QAF WITH ALEF MAKSURA FINAL FORM"
\uFC7F "ARABIC LIGATURE QAF WITH YEH FINAL FORM"
\uFC80 "ARABIC LIGATURE KAF WITH ALEF FINAL FORM"
\uFC81 "ARABIC LIGATURE KAF WITH LAM FINAL FORM"
\uFC82 "ARABIC LIGATURE KAF WITH MEEM FINAL FORM"
\uFC83 "ARABIC LIGATURE KAF WITH ALEF MAKSURA FINAL FORM"
\uFC84 "ARABIC LIGATURE KAF WITH YEH FINAL FORM"
\uFC85 "ARABIC LIGATURE LAM WITH MEEM FINAL FORM"
\uFC86 "ARABIC LIGATURE LAM WITH ALEF MAKSURA FINAL FORM"
\uFC87 "ARABIC LIGATURE LAM WITH YEH FINAL FORM"
\uFC88 "ARABIC LIGATURE MEEM WITH ALEF FINAL FORM"
\uFC89 "ARABIC LIGATURE MEEM WITH MEEM FINAL FORM"
\uFC8A "ARABIC LIGATURE NOON WITH REH FINAL FORM"
\uFC8B "ARABIC LIGATURE NOON WITH ZAIN FINAL FORM"
\uFC8C "ARABIC LIGATURE NOON WITH MEEM FINAL FORM"
\uFC8D "ARABIC LIGATURE NOON WITH NOON FINAL FORM"
\uFC8E "ARABIC LIGATURE NOON WITH ALEF MAKSURA FINAL FORM"
\uFC8F "ARABIC LIGATURE NOON WITH YEH FINAL FORM"
\uFC90 "ARABIC LIGATURE ALEF MAKSURA WITH SUPERSCRIPT ALEF FINAL FORM"
\uFC91 "ARABIC LIGATURE YEH WITH REH FINAL FORM"
\uFC92 "ARABIC LIGATURE YEH WITH ZAIN FINAL FORM"
\uFC93 "ARABIC LIGATURE YEH WITH MEEM FINAL FORM"
\uFC94 "ARABIC LIGATURE YEH WITH NOON FINAL FORM"
\uFC95 "ARABIC LIGATURE YEH WITH ALEF MAKSURA FINAL FORM"
\uFC96 "ARABIC LIGATURE YEH WITH YEH FINAL FORM"
\uFC97 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH JEEM INITIAL FORM"
\uFC98 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HAH INITIAL FORM"
\uFC99 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH KHAH INITIAL FORM"
\uFC9A "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM INITIAL FORM"
\uFC9B "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HEH INITIAL FORM"
\uFC9C "ARABIC LIGATURE BEH WITH JEEM INITIAL FORM"
\uFC9D "ARABIC LIGATURE BEH WITH HAH INITIAL FORM"
\uFC9E "ARABIC LIGATURE BEH WITH KHAH INITIAL FORM"
\uFC9F "ARABIC LIGATURE BEH WITH MEEM INITIAL FORM"
\uFCA0 "ARABIC LIGATURE BEH WITH HEH INITIAL FORM"
\uFCA1 "ARABIC LIGATURE TEH WITH JEEM INITIAL FORM"
\uFCA2 "ARABIC LIGATURE TEH WITH HAH INITIAL FORM"
\uFCA3 "ARABIC LIGATURE TEH WITH KHAH INITIAL FORM"
\uFCA4 "ARABIC LIGATURE TEH WITH MEEM INITIAL FORM"
\uFCA5 "ARABIC LIGATURE TEH WITH HEH INITIAL FORM"
\uFCA6 "ARABIC LIGATURE THEH WITH MEEM INITIAL FORM"
\uFCA7 "ARABIC LIGATURE JEEM WITH HAH INITIAL FORM"
\uFCA8 "ARABIC LIGATURE JEEM WITH MEEM INITIAL FORM"
\uFCA9 "ARABIC LIGATURE HAH WITH JEEM INITIAL FORM"
\uFCAA "ARABIC LIGATURE HAH WITH MEEM INITIAL FORM"
\uFCAB "ARABIC LIGATURE KHAH WITH JEEM INITIAL FORM"
\uFCAC "ARABIC LIGATURE KHAH WITH MEEM INITIAL FORM"
\uFCAD "ARABIC LIGATURE SEEN WITH JEEM INITIAL FORM"
\uFCAE "ARABIC LIGATURE SEEN WITH HAH INITIAL FORM"
\uFCAF "ARABIC LIGATURE SEEN WITH KHAH INITIAL FORM"
\uFCB0 "ARABIC LIGATURE SEEN WITH MEEM INITIAL FORM"
\uFCB1 "ARABIC LIGATURE SAD WITH HAH INITIAL FORM"
\uFCB2 "ARABIC LIGATURE SAD WITH KHAH INITIAL FORM"
\uFCB3 "ARABIC LIGATURE SAD WITH MEEM INITIAL FORM"
\uFCB4 "ARABIC LIGATURE DAD WITH JEEM INITIAL FORM"
\uFCB5 "ARABIC LIGATURE DAD WITH HAH INITIAL FORM"
\uFCB6 "ARABIC LIGATURE DAD WITH KHAH INITIAL FORM"
\uFCB7 "ARABIC LIGATURE DAD WITH MEEM INITIAL FORM"
\uFCB8 "ARABIC LIGATURE TAH WITH HAH INITIAL FORM"
\uFCB9 "ARABIC LIGATURE ZAH WITH MEEM INITIAL FORM"
\uFCBA "ARABIC LIGATURE AIN WITH JEEM INITIAL FORM"
\uFCBB "ARABIC LIGATURE AIN WITH MEEM INITIAL FORM"
\uFCBC "ARABIC LIGATURE GHAIN WITH JEEM INITIAL FORM"
\uFCBD "ARABIC LIGATURE GHAIN WITH MEEM INITIAL FORM"
\uFCBE "ARABIC LIGATURE FEH WITH JEEM INITIAL FORM"
\uFCBF "ARABIC LIGATURE FEH WITH HAH INITIAL FORM"
\uFCC0 "ARABIC LIGATURE FEH WITH KHAH INITIAL FORM"
\uFCC1 "ARABIC LIGATURE FEH WITH MEEM INITIAL FORM"
\uFCC2 "ARABIC LIGATURE QAF WITH HAH INITIAL FORM"
\uFCC3 "ARABIC LIGATURE QAF WITH MEEM INITIAL FORM"
\uFCC4 "ARABIC LIGATURE KAF WITH JEEM INITIAL FORM"
\uFCC5 "ARABIC LIGATURE KAF WITH HAH INITIAL FORM"
\uFCC6 "ARABIC LIGATURE KAF WITH KHAH INITIAL FORM"
\uFCC7 "ARABIC LIGATURE KAF WITH LAM INITIAL FORM"
\uFCC8 "ARABIC LIGATURE KAF WITH MEEM INITIAL FORM"
\uFCC9 "ARABIC LIGATURE LAM WITH JEEM INITIAL FORM"
\uFCCA "ARABIC LIGATURE LAM WITH HAH INITIAL FORM"
\uFCCB "ARABIC LIGATURE LAM WITH KHAH INITIAL FORM"
\uFCCC "ARABIC LIGATURE LAM WITH MEEM INITIAL FORM"
\uFCCD "ARABIC LIGATURE LAM WITH HEH INITIAL FORM"
\uFCCE "ARABIC LIGATURE MEEM WITH JEEM INITIAL FORM"
\uFCCF "ARABIC LIGATURE MEEM WITH HAH INITIAL FORM"
\uFCD0 "ARABIC LIGATURE MEEM WITH KHAH INITIAL FORM"
\uFCD1 "ARABIC LIGATURE MEEM WITH MEEM INITIAL FORM"
\uFCD2 "ARABIC LIGATURE NOON WITH JEEM INITIAL FORM"
\uFCD3 "ARABIC LIGATURE NOON WITH HAH INITIAL FORM"
\uFCD4 "ARABIC LIGATURE NOON WITH KHAH INITIAL FORM"
\uFCD5 "ARABIC LIGATURE NOON WITH MEEM INITIAL FORM"
\uFCD6 "ARABIC LIGATURE NOON WITH HEH INITIAL FORM"
\uFCD7 "ARABIC LIGATURE HEH WITH JEEM INITIAL FORM"
\uFCD8 "ARABIC LIGATURE HEH WITH MEEM INITIAL FORM"
\uFCD9 "ARABIC LIGATURE HEH WITH SUPERSCRIPT ALEF INITIAL FORM"
\uFCDA "ARABIC LIGATURE YEH WITH JEEM INITIAL FORM"
\uFCDB "ARABIC LIGATURE YEH WITH HAH INITIAL FORM"
\uFCDC "ARABIC LIGATURE YEH WITH KHAH INITIAL FORM"
\uFCDD "ARABIC LIGATURE YEH WITH MEEM INITIAL FORM"
\uFCDE "ARABIC LIGATURE YEH WITH HEH INITIAL FORM"
\uFCDF "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH MEEM MEDIAL FORM"
\uFCE0 "ARABIC LIGATURE YEH WITH HAMZA ABOVE WITH HEH MEDIAL FORM"
\uFCE1 "ARABIC LIGATURE BEH WITH MEEM MEDIAL FORM"
\uFCE2 "ARABIC LIGATURE BEH WITH HEH MEDIAL FORM"
\uFCE3 "ARABIC LIGATURE TEH WITH MEEM MEDIAL FORM"
\uFCE4 "ARABIC LIGATURE TEH WITH HEH MEDIAL FORM"
\uFCE5 "ARABIC LIGATURE THEH WITH MEEM MEDIAL FORM"
\uFCE6 "ARABIC LIGATURE THEH WITH HEH MEDIAL FORM"
\uFCE7 "ARABIC LIGATURE SEEN WITH MEEM MEDIAL FORM"
\uFCE8 "ARABIC LIGATURE SEEN WITH HEH MEDIAL FORM"
\uFCE9 "ARABIC LIGATURE SHEEN WITH MEEM MEDIAL FORM"
\uFCEA "ARABIC LIGATURE SHEEN WITH HEH MEDIAL FORM"
\uFCEB "ARABIC LIGATURE KAF WITH LAM MEDIAL FORM"
\uFCEC "ARABIC LIGATURE KAF WITH MEEM MEDIAL FORM"
\uFCED "ARABIC LIGATURE LAM WITH MEEM MEDIAL FORM"
\uFCEE "ARABIC LIGATURE NOON WITH MEEM MEDIAL FORM"
\uFCEF "ARABIC LIGATURE NOON WITH HEH MEDIAL FORM"
\uFCF0 "ARABIC LIGATURE YEH WITH MEEM MEDIAL FORM"
\uFCF1 "ARABIC LIGATURE YEH WITH HEH MEDIAL FORM"
\uFCF2 "ARABIC LIGATURE SHADDA WITH FATHA MEDIAL FORM"
\uFCF3 "ARABIC LIGATURE SHADDA WITH DAMMA MEDIAL FORM"
\uFCF4 "ARABIC LIGATURE SHADDA WITH KASRA MEDIAL FORM"
\uFCF5 "ARABIC LIGATURE TAH WITH ALEF MAKSURA ISOLATED FORM"
\uFCF6 "ARABIC LIGATURE TAH WITH YEH ISOLATED FORM"
\uFCF7 "ARABIC LIGATURE AIN WITH ALEF MAKSURA ISOLATED FORM"
\uFCF8 "ARABIC LIGATURE AIN WITH YEH ISOLATED FORM"
\uFCF9 "ARABIC LIGATURE GHAIN WITH ALEF MAKSURA ISOLATED FORM"
\uFCFA "ARABIC LIGATURE GHAIN WITH YEH ISOLATED FORM"
\uFCFB "ARABIC LIGATURE SEEN WITH ALEF MAKSURA ISOLATED FORM"
\uFCFC "ARABIC LIGATURE SEEN WITH YEH ISOLATED FORM"
\uFCFD "ARABIC LIGATURE SHEEN WITH ALEF MAKSURA ISOLATED FORM"
\uFCFE "ARABIC LIGATURE SHEEN WITH YEH ISOLATED FORM"
\uFCFF "ARABIC LIGATURE HAH WITH ALEF MAKSURA ISOLATED FORM"
\uFD00 "ARABIC LIGATURE HAH WITH YEH ISOLATED FORM"
\uFD01 "ARABIC LIGATURE JEEM WITH ALEF MAKSURA ISOLATED FORM"
\uFD02 "ARABIC LIGATURE JEEM WITH YEH ISOLATED FORM"
\uFD03 "ARABIC LIGATURE KHAH WITH ALEF MAKSURA ISOLATED FORM"
\uFD04 "ARABIC LIGATURE KHAH WITH YEH ISOLATED FORM"
\uFD05 "ARABIC LIGATURE SAD WITH ALEF MAKSURA ISOLATED FORM"
\uFD06 "ARABIC LIGATURE SAD WITH YEH ISOLATED FORM"
\uFD07 "ARABIC LIGATURE DAD WITH ALEF MAKSURA ISOLATED FORM"
\uFD08 "ARABIC LIGATURE DAD WITH YEH ISOLATED FORM"
\uFD09 "ARABIC LIGATURE SHEEN WITH JEEM ISOLATED FORM"
\uFD0A "ARABIC LIGATURE SHEEN WITH HAH ISOLATED FORM"
\uFD0B "ARABIC LIGATURE SHEEN WITH KHAH ISOLATED FORM"
\uFD0C "ARABIC LIGATURE SHEEN WITH MEEM ISOLATED FORM"
\uFD0D "ARABIC LIGATURE SHEEN WITH REH ISOLATED FORM"
\uFD0E "ARABIC LIGATURE SEEN WITH REH ISOLATED FORM"
\uFD0F "ARABIC LIGATURE SAD WITH REH ISOLATED FORM"
\uFD10 "ARABIC LIGATURE DAD WITH REH ISOLATED FORM"
\uFD11 "ARABIC LIGATURE TAH WITH ALEF MAKSURA FINAL FORM"
\uFD12 "ARABIC LIGATURE TAH WITH YEH FINAL FORM"
\uFD13 "ARABIC LIGATURE AIN WITH ALEF MAKSURA FINAL FORM"
\uFD14 "ARABIC LIGATURE AIN WITH YEH FINAL FORM"
\uFD15 "ARABIC LIGATURE GHAIN WITH ALEF MAKSURA FINAL FORM"
\uFD16 "ARABIC LIGATURE GHAIN WITH YEH FINAL FORM"
\uFD17 "ARABIC LIGATURE SEEN WITH ALEF MAKSURA FINAL FORM"
\uFD18 "ARABIC LIGATURE SEEN WITH YEH FINAL FORM"
\uFD19 "ARABIC LIGATURE SHEEN WITH ALEF MAKSURA FINAL FORM"
\uFD1A "ARABIC LIGATURE SHEEN WITH YEH FINAL FORM"
\uFD1B "ARABIC LIGATURE HAH WITH ALEF MAKSURA FINAL FORM"
\uFD1C "ARABIC LIGATURE HAH WITH YEH FINAL FORM"
\uFD1D "ARABIC LIGATURE JEEM WITH ALEF MAKSURA FINAL FORM"
\uFD1E "ARABIC LIGATURE JEEM WITH YEH FINAL FORM"
\uFD1F "ARABIC LIGATURE KHAH WITH ALEF MAKSURA FINAL FORM"
\uFD20 "ARABIC LIGATURE KHAH WITH YEH FINAL FORM"
\uFD21 "ARABIC LIGATURE SAD WITH ALEF MAKSURA FINAL FORM"
\uFD22 "ARABIC LIGATURE SAD WITH YEH FINAL FORM"
\uFD23 "ARABIC LIGATURE DAD WITH ALEF MAKSURA FINAL FORM"
\uFD24 "ARABIC LIGATURE DAD WITH YEH FINAL FORM"
\uFD25 "ARABIC LIGATURE SHEEN WITH JEEM FINAL FORM"
\uFD26 "ARABIC LIGATURE SHEEN WITH HAH FINAL FORM"
\uFD27 "ARABIC LIGATURE SHEEN WITH KHAH FINAL FORM"
\uFD28 "ARABIC LIGATURE SHEEN WITH MEEM FINAL FORM"
\uFD29 "ARABIC LIGATURE SHEEN WITH REH FINAL FORM"
\uFD2A "ARABIC LIGATURE SEEN WITH REH FINAL FORM"
\uFD2B "ARABIC LIGATURE SAD WITH REH FINAL FORM"
\uFD2C "ARABIC LIGATURE DAD WITH REH FINAL FORM"
\uFD2D "ARABIC LIGATURE SHEEN WITH JEEM INITIAL FORM"
\uFD2E "ARABIC LIGATURE SHEEN WITH HAH INITIAL FORM"
\uFD2F "ARABIC LIGATURE SHEEN WITH KHAH INITIAL FORM"
\uFD30 "ARABIC LIGATURE SHEEN WITH MEEM INITIAL FORM"
\uFD31 "ARABIC LIGATURE SEEN WITH HEH INITIAL FORM"
\uFD32 "ARABIC LIGATURE SHEEN WITH HEH INITIAL FORM"
\uFD33 "ARABIC LIGATURE TAH WITH MEEM INITIAL FORM"
\uFD34 "ARABIC LIGATURE SEEN WITH JEEM MEDIAL FORM"
\uFD35 "ARABIC LIGATURE SEEN WITH HAH MEDIAL FORM"
\uFD36 "ARABIC LIGATURE SEEN WITH KHAH MEDIAL FORM"
\uFD37 "ARABIC LIGATURE SHEEN WITH JEEM MEDIAL FORM"
\uFD38 "ARABIC LIGATURE SHEEN WITH HAH MEDIAL FORM"
\uFD39 "ARABIC LIGATURE SHEEN WITH KHAH MEDIAL FORM"
\uFD3A "ARABIC LIGATURE TAH WITH MEEM MEDIAL FORM"
\uFD3B "ARABIC LIGATURE ZAH WITH MEEM MEDIAL FORM"
\uFD3C "ARABIC LIGATURE ALEF WITH FATHATAN FINAL FORM"
\uFD3D "ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM"
\uFD3E "ORNATE LEFT PARENTHESIS"
\uFD3F "ORNATE RIGHT PARENTHESIS"
\uFD50 "ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM"
\uFD51 "ARABIC LIGATURE TEH WITH HAH WITH JEEM FINAL FORM"
\uFD52 "ARABIC LIGATURE TEH WITH HAH WITH JEEM INITIAL FORM"
\uFD53 "ARABIC LIGATURE TEH WITH HAH WITH MEEM INITIAL FORM"
\uFD54 "ARABIC LIGATURE TEH WITH KHAH WITH MEEM INITIAL FORM"
\uFD55 "ARABIC LIGATURE TEH WITH MEEM WITH JEEM INITIAL FORM"
\uFD56 "ARABIC LIGATURE TEH WITH MEEM WITH HAH INITIAL FORM"
\uFD57 "ARABIC LIGATURE TEH WITH MEEM WITH KHAH INITIAL FORM"
\uFD58 "ARABIC LIGATURE JEEM WITH MEEM WITH HAH FINAL FORM"
\uFD59 "ARABIC LIGATURE JEEM WITH MEEM WITH HAH INITIAL FORM"
\uFD5A "ARABIC LIGATURE HAH WITH MEEM WITH YEH FINAL FORM"
\uFD5B "ARABIC LIGATURE HAH WITH MEEM WITH ALEF MAKSURA FINAL FORM"
\uFD5C "ARABIC LIGATURE SEEN WITH HAH WITH JEEM INITIAL FORM"
\uFD5D "ARABIC LIGATURE SEEN WITH JEEM WITH HAH INITIAL FORM"
\uFD5E "ARABIC LIGATURE SEEN WITH JEEM WITH ALEF MAKSURA FINAL FORM"
\uFD5F "ARABIC LIGATURE SEEN WITH MEEM WITH HAH FINAL FORM"
\uFD60 "ARABIC LIGATURE SEEN WITH MEEM WITH HAH INITIAL FORM"
\uFD61 "ARABIC LIGATURE SEEN WITH MEEM WITH JEEM INITIAL FORM"
\uFD62 "ARABIC LIGATURE SEEN WITH MEEM WITH MEEM FINAL FORM"
\uFD63 "ARABIC LIGATURE SEEN WITH MEEM WITH MEEM INITIAL FORM"
\uFD64 "ARABIC LIGATURE SAD WITH HAH WITH HAH FINAL FORM"
\uFD65 "ARABIC LIGATURE SAD WITH HAH WITH HAH INITIAL FORM"
\uFD66 "ARABIC LIGATURE SAD WITH MEEM WITH MEEM FINAL FORM"
\uFD67 "ARABIC LIGATURE SHEEN WITH HAH WITH MEEM FINAL FORM"
\uFD68 "ARABIC LIGATURE SHEEN WITH HAH WITH MEEM INITIAL FORM"
\uFD69 "ARABIC LIGATURE SHEEN WITH JEEM WITH YEH FINAL FORM"
\uFD6A "ARABIC LIGATURE SHEEN WITH MEEM WITH KHAH FINAL FORM"
\uFD6B "ARABIC LIGATURE SHEEN WITH MEEM WITH KHAH INITIAL FORM"
\uFD6C "ARABIC LIGATURE SHEEN WITH MEEM WITH MEEM FINAL FORM"
\uFD6D "ARABIC LIGATURE SHEEN WITH MEEM WITH MEEM INITIAL FORM"
\uFD6E "ARABIC LIGATURE DAD WITH HAH WITH ALEF MAKSURA FINAL FORM"
\uFD6F "ARABIC LIGATURE DAD WITH KHAH WITH MEEM FINAL FORM"
\uFD70 "ARABIC LIGATURE DAD WITH KHAH WITH MEEM INITIAL FORM"
\uFD71 "ARABIC LIGATURE TAH WITH MEEM WITH HAH FINAL FORM"
\uFD72 "ARABIC LIGATURE TAH WITH MEEM WITH HAH INITIAL FORM"
\uFD73 "ARABIC LIGATURE TAH WITH MEEM WITH MEEM INITIAL FORM"
\uFD74 "ARABIC LIGATURE TAH WITH MEEM WITH YEH FINAL FORM"
\uFD75 "ARABIC LIGATURE AIN WITH JEEM WITH MEEM FINAL FORM"
\uFD76 "ARABIC LIGATURE AIN WITH MEEM WITH MEEM FINAL FORM"
\uFD77 "ARABIC LIGATURE AIN WITH MEEM WITH MEEM INITIAL FORM"
\uFD78 "ARABIC LIGATURE AIN WITH MEEM WITH ALEF MAKSURA FINAL FORM"
\uFD79 "ARABIC LIGATURE GHAIN WITH MEEM WITH MEEM FINAL FORM"
\uFD7A "ARABIC LIGATURE GHAIN WITH MEEM WITH YEH FINAL FORM"
\uFD7B "ARABIC LIGATURE GHAIN WITH MEEM WITH ALEF MAKSURA FINAL FORM"
\uFD7C "ARABIC LIGATURE FEH WITH KHAH WITH MEEM FINAL FORM"
\uFD7D "ARABIC LIGATURE FEH WITH KHAH WITH MEEM INITIAL FORM"
\uFD7E "ARABIC LIGATURE QAF WITH MEEM WITH HAH FINAL FORM"
\uFD7F "ARABIC LIGATURE QAF WITH MEEM WITH MEEM FINAL FORM"
\uFD80 "ARABIC LIGATURE LAM WITH HAH WITH MEEM FINAL FORM"
\uFD81 "ARABIC LIGATURE LAM WITH HAH WITH YEH FINAL FORM"
\uFD82 "ARABIC LIGATURE LAM WITH HAH WITH ALEF MAKSURA FINAL FORM"
\uFD83 "ARABIC LIGATURE LAM WITH JEEM WITH JEEM INITIAL FORM"
\uFD84 "ARABIC LIGATURE LAM WITH JEEM WITH JEEM FINAL FORM"
\uFD85 "ARABIC LIGATURE LAM WITH KHAH WITH MEEM FINAL FORM"
\uFD86 "ARABIC LIGATURE LAM WITH KHAH WITH MEEM INITIAL FORM"
\uFD87 "ARABIC LIGATURE LAM WITH MEEM WITH HAH FINAL FORM"
\uFD88 "ARABIC LIGATURE LAM WITH MEEM WITH HAH INITIAL FORM"
\uFD89 "ARABIC LIGATURE MEEM WITH HAH WITH JEEM INITIAL FORM"
\uFD8A "ARABIC LIGATURE MEEM WITH HAH WITH MEEM INITIAL FORM"
\uFD8B "ARABIC LIGATURE MEEM WITH HAH WITH YEH FINAL FORM"
\uFD8C "ARABIC LIGATURE MEEM WITH JEEM WITH HAH INITIAL FORM"
\uFD8D "ARABIC LIGATURE MEEM WITH JEEM WITH MEEM INITIAL FORM"
\uFD8E "ARABIC LIGATURE MEEM WITH KHAH WITH JEEM INITIAL FORM"
\uFD8F "ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM"
\uFD92 "ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM"
\uFD93 "ARABIC LIGATURE HEH WITH MEEM WITH JEEM INITIAL FORM"
\uFD94 "ARABIC LIGATURE HEH WITH MEEM WITH MEEM INITIAL FORM"
\uFD95 "ARABIC LIGATURE NOON WITH HAH WITH MEEM INITIAL FORM"
\uFD96 "ARABIC LIGATURE NOON WITH HAH WITH ALEF MAKSURA FINAL FORM"
\uFD97 "ARABIC LIGATURE NOON WITH JEEM WITH MEEM FINAL FORM"
\uFD98 "ARABIC LIGATURE NOON WITH JEEM WITH MEEM INITIAL FORM"
\uFD99 "ARABIC LIGATURE NOON WITH JEEM WITH ALEF MAKSURA FINAL FORM"
\uFD9A "ARABIC LIGATURE NOON WITH MEEM WITH YEH FINAL FORM"
\uFD9B "ARABIC LIGATURE NOON WITH MEEM WITH ALEF MAKSURA FINAL FORM"
\uFD9C "ARABIC LIGATURE YEH WITH MEEM WITH MEEM FINAL FORM"
\uFD9D "ARABIC LIGATURE YEH WITH MEEM WITH MEEM INITIAL FORM"
\uFD9E "ARABIC LIGATURE BEH WITH KHAH WITH YEH FINAL FORM"
\uFD9F "ARABIC LIGATURE TEH WITH JEEM WITH YEH FINAL FORM"
\uFDA0 "ARABIC LIGATURE TEH WITH JEEM WITH ALEF MAKSURA FINAL FORM"
\uFDA1 "ARABIC LIGATURE TEH WITH KHAH WITH YEH FINAL FORM"
\uFDA2 "ARABIC LIGATURE TEH WITH KHAH WITH ALEF MAKSURA FINAL FORM"
\uFDA3 "ARABIC LIGATURE TEH WITH MEEM WITH YEH FINAL FORM"
\uFDA4 "ARABIC LIGATURE TEH WITH MEEM WITH ALEF MAKSURA FINAL FORM"
\uFDA5 "ARABIC LIGATURE JEEM WITH MEEM WITH YEH FINAL FORM"
\uFDA6 "ARABIC LIGATURE JEEM WITH HAH WITH ALEF MAKSURA FINAL FORM"
\uFDA7 "ARABIC LIGATURE JEEM WITH MEEM WITH ALEF MAKSURA FINAL FORM"
\uFDA8 "ARABIC LIGATURE SEEN WITH KHAH WITH ALEF MAKSURA FINAL FORM"
\uFDA9 "ARABIC LIGATURE SAD WITH HAH WITH YEH FINAL FORM"
\uFDAA "ARABIC LIGATURE SHEEN WITH HAH WITH YEH FINAL FORM"
\uFDAB "ARABIC LIGATURE DAD WITH HAH WITH YEH FINAL FORM"
\uFDAC "ARABIC LIGATURE LAM WITH JEEM WITH YEH FINAL FORM"
\uFDAD "ARABIC LIGATURE LAM WITH MEEM WITH YEH FINAL FORM"
\uFDAE "ARABIC LIGATURE YEH WITH HAH WITH YEH FINAL FORM"
\uFDAF "ARABIC LIGATURE YEH WITH JEEM WITH YEH FINAL FORM"
\uFDB0 "ARABIC LIGATURE YEH WITH MEEM WITH YEH FINAL FORM"
\uFDB1 "ARABIC LIGATURE MEEM WITH MEEM WITH YEH FINAL FORM"
\uFDB2 "ARABIC LIGATURE QAF WITH MEEM WITH YEH FINAL FORM"
\uFDB3 "ARABIC LIGATURE NOON WITH HAH WITH YEH FINAL FORM"
\uFDB4 "ARABIC LIGATURE QAF WITH MEEM WITH HAH INITIAL FORM"
\uFDB5 "ARABIC LIGATURE LAM WITH HAH WITH MEEM INITIAL FORM"
\uFDB6 "ARABIC LIGATURE AIN WITH MEEM WITH YEH FINAL FORM"
\uFDB7 "ARABIC LIGATURE KAF WITH MEEM WITH YEH FINAL FORM"
\uFDB8 "ARABIC LIGATURE NOON WITH JEEM WITH HAH INITIAL FORM"
\uFDB9 "ARABIC LIGATURE MEEM WITH KHAH WITH YEH FINAL FORM"
\uFDBA "ARABIC LIGATURE LAM WITH JEEM WITH MEEM INITIAL FORM"
\uFDBB "ARABIC LIGATURE KAF WITH MEEM WITH MEEM FINAL FORM"
\uFDBC "ARABIC LIGATURE LAM WITH JEEM WITH MEEM FINAL FORM"
\uFDBD "ARABIC LIGATURE NOON WITH JEEM WITH HAH FINAL FORM"
\uFDBE "ARABIC LIGATURE JEEM WITH HAH WITH YEH FINAL FORM"
\uFDBF "ARABIC LIGATURE HAH WITH JEEM WITH YEH FINAL FORM"
\uFDC0 "ARABIC LIGATURE MEEM WITH JEEM WITH YEH FINAL FORM"
\uFDC1 "ARABIC LIGATURE FEH WITH MEEM WITH YEH FINAL FORM"
\uFDC2 "ARABIC LIGATURE BEH WITH HAH WITH YEH FINAL FORM"
\uFDC3 "ARABIC LIGATURE KAF WITH MEEM WITH MEEM INITIAL FORM"
\uFDC4 "ARABIC LIGATURE AIN WITH JEEM WITH MEEM INITIAL FORM"
\uFDC5 "ARABIC LIGATURE SAD WITH MEEM WITH MEEM INITIAL FORM"
\uFDC6 "ARABIC LIGATURE SEEN WITH KHAH WITH YEH FINAL FORM"
\uFDC7 "ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM"
\uFDF0 "ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM"
\uFDF1 "ARABIC LIGATURE QALA USED AS KORANIC STOP SIGN ISOLATED FORM"
\uFDF2 "ARABIC LIGATURE ALLAH ISOLATED FORM"
\uFDF3 "ARABIC LIGATURE AKBAR ISOLATED FORM"
\uFDF4 "ARABIC LIGATURE MOHAMMAD ISOLATED FORM"
\uFDF5 "ARABIC LIGATURE SALAM ISOLATED FORM"
\uFDF6 "ARABIC LIGATURE RASOUL ISOLATED FORM"
\uFDF7 "ARABIC LIGATURE ALAYHE ISOLATED FORM"
\uFDF8 "ARABIC LIGATURE WASALLAM ISOLATED FORM"
\uFDF9 "ARABIC LIGATURE SALLA ISOLATED FORM"
\uFDFA "ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM"
\uFDFB "ARABIC LIGATURE JALLAJALALOUHOU"
\uFDFC "RIAL SIGN"
\uFDFD "ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM"
\uFE00 "VARIATION SELECTOR-1"
\uFE01 "VARIATION SELECTOR-2"
\uFE02 "VARIATION SELECTOR-3"
\uFE03 "VARIATION SELECTOR-4"
\uFE04 "VARIATION SELECTOR-5"
\uFE05 "VARIATION SELECTOR-6"
\uFE06 "VARIATION SELECTOR-7"
\uFE07 "VARIATION SELECTOR-8"
\uFE08 "VARIATION SELECTOR-9"
\uFE09 "VARIATION SELECTOR-10"
\uFE0A "VARIATION SELECTOR-11"
\uFE0B "VARIATION SELECTOR-12"
\uFE0C "VARIATION SELECTOR-13"
\uFE0D "VARIATION SELECTOR-14"
\uFE0E "VARIATION SELECTOR-15"
\uFE0F "VARIATION SELECTOR-16"
\uFE10 "PRESENTATION FORM FOR VERTICAL COMMA"
\uFE11 "PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC COMMA"
\uFE12 "PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC FULL STOP"
\uFE13 "PRESENTATION FORM FOR VERTICAL COLON"
\uFE14 "PRESENTATION FORM FOR VERTICAL SEMICOLON"
\uFE15 "PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK"
\uFE16 "PRESENTATION FORM FOR VERTICAL QUESTION MARK"
\uFE17 "PRESENTATION FORM FOR VERTICAL LEFT WHITE LENTICULAR BRACKET"
\uFE18 "PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET"
\uFE19 "PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS"
\uFE20 "COMBINING LIGATURE LEFT HALF"
\uFE21 "COMBINING LIGATURE RIGHT HALF"
\uFE22 "COMBINING DOUBLE TILDE LEFT HALF"
\uFE23 "COMBINING DOUBLE TILDE RIGHT HALF"
\uFE24 "COMBINING MACRON LEFT HALF"
\uFE25 "COMBINING MACRON RIGHT HALF"
\uFE26 "COMBINING CONJOINING MACRON"
\uFE30 "PRESENTATION FORM FOR VERTICAL TWO DOT LEADER"
\uFE31 "PRESENTATION FORM FOR VERTICAL EM DASH"
\uFE32 "PRESENTATION FORM FOR VERTICAL EN DASH"
\uFE33 "PRESENTATION FORM FOR VERTICAL LOW LINE"
\uFE34 "PRESENTATION FORM FOR VERTICAL WAVY LOW LINE"
\uFE35 "PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS"
\uFE36 "PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS"
\uFE37 "PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET"
\uFE38 "PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET"
\uFE39 "PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET"
\uFE3A "PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET"
\uFE3B "PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET"
\uFE3C "PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET"
\uFE3D "PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET"
\uFE3E "PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET"
\uFE3F "PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET"
\uFE40 "PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET"
\uFE41 "PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET"
\uFE42 "PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET"
\uFE43 "PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET"
\uFE44 "PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET"
\uFE45 "SESAME DOT"
\uFE46 "WHITE SESAME DOT"
\uFE47 "PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET"
\uFE48 "PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET"
\uFE49 "DASHED OVERLINE"
\uFE4A "CENTRELINE OVERLINE"
\uFE4B "WAVY OVERLINE"
\uFE4C "DOUBLE WAVY OVERLINE"
\uFE4D "DASHED LOW LINE"
\uFE4E "CENTRELINE LOW LINE"
\uFE4F "WAVY LOW LINE"
\uFE50 "SMALL COMMA"
\uFE51 "SMALL IDEOGRAPHIC COMMA"
\uFE52 "SMALL FULL STOP"
\uFE54 "SMALL SEMICOLON"
\uFE55 "SMALL COLON"
\uFE56 "SMALL QUESTION MARK"
\uFE57 "SMALL EXCLAMATION MARK"
\uFE58 "SMALL EM DASH"
\uFE59 "SMALL LEFT PARENTHESIS"
\uFE5A "SMALL RIGHT PARENTHESIS"
\uFE5B "SMALL LEFT CURLY BRACKET"
\uFE5C "SMALL RIGHT CURLY BRACKET"
\uFE5D "SMALL LEFT TORTOISE SHELL BRACKET"
\uFE5E "SMALL RIGHT TORTOISE SHELL BRACKET"
\uFE5F "SMALL NUMBER SIGN"
\uFE60 "SMALL AMPERSAND"
\uFE61 "SMALL ASTERISK"
\uFE62 "SMALL PLUS SIGN"
\uFE63 "SMALL HYPHEN-MINUS"
\uFE64 "SMALL LESS-THAN SIGN"
\uFE65 "SMALL GREATER-THAN SIGN"
\uFE66 "SMALL EQUALS SIGN"
\uFE68 "SMALL REVERSE SOLIDUS"
\uFE69 "SMALL DOLLAR SIGN"
\uFE6A "SMALL PERCENT SIGN"
\uFE6B "SMALL COMMERCIAL AT"
\uFE70 "ARABIC FATHATAN ISOLATED FORM"
\uFE71 "ARABIC TATWEEL WITH FATHATAN ABOVE"
\uFE72 "ARABIC DAMMATAN ISOLATED FORM"
\uFE73 "ARABIC TAIL FRAGMENT"
\uFE74 "ARABIC KASRATAN ISOLATED FORM"
\uFE76 "ARABIC FATHA ISOLATED FORM"
\uFE77 "ARABIC FATHA MEDIAL FORM"
\uFE78 "ARABIC DAMMA ISOLATED FORM"
\uFE79 "ARABIC DAMMA MEDIAL FORM"
\uFE7A "ARABIC KASRA ISOLATED FORM"
\uFE7B "ARABIC KASRA MEDIAL FORM"
\uFE7C "ARABIC SHADDA ISOLATED FORM"
\uFE7D "ARABIC SHADDA MEDIAL FORM"
\uFE7E "ARABIC SUKUN ISOLATED FORM"
\uFE7F "ARABIC SUKUN MEDIAL FORM"
\uFE80 "ARABIC LETTER HAMZA ISOLATED FORM"
\uFE81 "ARABIC LETTER ALEF WITH MADDA ABOVE ISOLATED FORM"
\uFE82 "ARABIC LETTER ALEF WITH MADDA ABOVE FINAL FORM"
\uFE83 "ARABIC LETTER ALEF WITH HAMZA ABOVE ISOLATED FORM"
\uFE84 "ARABIC LETTER ALEF WITH HAMZA ABOVE FINAL FORM"
\uFE85 "ARABIC LETTER WAW WITH HAMZA ABOVE ISOLATED FORM"
\uFE86 "ARABIC LETTER WAW WITH HAMZA ABOVE FINAL FORM"
\uFE87 "ARABIC LETTER ALEF WITH HAMZA BELOW ISOLATED FORM"
\uFE88 "ARABIC LETTER ALEF WITH HAMZA BELOW FINAL FORM"
\uFE89 "ARABIC LETTER YEH WITH HAMZA ABOVE ISOLATED FORM"
\uFE8A "ARABIC LETTER YEH WITH HAMZA ABOVE FINAL FORM"
\uFE8B "ARABIC LETTER YEH WITH HAMZA ABOVE INITIAL FORM"
\uFE8C "ARABIC LETTER YEH WITH HAMZA ABOVE MEDIAL FORM"
\uFE8D "ARABIC LETTER ALEF ISOLATED FORM"
\uFE8E "ARABIC LETTER ALEF FINAL FORM"
\uFE8F "ARABIC LETTER BEH ISOLATED FORM"
\uFE90 "ARABIC LETTER BEH FINAL FORM"
\uFE91 "ARABIC LETTER BEH INITIAL FORM"
\uFE92 "ARABIC LETTER BEH MEDIAL FORM"
\uFE93 "ARABIC LETTER TEH MARBUTA ISOLATED FORM"
\uFE94 "ARABIC LETTER TEH MARBUTA FINAL FORM"
\uFE95 "ARABIC LETTER TEH ISOLATED FORM"
\uFE96 "ARABIC LETTER TEH FINAL FORM"
\uFE97 "ARABIC LETTER TEH INITIAL FORM"
\uFE98 "ARABIC LETTER TEH MEDIAL FORM"
\uFE99 "ARABIC LETTER THEH ISOLATED FORM"
\uFE9A "ARABIC LETTER THEH FINAL FORM"
\uFE9B "ARABIC LETTER THEH INITIAL FORM"
\uFE9C "ARABIC LETTER THEH MEDIAL FORM"
\uFE9D "ARABIC LETTER JEEM ISOLATED FORM"
\uFE9E "ARABIC LETTER JEEM FINAL FORM"
\uFE9F "ARABIC LETTER JEEM INITIAL FORM"
\uFEA0 "ARABIC LETTER JEEM MEDIAL FORM"
\uFEA1 "ARABIC LETTER HAH ISOLATED FORM"
\uFEA2 "ARABIC LETTER HAH FINAL FORM"
\uFEA3 "ARABIC LETTER HAH INITIAL FORM"
\uFEA4 "ARABIC LETTER HAH MEDIAL FORM"
\uFEA5 "ARABIC LETTER KHAH ISOLATED FORM"
\uFEA6 "ARABIC LETTER KHAH FINAL FORM"
\uFEA7 "ARABIC LETTER KHAH INITIAL FORM"
\uFEA8 "ARABIC LETTER KHAH MEDIAL FORM"
\uFEA9 "ARABIC LETTER DAL ISOLATED FORM"
\uFEAA "ARABIC LETTER DAL FINAL FORM"
\uFEAB "ARABIC LETTER THAL ISOLATED FORM"
\uFEAC "ARABIC LETTER THAL FINAL FORM"
\uFEAD "ARABIC LETTER REH ISOLATED FORM"
\uFEAE "ARABIC LETTER REH FINAL FORM"
\uFEAF "ARABIC LETTER ZAIN ISOLATED FORM"
\uFEB0 "ARABIC LETTER ZAIN FINAL FORM"
\uFEB1 "ARABIC LETTER SEEN ISOLATED FORM"
\uFEB2 "ARABIC LETTER SEEN FINAL FORM"
\uFEB3 "ARABIC LETTER SEEN INITIAL FORM"
\uFEB4 "ARABIC LETTER SEEN MEDIAL FORM"
\uFEB5 "ARABIC LETTER SHEEN ISOLATED FORM"
\uFEB6 "ARABIC LETTER SHEEN FINAL FORM"
\uFEB7 "ARABIC LETTER SHEEN INITIAL FORM"
\uFEB8 "ARABIC LETTER SHEEN MEDIAL FORM"
\uFEB9 "ARABIC LETTER SAD ISOLATED FORM"
\uFEBA "ARABIC LETTER SAD FINAL FORM"
\uFEBB "ARABIC LETTER SAD INITIAL FORM"
\uFEBC "ARABIC LETTER SAD MEDIAL FORM"
\uFEBD "ARABIC LETTER DAD ISOLATED FORM"
\uFEBE "ARABIC LETTER DAD FINAL FORM"
\uFEBF "ARABIC LETTER DAD INITIAL FORM"
\uFEC0 "ARABIC LETTER DAD MEDIAL FORM"
\uFEC1 "ARABIC LETTER TAH ISOLATED FORM"
\uFEC2 "ARABIC LETTER TAH FINAL FORM"
\uFEC3 "ARABIC LETTER TAH INITIAL FORM"
\uFEC4 "ARABIC LETTER TAH MEDIAL FORM"
\uFEC5 "ARABIC LETTER ZAH ISOLATED FORM"
\uFEC6 "ARABIC LETTER ZAH FINAL FORM"
\uFEC7 "ARABIC LETTER ZAH INITIAL FORM"
\uFEC8 "ARABIC LETTER ZAH MEDIAL FORM"
\uFEC9 "ARABIC LETTER AIN ISOLATED FORM"
\uFECA "ARABIC LETTER AIN FINAL FORM"
\uFECB "ARABIC LETTER AIN INITIAL FORM"
\uFECC "ARABIC LETTER AIN MEDIAL FORM"
\uFECD "ARABIC LETTER GHAIN ISOLATED FORM"
\uFECE "ARABIC LETTER GHAIN FINAL FORM"
\uFECF "ARABIC LETTER GHAIN INITIAL FORM"
\uFED0 "ARABIC LETTER GHAIN MEDIAL FORM"
\uFED1 "ARABIC LETTER FEH ISOLATED FORM"
\uFED2 "ARABIC LETTER FEH FINAL FORM"
\uFED3 "ARABIC LETTER FEH INITIAL FORM"
\uFED4 "ARABIC LETTER FEH MEDIAL FORM"
\uFED5 "ARABIC LETTER QAF ISOLATED FORM"
\uFED6 "ARABIC LETTER QAF FINAL FORM"
\uFED7 "ARABIC LETTER QAF INITIAL FORM"
\uFED8 "ARABIC LETTER QAF MEDIAL FORM"
\uFED9 "ARABIC LETTER KAF ISOLATED FORM"
\uFEDA "ARABIC LETTER KAF FINAL FORM"
\uFEDB "ARABIC LETTER KAF INITIAL FORM"
\uFEDC "ARABIC LETTER KAF MEDIAL FORM"
\uFEDD "ARABIC LETTER LAM ISOLATED FORM"
\uFEDE "ARABIC LETTER LAM FINAL FORM"
\uFEDF "ARABIC LETTER LAM INITIAL FORM"
\uFEE0 "ARABIC LETTER LAM MEDIAL FORM"
\uFEE1 "ARABIC LETTER MEEM ISOLATED FORM"
\uFEE2 "ARABIC LETTER MEEM FINAL FORM"
\uFEE3 "ARABIC LETTER MEEM INITIAL FORM"
\uFEE4 "ARABIC LETTER MEEM MEDIAL FORM"
\uFEE5 "ARABIC LETTER NOON ISOLATED FORM"
\uFEE6 "ARABIC LETTER NOON FINAL FORM"
\uFEE7 "ARABIC LETTER NOON INITIAL FORM"
\uFEE8 "ARABIC LETTER NOON MEDIAL FORM"
\uFEE9 "ARABIC LETTER HEH ISOLATED FORM"
\uFEEA "ARABIC LETTER HEH FINAL FORM"
\uFEEB "ARABIC LETTER HEH INITIAL FORM"
\uFEEC "ARABIC LETTER HEH MEDIAL FORM"
\uFEED "ARABIC LETTER WAW ISOLATED FORM"
\uFEEE "ARABIC LETTER WAW FINAL FORM"
\uFEEF "ARABIC LETTER ALEF MAKSURA ISOLATED FORM"
\uFEF0 "ARABIC LETTER ALEF MAKSURA FINAL FORM"
\uFEF1 "ARABIC LETTER YEH ISOLATED FORM"
\uFEF2 "ARABIC LETTER YEH FINAL FORM"
\uFEF3 "ARABIC LETTER YEH INITIAL FORM"
\uFEF4 "ARABIC LETTER YEH MEDIAL FORM"
\uFEF5 "ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE ISOLATED FORM"
\uFEF6 "ARABIC LIGATURE LAM WITH ALEF WITH MADDA ABOVE FINAL FORM"
\uFEF7 "ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE ISOLATED FORM"
\uFEF8 "ARABIC LIGATURE LAM WITH ALEF WITH HAMZA ABOVE FINAL FORM"
\uFEF9 "ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW ISOLATED FORM"
\uFEFA "ARABIC LIGATURE LAM WITH ALEF WITH HAMZA BELOW FINAL FORM"
\uFEFB "ARABIC LIGATURE LAM WITH ALEF ISOLATED FORM"
\uFEFC "ARABIC LIGATURE LAM WITH ALEF FINAL FORM"
\uFEFF "ZERO WIDTH NO-BREAK SPACE"
\uFF01 "FULLWIDTH EXCLAMATION MARK"
\uFF02 "FULLWIDTH QUOTATION MARK"
\uFF03 "FULLWIDTH NUMBER SIGN"
\uFF04 "FULLWIDTH DOLLAR SIGN"
\uFF05 "FULLWIDTH PERCENT SIGN"
\uFF06 "FULLWIDTH AMPERSAND"
\uFF07 "FULLWIDTH APOSTROPHE"
\uFF08 "FULLWIDTH LEFT PARENTHESIS"
\uFF09 "FULLWIDTH RIGHT PARENTHESIS"
\uFF0A "FULLWIDTH ASTERISK"
\uFF0B "FULLWIDTH PLUS SIGN"
\uFF0C "FULLWIDTH COMMA"
\uFF0D "FULLWIDTH HYPHEN-MINUS"
\uFF0E "FULLWIDTH FULL STOP"
\uFF0F "FULLWIDTH SOLIDUS"
\uFF10 "FULLWIDTH DIGIT ZERO"
\uFF11 "FULLWIDTH DIGIT ONE"
\uFF12 "FULLWIDTH DIGIT TWO"
\uFF13 "FULLWIDTH DIGIT THREE"
\uFF14 "FULLWIDTH DIGIT FOUR"
\uFF15 "FULLWIDTH DIGIT FIVE"
\uFF16 "FULLWIDTH DIGIT SIX"
\uFF17 "FULLWIDTH DIGIT SEVEN"
\uFF18 "FULLWIDTH DIGIT EIGHT"
\uFF19 "FULLWIDTH DIGIT NINE"
\uFF1A "FULLWIDTH COLON"
\uFF1B "FULLWIDTH SEMICOLON"
\uFF1C "FULLWIDTH LESS-THAN SIGN"
\uFF1D "FULLWIDTH EQUALS SIGN"
\uFF1E "FULLWIDTH GREATER-THAN SIGN"
\uFF1F "FULLWIDTH QUESTION MARK"
\uFF20 "FULLWIDTH COMMERCIAL AT"
\uFF21 "FULLWIDTH LATIN CAPITAL LETTER A"
\uFF22 "FULLWIDTH LATIN CAPITAL LETTER B"
\uFF23 "FULLWIDTH LATIN CAPITAL LETTER C"
\uFF24 "FULLWIDTH LATIN CAPITAL LETTER D"
\uFF25 "FULLWIDTH LATIN CAPITAL LETTER E"
\uFF26 "FULLWIDTH LATIN CAPITAL LETTER F"
\uFF27 "FULLWIDTH LATIN CAPITAL LETTER G"
\uFF28 "FULLWIDTH LATIN CAPITAL LETTER H"
\uFF29 "FULLWIDTH LATIN CAPITAL LETTER I"
\uFF2A "FULLWIDTH LATIN CAPITAL LETTER J"
\uFF2B "FULLWIDTH LATIN CAPITAL LETTER K"
\uFF2C "FULLWIDTH LATIN CAPITAL LETTER L"
\uFF2D "FULLWIDTH LATIN CAPITAL LETTER M"
\uFF2E "FULLWIDTH LATIN CAPITAL LETTER N"
\uFF2F "FULLWIDTH LATIN CAPITAL LETTER O"
\uFF30 "FULLWIDTH LATIN CAPITAL LETTER P"
\uFF31 "FULLWIDTH LATIN CAPITAL LETTER Q"
\uFF32 "FULLWIDTH LATIN CAPITAL LETTER R"
\uFF33 "FULLWIDTH LATIN CAPITAL LETTER S"
\uFF34 "FULLWIDTH LATIN CAPITAL LETTER T"
\uFF35 "FULLWIDTH LATIN CAPITAL LETTER U"
\uFF36 "FULLWIDTH LATIN CAPITAL LETTER V"
\uFF37 "FULLWIDTH LATIN CAPITAL LETTER W"
\uFF38 "FULLWIDTH LATIN CAPITAL LETTER X"
\uFF39 "FULLWIDTH LATIN CAPITAL LETTER Y"
\uFF3A "FULLWIDTH LATIN CAPITAL LETTER Z"
\uFF3B "FULLWIDTH LEFT SQUARE BRACKET"
\uFF3C "FULLWIDTH REVERSE SOLIDUS"
\uFF3D "FULLWIDTH RIGHT SQUARE BRACKET"
\uFF3E "FULLWIDTH CIRCUMFLEX ACCENT"
\uFF3F "FULLWIDTH LOW LINE"
\uFF40 "FULLWIDTH GRAVE ACCENT"
\uFF41 "FULLWIDTH LATIN SMALL LETTER A"
\uFF42 "FULLWIDTH LATIN SMALL LETTER B"
\uFF43 "FULLWIDTH LATIN SMALL LETTER C"
\uFF44 "FULLWIDTH LATIN SMALL LETTER D"
\uFF45 "FULLWIDTH LATIN SMALL LETTER E"
\uFF46 "FULLWIDTH LATIN SMALL LETTER F"
\uFF47 "FULLWIDTH LATIN SMALL LETTER G"
\uFF48 "FULLWIDTH LATIN SMALL LETTER H"
\uFF49 "FULLWIDTH LATIN SMALL LETTER I"
\uFF4A "FULLWIDTH LATIN SMALL LETTER J"
\uFF4B "FULLWIDTH LATIN SMALL LETTER K"
\uFF4C "FULLWIDTH LATIN SMALL LETTER L"
\uFF4D "FULLWIDTH LATIN SMALL LETTER M"
\uFF4E "FULLWIDTH LATIN SMALL LETTER N"
\uFF4F "FULLWIDTH LATIN SMALL LETTER O"
\uFF50 "FULLWIDTH LATIN SMALL LETTER P"
\uFF51 "FULLWIDTH LATIN SMALL LETTER Q"
\uFF52 "FULLWIDTH LATIN SMALL LETTER R"
\uFF53 "FULLWIDTH LATIN SMALL LETTER S"
\uFF54 "FULLWIDTH LATIN SMALL LETTER T"
\uFF55 "FULLWIDTH LATIN SMALL LETTER U"
\uFF56 "FULLWIDTH LATIN SMALL LETTER V"
\uFF57 "FULLWIDTH LATIN SMALL LETTER W"
\uFF58 "FULLWIDTH LATIN SMALL LETTER X"
\uFF59 "FULLWIDTH LATIN SMALL LETTER Y"
\uFF5A "FULLWIDTH LATIN SMALL LETTER Z"
\uFF5B "FULLWIDTH LEFT CURLY BRACKET"
\uFF5C "FULLWIDTH VERTICAL LINE"
\uFF5D "FULLWIDTH RIGHT CURLY BRACKET"
\uFF5E "FULLWIDTH TILDE"
\uFF5F "FULLWIDTH LEFT WHITE PARENTHESIS"
\uFF60 "FULLWIDTH RIGHT WHITE PARENTHESIS"
\uFF61 "HALFWIDTH IDEOGRAPHIC FULL STOP"
\uFF62 "HALFWIDTH LEFT CORNER BRACKET"
\uFF63 "HALFWIDTH RIGHT CORNER BRACKET"
\uFF64 "HALFWIDTH IDEOGRAPHIC COMMA"
\uFF65 "HALFWIDTH KATAKANA MIDDLE DOT"
\uFF66 "HALFWIDTH KATAKANA LETTER WO"
\uFF67 "HALFWIDTH KATAKANA LETTER SMALL A"
\uFF68 "HALFWIDTH KATAKANA LETTER SMALL I"
\uFF69 "HALFWIDTH KATAKANA LETTER SMALL U"
\uFF6A "HALFWIDTH KATAKANA LETTER SMALL E"
\uFF6B "HALFWIDTH KATAKANA LETTER SMALL O"
\uFF6C "HALFWIDTH KATAKANA LETTER SMALL YA"
\uFF6D "HALFWIDTH KATAKANA LETTER SMALL YU"
\uFF6E "HALFWIDTH KATAKANA LETTER SMALL YO"
\uFF6F "HALFWIDTH KATAKANA LETTER SMALL TU"
\uFF70 "HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK"
\uFF71 "HALFWIDTH KATAKANA LETTER A"
\uFF72 "HALFWIDTH KATAKANA LETTER I"
\uFF73 "HALFWIDTH KATAKANA LETTER U"
\uFF74 "HALFWIDTH KATAKANA LETTER E"
\uFF75 "HALFWIDTH KATAKANA LETTER O"
\uFF76 "HALFWIDTH KATAKANA LETTER KA"
\uFF77 "HALFWIDTH KATAKANA LETTER KI"
\uFF78 "HALFWIDTH KATAKANA LETTER KU"
\uFF79 "HALFWIDTH KATAKANA LETTER KE"
\uFF7A "HALFWIDTH KATAKANA LETTER KO"
\uFF7B "HALFWIDTH KATAKANA LETTER SA"
\uFF7C "HALFWIDTH KATAKANA LETTER SI"
\uFF7D "HALFWIDTH KATAKANA LETTER SU"
\uFF7E "HALFWIDTH KATAKANA LETTER SE"
\uFF7F "HALFWIDTH KATAKANA LETTER SO"
\uFF80 "HALFWIDTH KATAKANA LETTER TA"
\uFF81 "HALFWIDTH KATAKANA LETTER TI"
\uFF82 "HALFWIDTH KATAKANA LETTER TU"
\uFF83 "HALFWIDTH KATAKANA LETTER TE"
\uFF84 "HALFWIDTH KATAKANA LETTER TO"
\uFF85 "HALFWIDTH KATAKANA LETTER NA"
\uFF86 "HALFWIDTH KATAKANA LETTER NI"
\uFF87 "HALFWIDTH KATAKANA LETTER NU"
\uFF88 "HALFWIDTH KATAKANA LETTER NE"
\uFF89 "HALFWIDTH KATAKANA LETTER NO"
\uFF8A "HALFWIDTH KATAKANA LETTER HA"
\uFF8B "HALFWIDTH KATAKANA LETTER HI"
\uFF8C "HALFWIDTH KATAKANA LETTER HU"
\uFF8D "HALFWIDTH KATAKANA LETTER HE"
\uFF8E "HALFWIDTH KATAKANA LETTER HO"
\uFF8F "HALFWIDTH KATAKANA LETTER MA"
\uFF90 "HALFWIDTH KATAKANA LETTER MI"
\uFF91 "HALFWIDTH KATAKANA LETTER MU"
\uFF92 "HALFWIDTH KATAKANA LETTER ME"
\uFF93 "HALFWIDTH KATAKANA LETTER MO"
\uFF94 "HALFWIDTH KATAKANA LETTER YA"
\uFF95 "HALFWIDTH KATAKANA LETTER YU"
\uFF96 "HALFWIDTH KATAKANA LETTER YO"
\uFF97 "HALFWIDTH KATAKANA LETTER RA"
\uFF98 "HALFWIDTH KATAKANA LETTER RI"
\uFF99 "HALFWIDTH KATAKANA LETTER RU"
\uFF9A "HALFWIDTH KATAKANA LETTER RE"
\uFF9B "HALFWIDTH KATAKANA LETTER RO"
\uFF9C "HALFWIDTH KATAKANA LETTER WA"
\uFF9D "HALFWIDTH KATAKANA LETTER N"
\uFF9E "HALFWIDTH KATAKANA VOICED SOUND MARK"
\uFF9F "HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK"
\uFFA0 "HALFWIDTH HANGUL FILLER"
\uFFA1 "HALFWIDTH HANGUL LETTER KIYEOK"
\uFFA2 "HALFWIDTH HANGUL LETTER SSANGKIYEOK"
\uFFA3 "HALFWIDTH HANGUL LETTER KIYEOK-SIOS"
\uFFA4 "HALFWIDTH HANGUL LETTER NIEUN"
\uFFA5 "HALFWIDTH HANGUL LETTER NIEUN-CIEUC"
\uFFA6 "HALFWIDTH HANGUL LETTER NIEUN-HIEUH"
\uFFA7 "HALFWIDTH HANGUL LETTER TIKEUT"
\uFFA8 "HALFWIDTH HANGUL LETTER SSANGTIKEUT"
\uFFA9 "HALFWIDTH HANGUL LETTER RIEUL"
\uFFAA "HALFWIDTH HANGUL LETTER RIEUL-KIYEOK"
\uFFAB "HALFWIDTH HANGUL LETTER RIEUL-MIEUM"
\uFFAC "HALFWIDTH HANGUL LETTER RIEUL-PIEUP"
\uFFAD "HALFWIDTH HANGUL LETTER RIEUL-SIOS"
\uFFAE "HALFWIDTH HANGUL LETTER RIEUL-THIEUTH"
\uFFAF "HALFWIDTH HANGUL LETTER RIEUL-PHIEUPH"
\uFFB0 "HALFWIDTH HANGUL LETTER RIEUL-HIEUH"
\uFFB1 "HALFWIDTH HANGUL LETTER MIEUM"
\uFFB2 "HALFWIDTH HANGUL LETTER PIEUP"
\uFFB3 "HALFWIDTH HANGUL LETTER SSANGPIEUP"
\uFFB4 "HALFWIDTH HANGUL LETTER PIEUP-SIOS"
\uFFB5 "HALFWIDTH HANGUL LETTER SIOS"
\uFFB6 "HALFWIDTH HANGUL LETTER SSANGSIOS"
\uFFB7 "HALFWIDTH HANGUL LETTER IEUNG"
\uFFB8 "HALFWIDTH HANGUL LETTER CIEUC"
\uFFB9 "HALFWIDTH HANGUL LETTER SSANGCIEUC"
\uFFBA "HALFWIDTH HANGUL LETTER CHIEUCH"
\uFFBB "HALFWIDTH HANGUL LETTER KHIEUKH"
\uFFBC "HALFWIDTH HANGUL LETTER THIEUTH"
\uFFBD "HALFWIDTH HANGUL LETTER PHIEUPH"
\uFFBE "HALFWIDTH HANGUL LETTER HIEUH"
\uFFC2 "HALFWIDTH HANGUL LETTER A"
\uFFC3 "HALFWIDTH HANGUL LETTER AE"
\uFFC4 "HALFWIDTH HANGUL LETTER YA"
\uFFC5 "HALFWIDTH HANGUL LETTER YAE"
\uFFC6 "HALFWIDTH HANGUL LETTER EO"
\uFFC7 "HALFWIDTH HANGUL LETTER E"
\uFFCA "HALFWIDTH HANGUL LETTER YEO"
\uFFCB "HALFWIDTH HANGUL LETTER YE"
\uFFCC "HALFWIDTH HANGUL LETTER O"
\uFFCD "HALFWIDTH HANGUL LETTER WA"
\uFFCE "HALFWIDTH HANGUL LETTER WAE"
\uFFCF "HALFWIDTH HANGUL LETTER OE"
\uFFD2 "HALFWIDTH HANGUL LETTER YO"
\uFFD3 "HALFWIDTH HANGUL LETTER U"
\uFFD4 "HALFWIDTH HANGUL LETTER WEO"
\uFFD5 "HALFWIDTH HANGUL LETTER WE"
\uFFD6 "HALFWIDTH HANGUL LETTER WI"
\uFFD7 "HALFWIDTH HANGUL LETTER YU"
\uFFDA "HALFWIDTH HANGUL LETTER EU"
\uFFDB "HALFWIDTH HANGUL LETTER YI"
\uFFDC "HALFWIDTH HANGUL LETTER I"
\uFFE0 "FULLWIDTH CENT SIGN"
\uFFE1 "FULLWIDTH POUND SIGN"
\uFFE2 "FULLWIDTH NOT SIGN"
\uFFE3 "FULLWIDTH MACRON"
\uFFE4 "FULLWIDTH BROKEN BAR"
\uFFE5 "FULLWIDTH YEN SIGN"
\uFFE6 "FULLWIDTH WON SIGN"
\uFFE8 "HALFWIDTH FORMS LIGHT VERTICAL"
\uFFE9 "HALFWIDTH LEFTWARDS ARROW"
\uFFEA "HALFWIDTH UPWARDS ARROW"
\uFFEB "HALFWIDTH RIGHTWARDS ARROW"
\uFFEC "HALFWIDTH DOWNWARDS ARROW"
\uFFED "HALFWIDTH BLACK SQUARE"
\uFFEE "HALFWIDTH WHITE CIRCLE"
\uFFF9 "INTERLINEAR ANNOTATION ANCHOR"
\uFFFA "INTERLINEAR ANNOTATION SEPARATOR"
\uFFFB "INTERLINEAR ANNOTATION TERMINATOR"
\uFFFC "OBJECT REPLACEMENT CHARACTER"
\uFFFD "REPLACEMENT CHARACTER"
};

if {$CommandLineProgram != ""} {set program $CommandLineProgram}
if {[SelectProgram $program] != 1} {
    update;
    after 5000; #Give the user a chance to see the message
    SelectProgram tcl
}

if {[string equal $CommandLineUserClassFile ""] == 0} {
    ReadUserClasses $CommandLineUserClassFile;
}
if {$InitialTestInputDataFile != ""} {
    LoadTestInputData $InitialTestInputDataFile;
    if {$PipeP} {ShowMessage [_ "You can't read test data from a pipe and from a file."]}
}
if {$PipeP} {LoadTestInputData}
bind $::IND <<B3>> {ShowCode %W %x %y}
bind $::OUT <<B3>> {ShowCode %W %x %y}
bind $::COM <<B3>> {ShowCode %W %x %y}
focus -force $::REG;
FlushJournal;
