8866 lines
216 KiB
Java
8866 lines
216 KiB
Java
// -*- java -*- to avoid jde mode, which is slow on this big a file on
|
|
// one of my boxes
|
|
|
|
/*
|
|
The contents of this file are subject to the THDL Open Community License
|
|
Version 1.0 (the "License"); you may not use this file except in compliance
|
|
with the License. You may obtain a copy of the License on the THDL web site
|
|
(http://www.thdl.org/).
|
|
|
|
Software distributed under the License is distributed on an "AS IS" basis,
|
|
WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
|
|
License for the specific terms governing rights and limitations under the
|
|
License.
|
|
|
|
The Initial Developer of this software is the Tibetan and Himalayan Digital
|
|
Library (THDL). Portions created by the THDL are Copyright 2003 THDL.
|
|
All Rights Reserved.
|
|
|
|
Contributor(s): ______________________________________.
|
|
*/
|
|
|
|
package org.thdl.tib.text.ttt;
|
|
|
|
import org.thdl.util.ThdlOptions;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import junit.framework.TestCase;
|
|
|
|
|
|
/** Tests this package, especially {@link #TPairListFactory} and
|
|
* {@link #TPairList}.
|
|
*
|
|
* @author David Chandler */
|
|
public class PackageTest extends TestCase {
|
|
|
|
/** Invokes a text UI and runs all this class's tests. */
|
|
public static void main(String[] args) {
|
|
junit.textui.TestRunner.run(PackageTest.class);
|
|
}
|
|
|
|
protected void setUp() {
|
|
// We don't want to use options.txt:
|
|
ThdlOptions.forTestingOnlyInitializeWithoutDefaultOptionsFile();
|
|
|
|
// We don't want to load the TM or TMW font files ourselves:
|
|
ThdlOptions.setUserPreference("thdl.rely.on.system.tmw.fonts", true);
|
|
ThdlOptions.setUserPreference("thdl.rely.on.system.tm.fonts", true);
|
|
ThdlOptions.setUserPreference("thdl.debug", true);
|
|
}
|
|
|
|
|
|
public PackageTest() { }
|
|
private static void tstHelper(String acip) {
|
|
tstHelper2(acip, null, false, null, null, null);
|
|
}
|
|
private static void tstHelper(String acip, String expectedPairs) {
|
|
tstHelper2(acip, expectedPairs, false, null, null, null);
|
|
}
|
|
private static void tstHelper(String acip, String[] expectedParses) {
|
|
tstHelper2(acip, null, false, expectedParses, null, null);
|
|
}
|
|
private static void tstHelper(String acip, String expectedPairs, String[] expectedParses) {
|
|
tstHelper2(acip, expectedPairs, false, expectedParses, null, null);
|
|
}
|
|
private static void tstHelper(String acip, String expectedPairs, String[] expectedParses, String[] legalParses) {
|
|
tstHelper2(acip, expectedPairs, false, expectedParses, legalParses, null);
|
|
}
|
|
private static void tstHelper(String acip, String expectedPairs, String[] expectedParses, String[] legalParses, String expectedBestParse) {
|
|
tstHelper2(acip, expectedPairs, false, expectedParses, legalParses, expectedBestParse);
|
|
}
|
|
private static void tstHelper2(String acip) {
|
|
tstHelper2(acip, null);
|
|
}
|
|
private static void tstHelper2(String acip, String expectedPairs) {
|
|
tstHelper2(acip, expectedPairs, true, null, null, null);
|
|
}
|
|
|
|
private static final boolean sdebug = false;
|
|
private static void tstHelper2(String acip,
|
|
String expectedPairs,
|
|
boolean debug,
|
|
String[] expectedParses,
|
|
String[] expectedLegalParses,
|
|
String expectedBestParse) {
|
|
TPairList l = TPairListFactory.breakACIPIntoChunks(acip);
|
|
if (sdebug || debug)
|
|
System.out.println("ACIP=" + acip + " and l'=" + l);
|
|
if (expectedPairs != null) {
|
|
if (!l.equals(expectedPairs)) {
|
|
System.out.println("acip=" + acip + "; chunks=" + l + "; expected chunks=" + expectedPairs);
|
|
assertTrue(false);
|
|
}
|
|
}
|
|
|
|
TParseTree pt = l.getParseTree();
|
|
if (pt == null) {
|
|
if (sdebug || debug)
|
|
System.out.println("ACIP=" + acip + " and no parses exists; /numParses 0");
|
|
System.out.println("ACIPNoParseError: NO PARSE for the ACIP {" + acip + "}");
|
|
assertTrue(null == expectedParses || expectedParses.length == 0);
|
|
assertTrue(null == expectedLegalParses || expectedLegalParses.length == 0);
|
|
return;
|
|
} else {
|
|
if (pt.getWarning("Most", l, acip) != null) {
|
|
System.out.println(pt.getWarning("Most", l, acip));
|
|
} else if (pt.getWarning("All", l, acip) != null)
|
|
if (sdebug || debug) System.out.println("Paranoiac warning is this: " + pt.getWarning("All", l, acip));
|
|
}
|
|
int np = pt.numberOfParses();
|
|
boolean goodness = expectedParses == null || expectedParses.length == np;
|
|
if (sdebug || debug || !goodness)
|
|
System.out.println("ACIP=" + acip + " and parse tree=" + pt + " /size " + pt.size() + "; /pairs " + pt.numberOfPairs() + "; /numParses " + np);
|
|
assertTrue(goodness);
|
|
|
|
{
|
|
ParseIterator pi = pt.getParseIterator();
|
|
for (int i = 0 ; i < np; i++) {
|
|
TStackList n = pi.next();
|
|
if (sdebug || debug)
|
|
System.out.println("Parse " + (i + 1) + " is " + n + " which has " + n.size() + " glyphs.");
|
|
boolean okay = (null == expectedParses || n.equals(expectedParses[i]));
|
|
if (!okay)
|
|
System.out.println("Parse " + (i) + " (from zero) is " + n + " (toString2=" + n.toString2() + ") and expected is " + expectedParses[i]);
|
|
assertTrue(okay);
|
|
}
|
|
assertTrue(!pi.hasNext());
|
|
}
|
|
|
|
{
|
|
TStackListList legalParses = pt.getUniqueParse(false);
|
|
boolean goodness2 = (expectedLegalParses == null
|
|
|| expectedLegalParses.length == legalParses.size());
|
|
for (int i = 0 ; i < legalParses.size(); i++) {
|
|
TStackList n = legalParses.get(i);
|
|
if (sdebug || debug)
|
|
System.out.println("Legal parse " + (i + 1) + " is " + n + " which has " + n.size() + " glyphs.");
|
|
boolean okay = (null == expectedLegalParses
|
|
|| expectedLegalParses.length < i+1
|
|
|| n.equals(expectedLegalParses[i]));
|
|
if (!okay || !goodness2)
|
|
System.out.println("Legal parse " + (i) + " (from zero) is " + n + " (toString2=" + n.toString2() + ") and expected is "
|
|
+ ((i < expectedLegalParses.length)
|
|
? expectedLegalParses[i]
|
|
: "not present"));
|
|
assertTrue(okay);
|
|
}
|
|
if (!goodness2)
|
|
System.out.println("You expected " + expectedLegalParses.length + " legal parses, but there were instead " + legalParses.size() + " legal parses for ACIP " + acip + ".");
|
|
assertTrue(goodness2);
|
|
TStackListList allLegalParses = pt.getLegalParses();
|
|
TStackListList decentParses = pt.getNonIllegalParses();
|
|
if (pt.getBestParse() == null) {
|
|
if (legalParses.size() == 0) {
|
|
if (null != expectedBestParse && !"".equals(expectedBestParse)) {
|
|
System.out.print("Expected is that there is a best parse \"" + expectedBestParse + "\" but there is no best parse for ACIP {" + acip + "}");
|
|
assertTrue(false);
|
|
}
|
|
System.out.print("ACIPNoBestParseError: There is no best parse for the ACIP {" + acip + "}; ");
|
|
|
|
if (decentParses.size() == 1) {
|
|
System.out.println("ACIPNoLegalParseError: NO LEGAL PARSE for the unambiguous ACIP {" + acip + "} (i.e., exactly one illegal parse exists, so it's unambiguous)");
|
|
// DLC FIXME: it's really unambiguous if one illegal parse has fewer glyphs than any other? {shthA'I} might be an example... but NO! because you go left-to-right to make stacks, except think of BRTAN vs. BRAN, they break that rule... ???? DLC ????
|
|
} else {
|
|
System.out.println("ACIPNoLegalParseError: NO PARSES for ACIP {" + acip + "}, decent parses are " + decentParses);
|
|
}
|
|
} else {
|
|
if (legalParses.size() > 1) {
|
|
System.out.println("ACIPTooManyLegalParsesError: see these " + legalParses.size() + " legal parses for ACIP " + acip + ": " + legalParses);
|
|
assertTrue(legalParses.size() == 2
|
|
&& (legalParses.get(0).size()
|
|
== 1 + legalParses.get(1).size()));
|
|
}
|
|
}
|
|
} else {
|
|
if (legalParses.size() != 1) {
|
|
if (sdebug || debug) System.out.println("Best parse exists but there are none or two or more legal parses for ACIP {" + acip + "}");
|
|
}
|
|
if (null != expectedBestParse) {
|
|
boolean good = pt.getBestParse().equals(expectedBestParse);
|
|
if (!good) {
|
|
System.out.print("Expected best parse is \"" + expectedBestParse + "\" but the best parse is " + pt.getBestParse() + " for ACIP {" + acip + "}");
|
|
}
|
|
assertTrue(good);
|
|
}
|
|
if (sdebug || debug) System.out.println("There is a best parse for the slightly rocky ACIP {" + acip + "}");
|
|
}
|
|
|
|
if (allLegalParses.size() != legalParses.size()) {
|
|
if (sdebug || debug)
|
|
System.out.println("allLegalParses are " + allLegalParses + " and legalParses are " + legalParses);
|
|
}
|
|
}
|
|
if (l.getACIPError() != null)
|
|
System.out.println("ACIPError: " + l.getACIPError());
|
|
if (!l.recoverACIP().equals(acip)
|
|
&& (acip.indexOf("A+") < 1) // which becomes +, e.g. {NA+YA}
|
|
&& (acip.indexOf('0') < 0)
|
|
&& (acip.indexOf('1') < 0)
|
|
&& (acip.indexOf('2') < 0)
|
|
&& (acip.indexOf('3') < 0)
|
|
&& (acip.indexOf('4') < 0)
|
|
&& (acip.indexOf('5') < 0)
|
|
&& (acip.indexOf('6') < 0)
|
|
&& (acip.indexOf('7') < 0)
|
|
&& (acip.indexOf('8') < 0)
|
|
&& (acip.indexOf('9') < 0)) {
|
|
System.out.println("acip=" + acip
|
|
+ "; recovery is " + l.recoverACIP());
|
|
assertTrue(false);
|
|
}
|
|
}
|
|
|
|
// DLC FIXME: warn if we have to use the "what stacks take a GA prefix?" rules to get a unique legal parse.
|
|
|
|
public void testCutoff() {
|
|
// this would be exponential running time, so we cut it off:
|
|
tstHelper("BRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTNBRTN");
|
|
}
|
|
|
|
public void testSlowestTshegBar() {
|
|
// this would be exponential running time, so we cut it off:
|
|
tstHelper("BRTNBRTNBRTNB");
|
|
}
|
|
|
|
public void testPerformance() {
|
|
tstHelper("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
|
|
tstHelper("9012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678");
|
|
}
|
|
|
|
/** Tests {@link TPairListFactory#breakACIPIntoChunks(String)},
|
|
* {@link TPairList#getACIPError()}, and {@link
|
|
* TPairList#recoverACIP()}. */
|
|
public void testBreakACIPIntoChunks() {
|
|
tstHelper("GASN"); // ambiguous with regard to prefix rules
|
|
tstHelper("BARMA"); // ambiguous with regard to prefix rules
|
|
tstHelper("MARDA"); // ambiguous with regard to prefix rules
|
|
tstHelper("BBA"); // ambiguous with regard to prefix rules
|
|
tstHelper("BBLUGS"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDRA"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDRAG"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDRA'I"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDRAL"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDRAN"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDRANGS"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDREN"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDRI"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDRIS"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDROL"); // ambiguous with regard to prefix rules
|
|
tstHelper("BDRUG"); // ambiguous with regard to prefix rules
|
|
tstHelper("BLCAG"); // ambiguous with regard to prefix rules
|
|
tstHelper("BLCI"); // ambiguous with regard to prefix rules
|
|
tstHelper("BLKONG"); // ambiguous with regard to prefix rules
|
|
tstHelper("BLNGA"); // ambiguous with regard to prefix rules
|
|
tstHelper("BLNGAG"); // ambiguous with regard to prefix rules
|
|
tstHelper("BMA"); // ambiguous with regard to prefix rules
|
|
tstHelper("BMYOD"); // ambiguous with regard to prefix rules
|
|
tstHelper("BSALDA"); // ambiguous with regard to prefix rules
|
|
tstHelper("BSAMS"); // ambiguous with regard to prefix rules
|
|
tstHelper("BSEMS"); // ambiguous with regard to prefix rules
|
|
tstHelper("BTSAMS"); // ambiguous with regard to prefix rules
|
|
tstHelper("BTSIMS"); // ambiguous with regard to prefix rules
|
|
tstHelper("DDANG"); // ambiguous with regard to prefix rules
|
|
tstHelper("DDAR"); // ambiguous with regard to prefix rules
|
|
tstHelper("DDRANGS"); // ambiguous with regard to prefix rules
|
|
tstHelper("DDRUG"); // ambiguous with regard to prefix rules
|
|
tstHelper("DNAG"); // ambiguous with regard to prefix rules
|
|
tstHelper("DNOGS"); // ambiguous with regard to prefix rules
|
|
tstHelper("DRBAN"); // ambiguous with regard to prefix rules
|
|
tstHelper("DRGYU"); // ambiguous with regard to prefix rules
|
|
tstHelper("DRTOG"); // ambiguous with regard to prefix rules
|
|
tstHelper("DYA"); // ambiguous with regard to prefix rules
|
|
tstHelper("DYAN"); // ambiguous with regard to prefix rules
|
|
tstHelper("GDRA"); // ambiguous with regard to prefix rules
|
|
tstHelper("GDRIM"); // ambiguous with regard to prefix rules
|
|
tstHelper("GGAN"); // ambiguous with regard to prefix rules
|
|
tstHelper("GGYUR"); // ambiguous with regard to prefix rules
|
|
tstHelper("GLTAR"); // ambiguous with regard to prefix rules
|
|
tstHelper("GLTUNG"); // ambiguous with regard to prefix rules
|
|
tstHelper("GMA"); // ambiguous with regard to prefix rules
|
|
tstHelper("GMAN"); // ambiguous with regard to prefix rules
|
|
tstHelper("GMON"); // ambiguous with regard to prefix rules
|
|
tstHelper("GRDEGS"); // ambiguous with regard to prefix rules
|
|
tstHelper("GRDZU"); // ambiguous with regard to prefix rules
|
|
tstHelper("GRGYA"); // ambiguous with regard to prefix rules
|
|
tstHelper("GRNAGS"); // ambiguous with regard to prefix rules
|
|
tstHelper("GRTAN"); // ambiguous with regard to prefix rules
|
|
tstHelper("GRTOGS"); // ambiguous with regard to prefix rules
|
|
tstHelper("GRTZO"); // ambiguous with regard to prefix rules
|
|
tstHelper("GRTZOD"); // ambiguous with regard to prefix rules
|
|
tstHelper("GRTZON"); // ambiguous with regard to prefix rules
|
|
tstHelper("GSLA"); // ambiguous with regard to prefix rules
|
|
tstHelper("GSNAD"); // ambiguous with regard to prefix rules
|
|
tstHelper("GZLA"); // ambiguous with regard to prefix rules
|
|
tstHelper("MBA"); // ambiguous with regard to prefix rules
|
|
tstHelper("MBA'"); // ambiguous with regard to prefix rules
|
|
tstHelper("MBI'I"); // ambiguous with regard to prefix rules
|
|
tstHelper("MHA'A"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRDA"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRDO"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRDZOGS"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRGA"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRGAD"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRGAN"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRJES"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRJOD"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRTOGS"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRTOL"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRTZE'I"); // ambiguous with regard to prefix rules
|
|
tstHelper("MRTZIGS"); // ambiguous with regard to prefix rules
|
|
tstHelper("MSAM"); // ambiguous with regard to prefix rules
|
|
tstHelper("MSGRIB"); // ambiguous with regard to prefix rules
|
|
tstHelper("MSKYES"); // ambiguous with regard to prefix rules
|
|
tstHelper("MSON"); // ambiguous with regard to prefix rules
|
|
tstHelper("MSOS"); // ambiguous with regard to prefix rules
|
|
tstHelper("MSTAMS"); // ambiguous with regard to prefix rules
|
|
tstHelper("MSTAN"); // ambiguous with regard to prefix rules
|
|
|
|
|
|
|
|
|
|
tstHelper("KA'", "[(K . A), (' . )]",
|
|
new String[] { "{KA}{'}" },
|
|
new String[] { "{KA}{'}" },
|
|
"{KA}{'}"); // DLC NOW
|
|
|
|
tstHelper("A'AAMA", "{A}{'}{AA}{MA}"); // FIXME: how should we parse this?
|
|
|
|
tstHelper("K+K+KA", "{K+}{K+}{KA}");
|
|
|
|
|
|
|
|
// If you're not careful, you'll think GGYES is a legal
|
|
// Tibetan tsheg bar and parse it as {G}{G+YE}{S}. But it's
|
|
// Sanskrit, really, because GA doesn't take a GA prefix.
|
|
// This doesn't occur in ACIP input files that I've seen, but
|
|
// GGYI (S1000I.INC) and GGYUR (S5275MC4.ACT) do occur.
|
|
tstHelper("GGYES", "{G}{G}{YE}{S}",
|
|
new String[] { "{G}{G}{YE}{S}", "{G}{G+YE}{S}", "{G+G}{YE}{S}" },
|
|
new String[] { },
|
|
"{G+G}{YE}{S}");
|
|
|
|
tstHelper("DRUG", "{D}{RU}{G}",
|
|
new String[] { "{D}{RU}{G}", "{D+RU}{G}" },
|
|
new String[] { "{D+RU}{G}" },
|
|
"{D+RU}{G}");
|
|
|
|
|
|
tstHelper("d+H+d+HA", "{d+}{H+}{d+}{HA}",
|
|
new String[] { "{d+H+d+HA}" },
|
|
new String[] { "{d+H+d+HA}" });
|
|
|
|
tstHelper("Gd+H+d+HA");
|
|
|
|
tstHelper("AUTPA", "{AU}{T}{PA}",
|
|
new String[] { "{AU}{T}{PA}", "{AU}{T+PA}" },
|
|
new String[] { },
|
|
"{AU}{T+PA}");
|
|
tstHelper("PADMA", "{PA}{D}{MA}",
|
|
null,
|
|
null);
|
|
tstHelper("PADMA", "{PA}{D}{MA}",
|
|
new String[] { "{PA}{D}{MA}", "{PA}{D+MA}" },
|
|
new String[] { },
|
|
"{PA}{D+MA}");
|
|
tstHelper("PADMDM", "{PA}{D}{M}{D}{M}",
|
|
null,
|
|
new String[] { },
|
|
"{PA}{D+M}{D+M}");
|
|
tstHelper("GRVA'I", "{G}{R}{VA}{'I}",
|
|
new String[] { "{G}{R+VA}{'I}", "{G+R+VA}{'I}" },
|
|
new String[] { "{G+R+VA}{'I}" });
|
|
tstHelper("G-RVA'I", "{G-}{R}{VA}{'I}",
|
|
new String[] { "{G}{R+VA}{'I}" },
|
|
new String[] { },
|
|
"{G}{R+VA}{'I}");
|
|
tstHelper("RVA", "{R}{VA}",
|
|
new String[] { "{R+VA}" },
|
|
new String[] { "{R+VA}" });
|
|
tstHelper("K+0", "{K+}{0}", new String[] { }, new String[] { });
|
|
tstHelper("0+K", "{0-}{+-}{K}", new String[] { }, new String[] { });
|
|
tstHelper("0+0", "{0-}{+-}{0}", new String[] { }, new String[] { });
|
|
|
|
// DLC add tests for BRTAN, BLTA, BLAG, BRAG, B-LAG, B-RAG
|
|
|
|
// MARK for searching
|
|
tstHelper("0", "{0}", new String[] { "{0}" },
|
|
new String[] { "{0}" });
|
|
tstHelper("0123", "{0-}{1-}{2-}{3}", new String[] { "{0}{1}{2}{3}" },
|
|
new String[] { "{0}{1}{2}{3}" });
|
|
tstHelper("0-123", "{0-}{-}{1-}{2-}{3}", new String[] { "{0}{1}{2}{3}" },
|
|
new String[] { "{0}{1}{2}{3}" });
|
|
tstHelper("0123KA", "{0-}{1-}{2-}{3-}{KA}", new String[] { "{0}{1}{2}{3}{KA}" },
|
|
new String[] { });
|
|
tstHelper("G0123KA", "{G}{0-}{1-}{2-}{3-}{KA}", new String[] { "{G}{0}{1}{2}{3}{KA}" },
|
|
new String[] { });
|
|
tstHelper("BHA");
|
|
tstHelper("BHE");
|
|
tstHelper("BH'I");
|
|
tstHelper("BH'Im");
|
|
tstHelper("BH'Im:"); // DLC FIXME: make TibetanMachineWeb see EWTS {H} as an adornment.
|
|
tstHelper("D-VA");
|
|
tstHelper("DVA");
|
|
tstHelper("SRAS", "{S}{RA}{S}",
|
|
new String[] { "{S}{RA}{S}", "{S+RA}{S}" },
|
|
new String[] { "{S+RA}{S}" });
|
|
tstHelper("SARS", "{SA}{R}{S}",
|
|
new String[] { "{SA}{R}{S}", "{SA}{R+S}" },
|
|
new String[] { "{SA}{R}{S}" });
|
|
tstHelper("SARAS", "{SA}{RA}{S}",
|
|
new String[] { "{SA}{RA}{S}" },
|
|
new String[] { "{SA}{RA}{S}" });
|
|
|
|
tstHelper("SHLO",
|
|
"{SH}{LO}",
|
|
new String[] { "{SH}{LO}", "{SH+LO}" },
|
|
new String[] { "{SH+LO}" });
|
|
tstHelper("ZLUM", "{Z}{LU}{M}", new String[] { "{Z}{LU}{M}", "{Z+LU}{M}" }, new String[] { "{Z+LU}{M}" });
|
|
tstHelper("K'EE", "{K'EE}");
|
|
tstHelper("K'O", "{K'O}");
|
|
tstHelper("K'OO", "{K'OO}");
|
|
tstHelper("K'II", "{K'I}{I}");
|
|
tstHelper("K'i", "{K'i}");
|
|
tstHelper("K'A", "{K'A}");
|
|
tstHelper("B+DDZ", "{B+}{D}{DZ}",
|
|
new String[] { "{B+D}{DZ}",
|
|
"{B+D+DZ}" }); // we're conservative.
|
|
// A heuristic is to
|
|
// say that B+DDZ must
|
|
// be {B+D}{DZ}
|
|
// because the
|
|
// keyboardist surely
|
|
// would've typed two
|
|
// plusses if {B+D+DZ}
|
|
// were desired, given
|
|
// that we know the
|
|
// keyboardist was
|
|
// aware of the plus
|
|
// operator.
|
|
|
|
tstHelper("BRTN--GA",
|
|
"{B}{R}{T}{N-}{-}{GA}",
|
|
new String[] {
|
|
"{B}{R}{T}{N}{GA}",
|
|
"{B}{R}{T+N}{GA}",
|
|
"{B}{R+T}{N}{GA}",
|
|
"{B+R}{T}{N}{GA}",
|
|
"{B+R}{T+N}{GA}",
|
|
});
|
|
tstHelper("BR-TN"); // DLC: no legal parses, and 2 decent ones, eh?
|
|
tstHelper("BRTN",
|
|
"{B}{R}{T}{N}",
|
|
new String[] {
|
|
"{B}{R}{T}{N}",
|
|
"{B}{R}{T+N}",
|
|
"{B}{R+T}{N}",
|
|
"{B+R}{T}{N}",
|
|
"{B+R}{T+N}",
|
|
},
|
|
new String[] {
|
|
"{B}{R+T}{N}" // prefix-root-suffix
|
|
});
|
|
tstHelper("BRTN-BRTN",
|
|
"{B}{R}{T}{N-}{B}{R}{T}{N}",
|
|
new String[] {
|
|
"{B}{R}{T}{N}{B}{R}{T}{N}",
|
|
"{B}{R}{T}{N}{B}{R}{T+N}",
|
|
"{B}{R}{T}{N}{B}{R+T}{N}",
|
|
"{B}{R}{T}{N}{B+R}{T}{N}",
|
|
"{B}{R}{T}{N}{B+R}{T+N}",
|
|
"{B}{R}{T+N}{B}{R}{T}{N}",
|
|
"{B}{R}{T+N}{B}{R}{T+N}",
|
|
"{B}{R}{T+N}{B}{R+T}{N}",
|
|
"{B}{R}{T+N}{B+R}{T}{N}",
|
|
"{B}{R}{T+N}{B+R}{T+N}",
|
|
"{B}{R+T}{N}{B}{R}{T}{N}",
|
|
"{B}{R+T}{N}{B}{R}{T+N}",
|
|
"{B}{R+T}{N}{B}{R+T}{N}",
|
|
"{B}{R+T}{N}{B+R}{T}{N}",
|
|
"{B}{R+T}{N}{B+R}{T+N}",
|
|
"{B+R}{T}{N}{B}{R}{T}{N}",
|
|
"{B+R}{T}{N}{B}{R}{T+N}",
|
|
"{B+R}{T}{N}{B}{R+T}{N}",
|
|
"{B+R}{T}{N}{B+R}{T}{N}",
|
|
"{B+R}{T}{N}{B+R}{T+N}",
|
|
"{B+R}{T+N}{B}{R}{T}{N}",
|
|
"{B+R}{T+N}{B}{R}{T+N}",
|
|
"{B+R}{T+N}{B}{R+T}{N}",
|
|
"{B+R}{T+N}{B+R}{T}{N}",
|
|
"{B+R}{T+N}{B+R}{T+N}",
|
|
}); // has 25 parses
|
|
tstHelper("B+R-T-N-B-R-T+N",
|
|
new String[] { "{B+R}{T}{N}{B}{R}{T+N}" }); // has 1 parse
|
|
tstHelper("B+G+K", "{B+}{G+}{K}", new String[] { }); // no parses.
|
|
tstHelper("G-YA",
|
|
new String[] { "{G}{YA}" }); // has 1 parse
|
|
tstHelper("G+YA",
|
|
new String[] { "{G+YA}" }); // has 1 parse
|
|
tstHelper("G+YAm:",
|
|
new String[] { "{G+YAm:}" }); // has 1 parse
|
|
tstHelper("BRTN-BLTA", "{B}{R}{T}{N-}{B}{L}{TA}",
|
|
new String[] {
|
|
"{B}{R}{T}{N}{B}{L}{TA}",
|
|
"{B}{R}{T}{N}{B}{L+TA}",
|
|
"{B}{R}{T}{N}{B+L}{TA}",
|
|
"{B}{R}{T+N}{B}{L}{TA}",
|
|
"{B}{R}{T+N}{B}{L+TA}",
|
|
"{B}{R}{T+N}{B+L}{TA}",
|
|
"{B}{R+T}{N}{B}{L}{TA}",
|
|
"{B}{R+T}{N}{B}{L+TA}",
|
|
"{B}{R+T}{N}{B+L}{TA}",
|
|
"{B+R}{T}{N}{B}{L}{TA}",
|
|
"{B+R}{T}{N}{B}{L+TA}",
|
|
"{B+R}{T}{N}{B+L}{TA}",
|
|
"{B+R}{T+N}{B}{L}{TA}",
|
|
"{B+R}{T+N}{B}{L+TA}",
|
|
"{B+R}{T+N}{B+L}{TA}",
|
|
}); // has 15 parses
|
|
tstHelper("BSABS", new String[] { "{B}{SA}{B}{S}" });
|
|
tstHelper("ZUNGS");
|
|
tstHelper("BRTIB",
|
|
"{B}{R}{TI}{B}",
|
|
new String[] {
|
|
"{B}{R}{TI}{B}",
|
|
"{B}{R+TI}{B}",
|
|
"{B+R}{TI}{B}",
|
|
});
|
|
tstHelper("PRiTZTSVA",
|
|
"{P}{Ri}{TZ}{TS}{VA}",
|
|
new String[] {
|
|
"{P}{Ri}{TZ}{TS+VA}",
|
|
"{P}{Ri}{TZ+TS+VA}",
|
|
"{P+Ri}{TZ}{TS+VA}",
|
|
"{P+Ri}{TZ+TS+VA}"
|
|
});
|
|
tstHelper("SPYOMS", "{S}{P}{YO}{M}{S}",
|
|
new String[] {
|
|
"{S}{P}{YO}{M}{S}",
|
|
"{S}{P}{YO}{M+S}",
|
|
"{S}{P+YO}{M}{S}",
|
|
"{S}{P+YO}{M+S}",
|
|
"{S+P}{YO}{M}{S}",
|
|
"{S+P}{YO}{M+S}",
|
|
"{S+P+YO}{M}{S}",
|
|
"{S+P+YO}{M+S}",
|
|
});
|
|
tstHelper(":'AO", "[(: . -), (' . ), (A . O)]");
|
|
tstHelper("AA:", "[(A . A:)]", new String[] { "{AA:}" });
|
|
tstHelper("KE:", "[(K . E:)]");
|
|
tstHelper("K:", "[(K . ), (: . )]",
|
|
new String[] { /* No parses exist. "K:" is illegal. */ });
|
|
tstHelper("'AO", "[(' . ), (A . O)]");
|
|
tstHelper("'AOM", "[(' . ), (A . O), (M . )]");
|
|
// DLC CHECK: S6814M6.ACT for BA'I and 'AO
|
|
|
|
tstHelper("BTZVA", "[(B . ), (TZ . ), (V . A)]");
|
|
|
|
tstHelper("G--YA", new String[] { "{G}{YA}" });
|
|
tstHelper("-", "[( . -)]");
|
|
tstHelper("+", "[(+ . )]");
|
|
tstHelper("G-Y", "[(G . -), (Y . )]");
|
|
tstHelper("GA-Y", "[(G . A), ( . -), (Y . )]");
|
|
|
|
tstHelper("SKU'I", "[(S . ), (K . U), (' . I)]");
|
|
tstHelper("'BU", "[(' . ), (B . U)]");
|
|
tstHelper("BSKYANGS", "[(B . ), (S . ), (K . ), (Y . A), (NG . ), (S . )]");
|
|
tstHelper("SKYABS", "[(S . ), (K . ), (Y . A), (B . ), (S . )]");
|
|
tstHelper("SKYAB", "[(S . ), (K . ), (Y . A), (B . )]");
|
|
|
|
tstHelper("NA+YADAA", "[(N . +), (Y . A), (D . ), (A . A)]");
|
|
tstHelper("AA-KshA", "[(A . A), ( . -), (Ksh . A)]");
|
|
|
|
tstHelper("AAS", "[(A . A), (S . )]");
|
|
tstHelper("AA-ttA", "[(A . A), ( . -), (t . ), (t . A)]");
|
|
tstHelper("'AD", "[(' . A), (D . )]");
|
|
tstHelper("AE", "[(A . E)]");
|
|
tstHelper("AEE", "[(A . EE)]");
|
|
tstHelper("AER", "[(A . E), (R . )]");
|
|
tstHelper("AG");
|
|
|
|
|
|
tstHelper("H'Um:", "[(H . 'Um:)]");
|
|
tstHelper("H'U", "[(H . 'U)]");
|
|
tstHelper("Hi", "[(H . i)]");
|
|
tstHelper("Him", "[(H . im)]");
|
|
tstHelper("Him:", "[(H . im:)]");
|
|
tstHelper("H'Um", "[(H . 'Um)]");
|
|
|
|
tstHelper("AA", "[(A . A)]");
|
|
tstHelper("AAm", "[(A . Am)]");
|
|
tstHelper("AAm:", "[(A . Am:)]");
|
|
tstHelper("A'im:", "[(A . 'im:)]");
|
|
tstHelper("DEAI", "[(D . E), (A . I)]");
|
|
tstHelper("G'A'I", "[(G . 'A), (' . I)]");
|
|
tstHelper("G'I'I", "[(G . 'I), (' . I)]");
|
|
tstHelper("G'Im:'I", "[(G . 'Im:), (' . I)]");
|
|
tstHelper("G'Im:'ANG'AM'I", "[(G . 'Im:), (' . A), (NG . 'A), (M . 'I)]"); // DLC FIXME: 'ANG'A is what? 'ANG-'A or 'A-NG'A?
|
|
|
|
tstHelper("BA'AM", "[(B . A), (' . A), (M . )]");
|
|
tstHelper("B'AM", "[(B . 'A), (M . )]");
|
|
tstHelper("'AM'E", "[(' . A), (M . 'E)]");
|
|
tstHelper("BA'AM'E", "[(B . A), (' . A), (M . 'E)]");
|
|
tstHelper("BA'AM-'E", "[(B . A), (' . A), (M . -), (' . E)]");
|
|
|
|
tstHelper("TAA", "[(T . ), (A . A)]");
|
|
tstHelper("DAA", "[(D . ), (A . A)]");
|
|
tstHelper("DAAm", "[(D . ), (A . Am)]");
|
|
tstHelper("DAAm:", "[(D . ), (A . Am:)]");
|
|
tstHelper("DA'im:", "[(D . A), (' . im:)]");
|
|
|
|
tstHelper("NA+YA", "[(N . +), (Y . A)]");
|
|
|
|
tstHelper("'A", "[(' . A)]");
|
|
tstHelper("'Am", "[(' . Am)]");
|
|
tstHelper("'Am:", "[(' . Am:)]");
|
|
tstHelper("''im:", "[(' . 'im:)]");
|
|
tstHelper("D-'A", "[(D . -), (' . A)]");
|
|
tstHelper("D-'Am", "[(D . -), (' . Am)]");
|
|
tstHelper("D-'Am:", "[(D . -), (' . Am:)]");
|
|
|
|
// AMBIGUOUS really, but grepping for "[GDBM']'[AIEUO]" makes
|
|
// me think it's [(D . 'A)], which you'd hope it would be
|
|
// since A'A is an example in the ACIP docs.
|
|
//
|
|
// tstHelper("D'A", "[(D . 'A)]");
|
|
// tstHelper("D'A", "[(D . ), (' . A)]");
|
|
tstHelper("D'A", "[(D . 'A)]");
|
|
tstHelper("D'Am", "[(D . 'Am)]");
|
|
tstHelper("D'Am:", "[(D . 'Am:)]");
|
|
|
|
tstHelper("BA'I", "[(B . A), (' . I)]");
|
|
tstHelper("DAVA", "[(D . A), (V . A)]");
|
|
tstHelper("D-VA", "[(D . -), (V . A)]");
|
|
tstHelper("DVA", "[(D . ), (V . A)]");
|
|
tstHelper("BA'AM", "[(B . A), (' . A), (M . )]");
|
|
|
|
|
|
|
|
tstHelper("AAA");
|
|
|
|
tstHelper("A+YA", "[(A . +), (Y . A)]"); // achen over ya
|
|
|
|
tstHelper("D''im:", "[(D . ), (' . 'im:)]");
|
|
|
|
|
|
|
|
tstHelper("ssh");
|
|
tstHelper("ssshsstqm");
|
|
tstHelper("sh");
|
|
tstHelper("D----Z");
|
|
tstHelper("D++++Z");
|
|
tstHelper("shA");
|
|
tstHelper("SHA", "[(SH . A)]");
|
|
tstHelper("TSHA", "[(TS . ), (H . A)]");
|
|
tstHelper("TS-HA", "[(TS . -), (H . A)]");
|
|
tstHelper("TSE-HA", "[(TS . E), ( . -), (H . A)]");
|
|
tstHelper("TSEHA", "[(TS . E), (H . A)]");
|
|
tstHelper("s");
|
|
tstHelper("T+ZA", "[(T . +), (Z . A)]");
|
|
tstHelper("shTZNGN", "[(sh . ), (TZ . ), (NG . ), (N . )]");
|
|
tstHelper("shTZNAGN", "[(sh . ), (TZ . ), (N . A), (G . ), (N . )]");
|
|
tstHelper("KAm", "[(K . Am)]");
|
|
tstHelper("shT-ZNAGN", "[(sh . ), (T . -), (Z . ), (N . A), (G . ), (N . )]");
|
|
tstHelper("shT+ZNAGN", "[(sh . ), (T . +), (Z . ), (N . A), (G . ), (N . )]");
|
|
|
|
tstHelper("TYA-''I"); // from KD0095M.ACT
|
|
tstHelper("A-DZU");
|
|
tstHelper("MNYA-DZU");
|
|
|
|
System.out.println("\n\n\ntsting a bunch of tsheg bars I yanked from the kangyur:\n\n");
|
|
tstHelper("'");
|
|
tstHelper("A");
|
|
tstHelper("'A");
|
|
tstHelper("A'");
|
|
tstHelper("AA");
|
|
tstHelper("A'A");
|
|
tstHelper("AAD");
|
|
tstHelper("AAG");
|
|
tstHelper("AA'I");
|
|
tstHelper("AA-KshA");
|
|
tstHelper("AA-Ksh'A");
|
|
tstHelper("AA-KshI");
|
|
tstHelper("AAm");
|
|
tstHelper("AAN");
|
|
tstHelper("AANG");
|
|
tstHelper("AANG-GA'I");
|
|
tstHelper("AAR");
|
|
tstHelper("AARDZA");
|
|
tstHelper("AARDZU");
|
|
tstHelper("AARTHA");
|
|
tstHelper("AARYA");
|
|
tstHelper("A'ARYA");
|
|
tstHelper("A'A-RYA");
|
|
tstHelper("AAS");
|
|
tstHelper("AA-ttA");
|
|
tstHelper("'AD");
|
|
tstHelper("AE");
|
|
tstHelper("AEE");
|
|
tstHelper("AER");
|
|
tstHelper("AG");
|
|
tstHelper("Ai");
|
|
tstHelper("AI");
|
|
tstHelper("'A'I");
|
|
tstHelper("A'I");
|
|
tstHelper("AINDRA");
|
|
tstHelper("AIN-DRA");
|
|
tstHelper("AI-ttI");
|
|
tstHelper("Am");
|
|
tstHelper("'AM");
|
|
tstHelper("ANDA");
|
|
tstHelper("ANG");
|
|
tstHelper("'ANG");
|
|
tstHelper("'ANGS");
|
|
tstHelper("AO");
|
|
tstHelper("AOm");
|
|
tstHelper("AOM");
|
|
tstHelper("AOO");
|
|
tstHelper("A'RYA");
|
|
tstHelper("AshtA");
|
|
tstHelper("AU");
|
|
tstHelper("A'U");
|
|
tstHelper("AUD");
|
|
tstHelper("AUG");
|
|
tstHelper("AU-KKE");
|
|
tstHelper("AUshnI");
|
|
tstHelper("AU-TAP");
|
|
tstHelper("AUTAPA");
|
|
tstHelper("AUT-KA");
|
|
tstHelper("AU-TKU");
|
|
tstHelper("AUTP");
|
|
tstHelper("AUTPA");
|
|
tstHelper("AU-TPA");
|
|
tstHelper("AUT-PA");
|
|
tstHelper("AUTPAL");
|
|
tstHelper("AUT-PAL");
|
|
tstHelper("AUTPALA");
|
|
tstHelper("'B");
|
|
tstHelper("Ba");
|
|
tstHelper("BA");
|
|
tstHelper("'BA");
|
|
tstHelper("'BA'");
|
|
tstHelper("B'A");
|
|
tstHelper("BA'");
|
|
tstHelper("BA'AM");
|
|
tstHelper("BA'ANG");
|
|
tstHelper("BAB");
|
|
tstHelper("'BAB");
|
|
tstHelper("BABS");
|
|
tstHelper("'BABS");
|
|
tstHelper("BAD");
|
|
tstHelper("'BAD");
|
|
tstHelper("BADG");
|
|
tstHelper("BADZRA");
|
|
tstHelper("BADZRA'I");
|
|
tstHelper("BADZRAS");
|
|
tstHelper("BADZRO");
|
|
tstHelper("BAG");
|
|
tstHelper("BAGS");
|
|
tstHelper("'BAGS");
|
|
tstHelper("'BA'I");
|
|
tstHelper("B'AI");
|
|
tstHelper("B'A'I");
|
|
tstHelper("BA'I");
|
|
tstHelper("BA'I'O");
|
|
tstHelper("BA'ISKYE");
|
|
tstHelper("BAKKU");
|
|
tstHelper("BAL");
|
|
tstHelper("'BAL");
|
|
tstHelper("BAm");
|
|
tstHelper("BAM");
|
|
tstHelper("'BAM");
|
|
tstHelper("BAN");
|
|
tstHelper("BAndE");
|
|
tstHelper("BANDE");
|
|
tstHelper("BANDHE");
|
|
tstHelper("BAndI");
|
|
tstHelper("BANDI");
|
|
tstHelper("BANDRA");
|
|
tstHelper("BANDRE");
|
|
tstHelper("BANG");
|
|
tstHelper("'BANG");
|
|
tstHelper("B'ANG");
|
|
tstHelper("BANGS");
|
|
tstHelper("'BANGS");
|
|
tstHelper("BA'O");
|
|
tstHelper("BA'OBLO");
|
|
tstHelper("BAOM");
|
|
tstHelper("BAR");
|
|
tstHelper("'BAR");
|
|
tstHelper("BARMA");
|
|
tstHelper("BARnA'I");
|
|
tstHelper("BARSHA");
|
|
tstHelper("BAR-SHI");
|
|
tstHelper("BAS");
|
|
tstHelper("BASD");
|
|
tstHelper("BASM");
|
|
tstHelper("BATA+SA'I");
|
|
tstHelper("BAUNG");
|
|
tstHelper("BBANG");
|
|
tstHelper("BBAS");
|
|
tstHelper("BBLAN");
|
|
tstHelper("BBYID");
|
|
tstHelper("BCA");
|
|
tstHelper("BCA'");
|
|
tstHelper("BCAB");
|
|
tstHelper("BCABS");
|
|
tstHelper("BCAD");
|
|
tstHelper("BCAG");
|
|
tstHelper("BCAGS");
|
|
tstHelper("BCAL");
|
|
tstHelper("BCAN");
|
|
tstHelper("BCANG");
|
|
tstHelper("BCANGS");
|
|
tstHelper("BCA'O");
|
|
tstHelper("BCAR");
|
|
tstHelper("BCAS");
|
|
tstHelper("BCCO");
|
|
tstHelper("BCED");
|
|
tstHelper("BCER");
|
|
tstHelper("BCES");
|
|
tstHelper("BCHAD");
|
|
tstHelper("BCHANG");
|
|
tstHelper("BCHES");
|
|
tstHelper("BCHI");
|
|
tstHelper("BCHIS");
|
|
tstHelper("BCHOD");
|
|
tstHelper("BCI");
|
|
tstHelper("BCIBS");
|
|
tstHelper("BCIL");
|
|
tstHelper("BCING");
|
|
tstHelper("BCINGS");
|
|
tstHelper("BCIR");
|
|
tstHelper("BCIS");
|
|
tstHelper("BCO");
|
|
tstHelper("BCOD");
|
|
tstHelper("BCOL");
|
|
tstHelper("BCOM");
|
|
tstHelper("BCOMN");
|
|
tstHelper("BCON");
|
|
tstHelper("BCONGS");
|
|
tstHelper("BCOS");
|
|
tstHelper("BCU");
|
|
tstHelper("BCU'AM");
|
|
tstHelper("BCU'ANG");
|
|
tstHelper("BCUD");
|
|
tstHelper("BCUG");
|
|
tstHelper("BCUGS");
|
|
tstHelper("BCU'I");
|
|
tstHelper("BCUM");
|
|
tstHelper("BCUN");
|
|
tstHelper("BCUNG");
|
|
tstHelper("BCU'O");
|
|
tstHelper("BCUR");
|
|
tstHelper("BCUS");
|
|
tstHelper("BCVA");
|
|
tstHelper("BCVO");
|
|
tstHelper("BCWA");
|
|
tstHelper("BCWO");
|
|
tstHelper("BDA");
|
|
tstHelper("BDA'");
|
|
tstHelper("BDAG");
|
|
tstHelper("BDAGS");
|
|
tstHelper("BDAL");
|
|
tstHelper("BDAM");
|
|
tstHelper("BDAMS");
|
|
tstHelper("BDAN");
|
|
tstHelper("BDA'O");
|
|
tstHelper("BDAR");
|
|
tstHelper("BDAS");
|
|
tstHelper("BDE");
|
|
tstHelper("BDE'AM");
|
|
tstHelper("BDEB");
|
|
tstHelper("BDEGS");
|
|
tstHelper("BDE'I");
|
|
tstHelper("BDEN");
|
|
tstHelper("BDE'O");
|
|
tstHelper("BDER");
|
|
tstHelper("BDES");
|
|
tstHelper("BDO");
|
|
tstHelper("BDOG");
|
|
tstHelper("BDO'I");
|
|
tstHelper("BDON");
|
|
tstHelper("BDRAL");
|
|
tstHelper("BDROL");
|
|
tstHelper("BDRUG");
|
|
tstHelper("BDU");
|
|
tstHelper("BDUD");
|
|
tstHelper("BDUG");
|
|
tstHelper("BDUGS");
|
|
tstHelper("BDUN");
|
|
tstHelper("BDUNG");
|
|
tstHelper("BDUNGS");
|
|
tstHelper("BDUS");
|
|
tstHelper("BDZAG");
|
|
tstHelper("BDZAM");
|
|
tstHelper("BDZES");
|
|
tstHelper("Be");
|
|
tstHelper("BE");
|
|
tstHelper("'BEB");
|
|
tstHelper("'BEBS");
|
|
tstHelper("BED");
|
|
tstHelper("BEE");
|
|
tstHelper("BEE-d'U");
|
|
tstHelper("BEED'U");
|
|
tstHelper("BEE-d'U-RYA");
|
|
tstHelper("BEEd'URYA");
|
|
tstHelper("BEED'URYA");
|
|
tstHelper("BEEd'URYA'I");
|
|
tstHelper("BEED'URYA'I");
|
|
tstHelper("BEEK'U");
|
|
tstHelper("BEGS");
|
|
tstHelper("BE'I");
|
|
tstHelper("'BEL");
|
|
tstHelper("BEM");
|
|
tstHelper("BEMS");
|
|
tstHelper("'BEN");
|
|
tstHelper("BENDE");
|
|
tstHelper("BENDHA");
|
|
tstHelper("BER");
|
|
tstHelper("BE'U");
|
|
tstHelper("BE'US");
|
|
tstHelper("BGA");
|
|
tstHelper("BGAD");
|
|
tstHelper("BGAG");
|
|
tstHelper("BGAGS");
|
|
tstHelper("BGAM");
|
|
tstHelper("BGAS");
|
|
tstHelper("BGED");
|
|
tstHelper("BGEGS");
|
|
tstHelper("BGO");
|
|
tstHelper("BGOD");
|
|
tstHelper("BGOMS");
|
|
tstHelper("BGONG");
|
|
tstHelper("BGO'O");
|
|
tstHelper("BGOR");
|
|
tstHelper("BGOS");
|
|
tstHelper("BGRA");
|
|
tstHelper("BGRAD");
|
|
tstHelper("BGRANG");
|
|
tstHelper("BGRANGS");
|
|
tstHelper("BGRES");
|
|
tstHelper("BGRO");
|
|
tstHelper("BGROD");
|
|
tstHelper("BGROGS");
|
|
tstHelper("BGROL");
|
|
tstHelper("BGRONG");
|
|
tstHelper("BGRONGS");
|
|
tstHelper("BGROS");
|
|
tstHelper("BGSAS");
|
|
tstHelper("BGU");
|
|
tstHelper("BGYA");
|
|
tstHelper("BGYAD");
|
|
tstHelper("BGYA'O");
|
|
tstHelper("BGYAS");
|
|
tstHelper("BGYED");
|
|
tstHelper("BGYEN");
|
|
tstHelper("BGYI");
|
|
tstHelper("BGYI'AM");
|
|
tstHelper("BGYI'ANG");
|
|
tstHelper("BGYIB");
|
|
tstHelper("BGYID");
|
|
tstHelper("BGYI'I");
|
|
tstHelper("BGYIN");
|
|
tstHelper("BGYING");
|
|
tstHelper("BGYINGS");
|
|
tstHelper("BGYI'O");
|
|
tstHelper("BGYIR");
|
|
tstHelper("BGYIS");
|
|
tstHelper("BGYUR");
|
|
tstHelper("BHA");
|
|
tstHelper("BH'A");
|
|
tstHelper("BHADRA");
|
|
tstHelper("BHADRE");
|
|
tstHelper("BHAN");
|
|
tstHelper("BHANG");
|
|
tstHelper("BHAR");
|
|
tstHelper("BHE");
|
|
tstHelper("BHEN");
|
|
tstHelper("BHI");
|
|
tstHelper("BHIN");
|
|
tstHelper("BHING");
|
|
tstHelper("BHO");
|
|
tstHelper("BHOD");
|
|
tstHelper("BHOtA'I");
|
|
tstHelper("BHRiNG");
|
|
tstHelper("BHRING");
|
|
tstHelper("BHU");
|
|
tstHelper("BH'U");
|
|
tstHelper("BHYA-NTA");
|
|
tstHelper("BHYU");
|
|
tstHelper("BI");
|
|
tstHelper("B'I");
|
|
tstHelper("BID");
|
|
tstHelper("BIDYA");
|
|
tstHelper("BIDY'A");
|
|
tstHelper("'BIGS");
|
|
tstHelper("B'I'I");
|
|
tstHelper("BI'I");
|
|
tstHelper("BIL");
|
|
tstHelper("BIM");
|
|
tstHelper("BI-MBA");
|
|
tstHelper("BIM-PA");
|
|
tstHelper("BIM-PA");
|
|
tstHelper("BIM-PA'I");
|
|
tstHelper("BIN");
|
|
tstHelper("BINGSHA");
|
|
tstHelper("BIR");
|
|
tstHelper("B'IR");
|
|
tstHelper("BIR'A");
|
|
tstHelper("BIS");
|
|
tstHelper("BI-shtE");
|
|
tstHelper("BI-ttI");
|
|
tstHelper("BKA'");
|
|
tstHelper("BKAB");
|
|
tstHelper("BKAD");
|
|
tstHelper("BKAG");
|
|
tstHelper("BKA'I");
|
|
tstHelper("BKAL");
|
|
tstHelper("BKALG");
|
|
tstHelper("BKANG");
|
|
tstHelper("BKANGS");
|
|
tstHelper("BKA'O");
|
|
tstHelper("BKAR");
|
|
tstHelper("BKAS");
|
|
tstHelper("BKED");
|
|
tstHelper("BKHYU");
|
|
tstHelper("BKLAG");
|
|
tstHelper("BKLAGS");
|
|
tstHelper("BKLOG");
|
|
tstHelper("BKLUBS");
|
|
tstHelper("BKOD");
|
|
tstHelper("BKOGS");
|
|
tstHelper("BKOL");
|
|
tstHelper("BKONG");
|
|
tstHelper("BKRA");
|
|
tstHelper("BKRA'AM");
|
|
tstHelper("BKRABS");
|
|
tstHelper("BKRAL");
|
|
tstHelper("BKRAM");
|
|
tstHelper("BKRE");
|
|
tstHelper("BKREN");
|
|
tstHelper("BKRENG");
|
|
tstHelper("BKRES");
|
|
tstHelper("BKRI");
|
|
tstHelper("BKRI'I");
|
|
tstHelper("BKRI'O");
|
|
tstHelper("BKRIR");
|
|
tstHelper("BKRIS");
|
|
tstHelper("BKROL");
|
|
tstHelper("BKRONGS");
|
|
tstHelper("BKRU");
|
|
tstHelper("BKRU'O");
|
|
tstHelper("BKRUR");
|
|
tstHelper("BKRUS");
|
|
tstHelper("BKU");
|
|
tstHelper("BKUG");
|
|
tstHelper("BKUM");
|
|
tstHelper("BKUR");
|
|
tstHelper("BKUS");
|
|
tstHelper("BKYE");
|
|
tstHelper("BKYED");
|
|
tstHelper("BKYE'O");
|
|
tstHelper("BKYI");
|
|
tstHelper("BKYID");
|
|
tstHelper("BKYON");
|
|
tstHelper("BLA");
|
|
tstHelper("BLAB");
|
|
tstHelper("BLAD");
|
|
tstHelper("BLAG");
|
|
tstHelper("BLAGS");
|
|
tstHelper("BLA'I");
|
|
tstHelper("BLAM");
|
|
tstHelper("BLAN");
|
|
tstHelper("BLANG");
|
|
tstHelper("BLANGS");
|
|
tstHelper("BLA'O");
|
|
tstHelper("BLAS");
|
|
tstHelper("BLCAG");
|
|
tstHelper("BLDAG");
|
|
tstHelper("BLDAGS");
|
|
tstHelper("BLINGS");
|
|
tstHelper("BLNGA");
|
|
tstHelper("BLO");
|
|
tstHelper("BLO'ANG");
|
|
tstHelper("BLO'I");
|
|
tstHelper("BLON");
|
|
tstHelper("BLONG");
|
|
tstHelper("BLO'O");
|
|
tstHelper("BLOR");
|
|
tstHelper("BLOS");
|
|
tstHelper("BLTA");
|
|
tstHelper("BLTA'AM");
|
|
tstHelper("BLTAB");
|
|
tstHelper("BLTAM");
|
|
tstHelper("BLTAMS");
|
|
tstHelper("BLTAN");
|
|
tstHelper("BLTA'O");
|
|
tstHelper("BLTAR");
|
|
tstHelper("BLTAS");
|
|
tstHelper("BLTOS");
|
|
tstHelper("BLTUNG");
|
|
tstHelper("BLUD");
|
|
tstHelper("BLUGS");
|
|
tstHelper("BLUN");
|
|
tstHelper("BLUNG");
|
|
tstHelper("BLUS");
|
|
tstHelper("BNA");
|
|
tstHelper("BNGAN");
|
|
tstHelper("BNGAS");
|
|
tstHelper("BNGO'O");
|
|
tstHelper("BNYAMS");
|
|
tstHelper("BNYEN");
|
|
tstHelper("BNYID");
|
|
tstHelper("BO");
|
|
tstHelper("'BO");
|
|
tstHelper("BO");
|
|
tstHelper("BO'AM");
|
|
tstHelper("BO'ANG");
|
|
tstHelper("BOBS");
|
|
tstHelper("BOCM");
|
|
tstHelper("BOD");
|
|
tstHelper("'BOD");
|
|
tstHelper("BODE");
|
|
tstHelper("BODHI");
|
|
tstHelper("BOG");
|
|
tstHelper("'BOG");
|
|
tstHelper("'BOGS");
|
|
tstHelper("BO'I");
|
|
tstHelper("BOL");
|
|
tstHelper("BOM");
|
|
tstHelper("BON");
|
|
tstHelper("BONG");
|
|
tstHelper("'BONG");
|
|
tstHelper("BO'O");
|
|
tstHelper("BOR");
|
|
tstHelper("'BOR");
|
|
tstHelper("BOS");
|
|
tstHelper("BP");
|
|
tstHelper("BPA");
|
|
tstHelper("BRA");
|
|
tstHelper("'BRA");
|
|
tstHelper("BRAD");
|
|
tstHelper("'BRAD");
|
|
tstHelper("BRAG");
|
|
tstHelper("BRAGS");
|
|
tstHelper("BRAL");
|
|
tstHelper("'BRAL");
|
|
tstHelper("BRAM");
|
|
tstHelper("'BRAM");
|
|
tstHelper("BRAN");
|
|
tstHelper("BRANG");
|
|
tstHelper("'BRANG");
|
|
tstHelper("'BRANGS");
|
|
tstHelper("'BRAS");
|
|
tstHelper("BRDA");
|
|
tstHelper("BRDAB");
|
|
tstHelper("BRDABS");
|
|
tstHelper("BRDAG");
|
|
tstHelper("BRDA'I");
|
|
tstHelper("BRDAL");
|
|
tstHelper("BRDAR");
|
|
tstHelper("BRDAS");
|
|
tstHelper("BRDEG");
|
|
tstHelper("BRDEGS");
|
|
tstHelper("BRDOD");
|
|
tstHelper("BRDOL");
|
|
tstHelper("BRDOS");
|
|
tstHelper("BRDUB");
|
|
tstHelper("BRDUBS");
|
|
tstHelper("BRDUNG");
|
|
tstHelper("BRDUNGS");
|
|
tstHelper("BRDZAGS");
|
|
tstHelper("BRDZANG");
|
|
tstHelper("BRDZANGS");
|
|
tstHelper("BRDZEN");
|
|
tstHelper("BRDZES");
|
|
tstHelper("BRDZI");
|
|
tstHelper("BRDZIN");
|
|
tstHelper("BRDZIS");
|
|
tstHelper("BRDZOD");
|
|
tstHelper("BRDZOGS");
|
|
tstHelper("BRDZON");
|
|
tstHelper("BRDZUN");
|
|
tstHelper("BRDZUS");
|
|
tstHelper("BRE");
|
|
tstHelper("'BRE");
|
|
tstHelper("BRED");
|
|
tstHelper("'BRED");
|
|
tstHelper("BREG");
|
|
tstHelper("'BREG");
|
|
tstHelper("BREGS");
|
|
tstHelper("'BREGS");
|
|
tstHelper("BRE'I");
|
|
tstHelper("BREL");
|
|
tstHelper("'BREL");
|
|
tstHelper("BRENG");
|
|
tstHelper("'BRENG");
|
|
tstHelper("'BRENGS");
|
|
tstHelper("BRER");
|
|
tstHelper("BRES");
|
|
tstHelper("'BRES");
|
|
tstHelper("BRE'U");
|
|
tstHelper("BRGA");
|
|
tstHelper("BRGAL");
|
|
tstHelper("BRGAN");
|
|
tstHelper("BRGYA");
|
|
tstHelper("BRGYA'");
|
|
tstHelper("BRGYA'AM");
|
|
tstHelper("BRGYA'ANG");
|
|
tstHelper("BRGYAB");
|
|
tstHelper("BRGYAD");
|
|
tstHelper("BRGYAGS");
|
|
tstHelper("BRGYA'I");
|
|
tstHelper("BRGYAL");
|
|
tstHelper("BRGYAN");
|
|
tstHelper("BRGYANG");
|
|
tstHelper("BRGYANGS");
|
|
tstHelper("BRGYA'O");
|
|
tstHelper("BRGYAR");
|
|
tstHelper("BRGYAS");
|
|
tstHelper("BRGYI");
|
|
tstHelper("BRGYU");
|
|
tstHelper("BRGYUD");
|
|
tstHelper("BRGYUG");
|
|
tstHelper("BRGYUGS");
|
|
tstHelper("BRGYUR");
|
|
tstHelper("BRGYUS");
|
|
tstHelper("BRi");
|
|
tstHelper("BRI");
|
|
tstHelper("'BRI");
|
|
tstHelper("BRIB");
|
|
tstHelper("BRID");
|
|
tstHelper("'BRID");
|
|
tstHelper("BRIL");
|
|
tstHelper("BRIM");
|
|
tstHelper("'BRIM");
|
|
tstHelper("BRIMS");
|
|
tstHelper("'BRIN");
|
|
tstHelper("BRING");
|
|
tstHelper("'BRING");
|
|
tstHelper("'BRI'O");
|
|
tstHelper("BRIR");
|
|
tstHelper("'BRIR");
|
|
tstHelper("BRIS");
|
|
tstHelper("BRiTTA");
|
|
tstHelper("BRJE");
|
|
tstHelper("BRJED");
|
|
tstHelper("BRJES");
|
|
tstHelper("BRJID");
|
|
tstHelper("BRJING");
|
|
tstHelper("BRJOD");
|
|
tstHelper("BRJOS");
|
|
tstHelper("BRKAM");
|
|
tstHelper("BRKO");
|
|
tstHelper("BRKOR");
|
|
tstHelper("BRKOS");
|
|
tstHelper("BRKU");
|
|
tstHelper("BRKUS");
|
|
tstHelper("BRKYAL");
|
|
tstHelper("BRKYANG");
|
|
tstHelper("BRKYANGS");
|
|
tstHelper("BRLA");
|
|
tstHelper("BRLAB");
|
|
tstHelper("BRLABS");
|
|
tstHelper("BRLAG");
|
|
tstHelper("BRLAGS");
|
|
tstHelper("BRLA'I");
|
|
tstHelper("BRLAM");
|
|
tstHelper("BRLAN");
|
|
tstHelper("BRLANG");
|
|
tstHelper("BRLANGS");
|
|
tstHelper("BRLAR");
|
|
tstHelper("BRLAS");
|
|
tstHelper("BRNAB");
|
|
tstHelper("BRNAG");
|
|
tstHelper("BRNAGS");
|
|
tstHelper("BRNAL");
|
|
tstHelper("BRNAMS");
|
|
tstHelper("BRNAN");
|
|
tstHelper("BRNANGS");
|
|
tstHelper("BRNGA");
|
|
tstHelper("BRNGABS");
|
|
tstHelper("BRNGAM");
|
|
tstHelper("BRNGAR");
|
|
tstHelper("BRNGAS");
|
|
tstHelper("BRNGOD");
|
|
tstHelper("BRNYA");
|
|
tstHelper("BRNYAN");
|
|
tstHelper("BRNYAS");
|
|
tstHelper("BRNYED");
|
|
tstHelper("BRNYEN");
|
|
tstHelper("BRNYES");
|
|
tstHelper("BRNYIL");
|
|
tstHelper("BRNYIS");
|
|
tstHelper("BRNYOGS");
|
|
tstHelper("BRO");
|
|
tstHelper("'BRO");
|
|
tstHelper("BROD");
|
|
tstHelper("'BROD");
|
|
tstHelper("'BROG");
|
|
tstHelper("'BROM");
|
|
tstHelper("BRONGS");
|
|
tstHelper("'BRONGS");
|
|
tstHelper("BROR");
|
|
tstHelper("BROS");
|
|
tstHelper("'BROS");
|
|
tstHelper("BRTA");
|
|
tstHelper("BRTABS");
|
|
tstHelper("BRTAD");
|
|
tstHelper("BRTAG");
|
|
tstHelper("BRTAGS");
|
|
tstHelper("BRTAN");
|
|
tstHelper("BRTAR");
|
|
tstHelper("BRTAS");
|
|
tstHelper("BRTEG");
|
|
tstHelper("BRTEN");
|
|
tstHelper("BRTIB");
|
|
tstHelper("BRTN");
|
|
tstHelper("BRTOD");
|
|
tstHelper("BRTOG");
|
|
tstHelper("BRTOL");
|
|
tstHelper("BRTON");
|
|
tstHelper("BRTUL");
|
|
tstHelper("BRTUN");
|
|
tstHelper("BRTZA");
|
|
tstHelper("BRTZAD");
|
|
tstHelper("BRTZAL");
|
|
tstHelper("BRTZAM");
|
|
tstHelper("BRTZAMS");
|
|
tstHelper("BRTZAN");
|
|
tstHelper("BRTZE");
|
|
tstHelper("BRTZEG");
|
|
tstHelper("BRTZEGS");
|
|
tstHelper("BRTZE'I");
|
|
tstHelper("BRTZEN");
|
|
tstHelper("BRTZER");
|
|
tstHelper("BRTZES");
|
|
tstHelper("BRTZI");
|
|
tstHelper("BRTZIG");
|
|
tstHelper("BRTZIGS");
|
|
tstHelper("BRTZI'O");
|
|
tstHelper("BRTZIR");
|
|
tstHelper("BRTZIS");
|
|
tstHelper("BRTZNL");
|
|
tstHelper("BRTZOD");
|
|
tstHelper("BRTZOM");
|
|
tstHelper("BRTZON");
|
|
tstHelper("BRTZONG");
|
|
tstHelper("BRTZONGS");
|
|
tstHelper("BRTZUB");
|
|
tstHelper("BRTZUGS");
|
|
tstHelper("BRTZUN");
|
|
tstHelper("BRTZWA");
|
|
tstHelper("BRU");
|
|
tstHelper("'BRU");
|
|
tstHelper("'BRU'AM");
|
|
tstHelper("BRUBS");
|
|
tstHelper("BRUD");
|
|
tstHelper("BRUG");
|
|
tstHelper("'BRUG");
|
|
tstHelper("'BRU'I");
|
|
tstHelper("BRUL");
|
|
tstHelper("'BRUL");
|
|
tstHelper("'BRUM");
|
|
tstHelper("BRUN");
|
|
tstHelper("BRUNG");
|
|
tstHelper("BRUNGS");
|
|
tstHelper("BRU'O");
|
|
tstHelper("'BRUR");
|
|
tstHelper("BRUS");
|
|
tstHelper("'BRUS");
|
|
tstHelper("BSA");
|
|
tstHelper("BSAB");
|
|
tstHelper("BSABS");
|
|
tstHelper("BSAD");
|
|
tstHelper("BSAG");
|
|
tstHelper("BSAGS");
|
|
tstHelper("BSAL");
|
|
tstHelper("BSAM");
|
|
tstHelper("BSAMS");
|
|
tstHelper("BSAN");
|
|
tstHelper("BSANG");
|
|
tstHelper("BSANGS");
|
|
tstHelper("BSAR");
|
|
tstHelper("BSBU");
|
|
tstHelper("BSDAD");
|
|
tstHelper("BSDAGS");
|
|
tstHelper("BSDAL");
|
|
tstHelper("BSDAM");
|
|
tstHelper("BSDAMS");
|
|
tstHelper("BSDEB");
|
|
tstHelper("BSDEBS");
|
|
tstHelper("BSDIG");
|
|
tstHelper("BSDIGS");
|
|
tstHelper("BSDO");
|
|
tstHelper("BSDOD");
|
|
tstHelper("BSDOGS");
|
|
tstHelper("BSDOMS");
|
|
tstHelper("BSDON");
|
|
tstHelper("BSDONG");
|
|
tstHelper("BSDONGS");
|
|
tstHelper("BSDO'O");
|
|
tstHelper("BSDOS");
|
|
tstHelper("BSDU");
|
|
tstHelper("BSDUG");
|
|
tstHelper("BSDUM");
|
|
tstHelper("BSDUMS");
|
|
tstHelper("BSDUN");
|
|
tstHelper("BSDUS");
|
|
tstHelper("BSE");
|
|
tstHelper("BSEGS");
|
|
tstHelper("BSEL");
|
|
tstHelper("BSENG");
|
|
tstHelper("BSER");
|
|
tstHelper("BSGAL");
|
|
tstHelper("BSGEGS");
|
|
tstHelper("BSGO");
|
|
tstHelper("BSGO'AM");
|
|
tstHelper("BSGOM");
|
|
tstHelper("BSGOMS");
|
|
tstHelper("BSGONGS");
|
|
tstHelper("BSGO'O");
|
|
tstHelper("BSGOS");
|
|
tstHelper("BSGRAB");
|
|
tstHelper("BSGRAG");
|
|
tstHelper("BSGRAGS");
|
|
tstHelper("BSGRAL");
|
|
tstHelper("BSGRE");
|
|
tstHelper("BSGRENG");
|
|
tstHelper("BSGRENGS");
|
|
tstHelper("BSGRES");
|
|
tstHelper("BSGRIB");
|
|
tstHelper("BSGRIBS");
|
|
tstHelper("BSGRIGS");
|
|
tstHelper("BSGRIM");
|
|
tstHelper("BSGRIMS");
|
|
tstHelper("BSGRIN");
|
|
tstHelper("BSGROM");
|
|
tstHelper("BSGRON");
|
|
tstHelper("BSGRUB");
|
|
tstHelper("BSGRUBS");
|
|
tstHelper("BSGRUL");
|
|
tstHelper("BSGRUN");
|
|
tstHelper("BSGRUNGS");
|
|
tstHelper("BSGRUR");
|
|
tstHelper("BSGUB");
|
|
tstHelper("BSGUGS");
|
|
tstHelper("BSGUL");
|
|
tstHelper("BSGYANG");
|
|
tstHelper("BSGYANGS");
|
|
tstHelper("BSGYEL");
|
|
tstHelper("BSGYING");
|
|
tstHelper("BSGYINGS");
|
|
tstHelper("BSGYU");
|
|
tstHelper("BSGYUBS");
|
|
tstHelper("BSGYUR");
|
|
tstHelper("BSHA");
|
|
tstHelper("BSHA'");
|
|
tstHelper("BSHAD");
|
|
tstHelper("BSHAGS");
|
|
tstHelper("BSHAL");
|
|
tstHelper("BSHAM");
|
|
tstHelper("BSHAMS");
|
|
tstHelper("BSHAN");
|
|
tstHelper("BSHANG");
|
|
tstHelper("BSHAR");
|
|
tstHelper("BSHAS");
|
|
tstHelper("BSHEGS");
|
|
tstHelper("BSHEN");
|
|
tstHelper("BSHES");
|
|
tstHelper("BSHIG");
|
|
tstHelper("BSHIN");
|
|
tstHelper("BSHOL");
|
|
tstHelper("BSHOR");
|
|
tstHelper("BSHOS");
|
|
tstHelper("BSHUL");
|
|
tstHelper("BSHUM");
|
|
tstHelper("BSHUMS");
|
|
tstHelper("BSHUNG");
|
|
tstHelper("BSHUS");
|
|
tstHelper("BSIL");
|
|
tstHelper("BSKA");
|
|
tstHelper("BSKA'");
|
|
tstHelper("BSKAB");
|
|
tstHelper("BSKAL");
|
|
tstHelper("BSKAM");
|
|
tstHelper("BSKAMS");
|
|
tstHelper("BSKANG");
|
|
tstHelper("BSKANGS");
|
|
tstHelper("BSKAR");
|
|
tstHelper("BSKED");
|
|
tstHelper("BSKO");
|
|
tstHelper("BSKOD");
|
|
tstHelper("BSKOL");
|
|
tstHelper("BSKOMS");
|
|
tstHelper("BSKON");
|
|
tstHelper("BSKONGS");
|
|
tstHelper("BSKO'O");
|
|
tstHelper("BSKOR");
|
|
tstHelper("BSKOS");
|
|
tstHelper("BSKRAD");
|
|
tstHelper("BSKRAG");
|
|
tstHelper("BSKRAL");
|
|
tstHelper("BSKRANG");
|
|
tstHelper("BSKRIN");
|
|
tstHelper("BSKROGS");
|
|
tstHelper("BSKRU");
|
|
tstHelper("BSKRUL");
|
|
tstHelper("BSKRUN");
|
|
tstHelper("BSKU");
|
|
tstHelper("BSKUL");
|
|
tstHelper("BSKUM");
|
|
tstHelper("BSKUMS");
|
|
tstHelper("BSKU'O");
|
|
tstHelper("BSKUR");
|
|
tstHelper("BSKUS");
|
|
tstHelper("BSKYAB");
|
|
tstHelper("BSKYABS");
|
|
tstHelper("BSKYAD");
|
|
tstHelper("BSKYAL");
|
|
tstHelper("BSKYANG");
|
|
tstHelper("BSKYAS");
|
|
tstHelper("BSKYE");
|
|
tstHelper("BSKYED");
|
|
tstHelper("BSKYEL");
|
|
tstHelper("BSKYENG");
|
|
tstHelper("BSKYES");
|
|
tstHelper("BSKYID");
|
|
tstHelper("BSKYIL");
|
|
tstHelper("BSKYOD");
|
|
tstHelper("BSKYOM");
|
|
tstHelper("BSKYON");
|
|
tstHelper("BSKYONG");
|
|
tstHelper("BSKYUD");
|
|
tstHelper("BSKYUG");
|
|
tstHelper("BSKYUNG");
|
|
tstHelper("BSKYUNGS");
|
|
tstHelper("BSKYUR");
|
|
tstHelper("BSLA");
|
|
tstHelper("BSLAB");
|
|
tstHelper("BSLABS");
|
|
tstHelper("BSLAD");
|
|
tstHelper("BSLANG");
|
|
tstHelper("BSLANGS");
|
|
tstHelper("BSLAR");
|
|
tstHelper("BSLENGS");
|
|
tstHelper("BSLONG");
|
|
tstHelper("BSLONGS");
|
|
tstHelper("BSLU");
|
|
tstHelper("BSLU'O");
|
|
tstHelper("BSLUS");
|
|
tstHelper("BSMAS");
|
|
tstHelper("BSMRA");
|
|
tstHelper("BSNAM");
|
|
tstHelper("BSNAMS");
|
|
tstHelper("BSNAN");
|
|
tstHelper("BSNANG");
|
|
tstHelper("BSNGA");
|
|
tstHelper("BSNGAD");
|
|
tstHelper("BSNGAGS");
|
|
tstHelper("BSNGAL");
|
|
tstHelper("BSNGAM");
|
|
tstHelper("BSNGAMS");
|
|
tstHelper("BSNGAS");
|
|
tstHelper("BSNGO");
|
|
tstHelper("BSNGO'AM");
|
|
tstHelper("BSNGO'ANG");
|
|
tstHelper("BSNGOD");
|
|
tstHelper("BSNGOGS");
|
|
tstHelper("BSNGOMS");
|
|
tstHelper("BSNGON");
|
|
tstHelper("BSNGO'O");
|
|
tstHelper("BSNGOR");
|
|
tstHelper("BSNGOS");
|
|
tstHelper("BSNOL");
|
|
tstHelper("BSNOR");
|
|
tstHelper("BSNUN");
|
|
tstHelper("BSNUR");
|
|
tstHelper("BSNYAD");
|
|
tstHelper("BSNYAGS");
|
|
tstHelper("BSNYAL");
|
|
tstHelper("BSNYAMS");
|
|
tstHelper("BSNYAN");
|
|
tstHelper("BSNYED");
|
|
tstHelper("BSNYEG");
|
|
tstHelper("BSNYEGS");
|
|
tstHelper("BSNYEL");
|
|
tstHelper("BSNYEMS");
|
|
tstHelper("BSNYEN");
|
|
tstHelper("BSNYENGS");
|
|
tstHelper("BSNYER");
|
|
tstHelper("BSNYES");
|
|
tstHelper("BSNYIL");
|
|
tstHelper("BSNYINGS");
|
|
tstHelper("BSNYOD");
|
|
tstHelper("BSNYOGS");
|
|
tstHelper("BSNYON");
|
|
tstHelper("BSNYUN");
|
|
tstHelper("BSNYUNG");
|
|
tstHelper("BSNYUNGS");
|
|
tstHelper("BSO");
|
|
tstHelper("BSOD");
|
|
tstHelper("BSOGS");
|
|
tstHelper("BSOL");
|
|
tstHelper("BSONG");
|
|
tstHelper("BSOS");
|
|
tstHelper("BSPOBS");
|
|
tstHelper("BSPYAD");
|
|
tstHelper("BSRABS");
|
|
tstHelper("BSRAD");
|
|
tstHelper("BSRANG");
|
|
tstHelper("BSRE");
|
|
tstHelper("BSREG");
|
|
tstHelper("BSREGS");
|
|
tstHelper("BSREL");
|
|
tstHelper("BSRES");
|
|
tstHelper("BSRI");
|
|
tstHelper("BSRID");
|
|
tstHelper("BSRING");
|
|
tstHelper("BSRINGS");
|
|
tstHelper("BSRI'O");
|
|
tstHelper("BSRO");
|
|
tstHelper("BSROG");
|
|
tstHelper("BSROS");
|
|
tstHelper("BSRUBS");
|
|
tstHelper("BSRUNG");
|
|
tstHelper("BSRUNGS");
|
|
tstHelper("BSTA");
|
|
tstHelper("BSTAB");
|
|
tstHelper("BSTABS");
|
|
tstHelper("BSTAD");
|
|
tstHelper("BSTAN");
|
|
tstHelper("BSTANG");
|
|
tstHelper("BSTANGS");
|
|
tstHelper("BSTAR");
|
|
tstHelper("BSTAS");
|
|
tstHelper("BSTE");
|
|
tstHelper("BSTED");
|
|
tstHelper("BSTEN");
|
|
tstHelper("BSTENG");
|
|
tstHelper("BSTI");
|
|
tstHelper("BSTING");
|
|
tstHelper("BSTOBS");
|
|
tstHelper("BSTOD");
|
|
tstHelper("BSTON");
|
|
tstHelper("BSTONG");
|
|
tstHelper("BSTU");
|
|
tstHelper("BSTUD");
|
|
tstHelper("BSTUN");
|
|
tstHelper("BSTUNG");
|
|
tstHelper("BSTUNGS");
|
|
tstHelper("BSTZAGS");
|
|
tstHelper("BSTZAL");
|
|
tstHelper("BSTZOL");
|
|
tstHelper("BSU");
|
|
tstHelper("BSUN");
|
|
tstHelper("BSUNG");
|
|
tstHelper("BSU'O");
|
|
tstHelper("BSUR");
|
|
tstHelper("BSUS");
|
|
tstHelper("BTA");
|
|
tstHelper("BTA'");
|
|
tstHelper("BTAB");
|
|
tstHelper("BTABS");
|
|
tstHelper("BTAD");
|
|
tstHelper("BTAG");
|
|
tstHelper("BTAGS");
|
|
tstHelper("BTAMS");
|
|
tstHelper("BTANG");
|
|
tstHelper("BTANGS");
|
|
tstHelper("BTA'O");
|
|
tstHelper("BTAR");
|
|
tstHelper("BTAS");
|
|
tstHelper("BTEG");
|
|
tstHelper("BTENG");
|
|
tstHelper("BTHOB");
|
|
tstHelper("BTING");
|
|
tstHelper("BTOD");
|
|
tstHelper("BTOGS");
|
|
tstHelper("BTOL");
|
|
tstHelper("BTON");
|
|
tstHelper("BTONG");
|
|
tstHelper("BTSAL");
|
|
tstHelper("BTSAN");
|
|
tstHelper("BTSANGS");
|
|
tstHelper("BTSUN");
|
|
tstHelper("BTU");
|
|
tstHelper("BTUB");
|
|
tstHelper("BTUD");
|
|
tstHelper("BTU'I");
|
|
tstHelper("BTUL");
|
|
tstHelper("BTUNG");
|
|
tstHelper("BTUS");
|
|
tstHelper("BTZA'");
|
|
tstHelper("BTZAD");
|
|
tstHelper("BTZAG");
|
|
tstHelper("BTZAGS");
|
|
tstHelper("BTZAL");
|
|
tstHelper("BTZAM");
|
|
tstHelper("BTZAMS");
|
|
tstHelper("BTZAN");
|
|
tstHelper("BTZANG");
|
|
tstHelper("BTZAR");
|
|
tstHelper("BTZAS");
|
|
tstHelper("BTZE");
|
|
tstHelper("BTZEM");
|
|
tstHelper("BTZEMS");
|
|
tstHelper("BTZIR");
|
|
tstHelper("BTZO");
|
|
tstHelper("BTZOD");
|
|
tstHelper("BTZOG");
|
|
tstHelper("BTZOM");
|
|
tstHelper("BTZON");
|
|
tstHelper("BTZONG");
|
|
tstHelper("BTZONGS");
|
|
tstHelper("BTZO'O");
|
|
tstHelper("BTZOS");
|
|
tstHelper("BTZUD");
|
|
tstHelper("BTZUG");
|
|
tstHelper("BTZUGS");
|
|
tstHelper("BTZUM");
|
|
tstHelper("BTZUMS");
|
|
tstHelper("BTZUN");
|
|
tstHelper("BTZVA");
|
|
tstHelper("BTZWA");
|
|
tstHelper("BU");
|
|
tstHelper("'BU");
|
|
tstHelper("BU'");
|
|
tstHelper("BU'AM");
|
|
tstHelper("BU'ANG");
|
|
tstHelper("BUB");
|
|
tstHelper("'BUBS");
|
|
tstHelper("BUD");
|
|
tstHelper("'BUD");
|
|
tstHelper("BU-DADHA");
|
|
tstHelper("BUDDHA");
|
|
tstHelper("BUDDH'A");
|
|
tstHelper("BUG");
|
|
tstHelper("'BUGS");
|
|
tstHelper("'BU'I");
|
|
tstHelper("BU'I");
|
|
tstHelper("BU'I'O");
|
|
tstHelper("BUL");
|
|
tstHelper("'BUL");
|
|
tstHelper("BUm");
|
|
tstHelper("BUM");
|
|
tstHelper("'BUM");
|
|
tstHelper("BU'MA");
|
|
tstHelper("BUN");
|
|
tstHelper("BUNG");
|
|
tstHelper("BUNGS");
|
|
tstHelper("'BUNGS");
|
|
tstHelper("BU'O");
|
|
tstHelper("BUR");
|
|
tstHelper("'BUR");
|
|
tstHelper("BUS");
|
|
tstHelper("'BUS");
|
|
tstHelper("BYA");
|
|
tstHelper("BYA'AM");
|
|
tstHelper("BYA'ANG");
|
|
tstHelper("BYAB");
|
|
tstHelper("BYAD");
|
|
tstHelper("BYA'I");
|
|
tstHelper("BYAM");
|
|
tstHelper("'BYAM");
|
|
tstHelper("BYAMS");
|
|
tstHelper("BYAN");
|
|
tstHelper("BYANG");
|
|
tstHelper("'BYANG");
|
|
tstHelper("BYANGS");
|
|
tstHelper("BYA'O");
|
|
tstHelper("BYA'OSHES");
|
|
tstHelper("BYAR");
|
|
tstHelper("'BYAR");
|
|
tstHelper("BYAS");
|
|
tstHelper("BYE");
|
|
tstHelper("'BYE");
|
|
tstHelper("BYE'AM");
|
|
tstHelper("BYEB");
|
|
tstHelper("BYED");
|
|
tstHelper("'BYED");
|
|
tstHelper("'BYEL");
|
|
tstHelper("BYEM");
|
|
tstHelper("BYEMS");
|
|
tstHelper("BYEN");
|
|
tstHelper("'BYENG");
|
|
tstHelper("BYER");
|
|
tstHelper("'BYER");
|
|
tstHelper("BYES");
|
|
tstHelper("'BYES");
|
|
tstHelper("BYE'U");
|
|
tstHelper("BYI");
|
|
tstHelper("'BYI");
|
|
tstHelper("BYID");
|
|
tstHelper("'BYID");
|
|
tstHelper("BYIN");
|
|
tstHelper("'BYIN");
|
|
tstHelper("BYING");
|
|
tstHelper("'BYING");
|
|
tstHelper("BYINGS");
|
|
tstHelper("BYIR");
|
|
tstHelper("BYIS");
|
|
tstHelper("BYI'U");
|
|
tstHelper("BYO");
|
|
tstHelper("'BYO");
|
|
tstHelper("BYOD");
|
|
tstHelper("BYOG");
|
|
tstHelper("BYOL");
|
|
tstHelper("'BYOL");
|
|
tstHelper("BYON");
|
|
tstHelper("'BYON");
|
|
tstHelper("'BYONG");
|
|
tstHelper("'BYOR");
|
|
tstHelper("BYOS");
|
|
tstHelper("BYU");
|
|
tstHelper("BY'U");
|
|
tstHelper("BYU'");
|
|
tstHelper("BYUD");
|
|
tstHelper("'BYUD");
|
|
tstHelper("BYUG");
|
|
tstHelper("'BYUG");
|
|
tstHelper("BYUGS");
|
|
tstHelper("BYUL");
|
|
tstHelper("BYUMS");
|
|
tstHelper("BYUN");
|
|
tstHelper("BYUNB");
|
|
tstHelper("BYUNG");
|
|
tstHelper("'BYUNG");
|
|
tstHelper("BYUNGS");
|
|
tstHelper("BYUR");
|
|
tstHelper("'BYUR");
|
|
tstHelper("BZA'");
|
|
tstHelper("BZAD");
|
|
tstHelper("BZAG");
|
|
tstHelper("BZA'I");
|
|
tstHelper("BZAL");
|
|
tstHelper("BZALS");
|
|
tstHelper("BZANG");
|
|
tstHelper("BZANGS");
|
|
tstHelper("BZA'O");
|
|
tstHelper("BZAR");
|
|
tstHelper("BZAS");
|
|
tstHelper("BZED");
|
|
tstHelper("BZENG");
|
|
tstHelper("BZENGS");
|
|
tstHelper("BZHAB");
|
|
tstHelper("BZHABS");
|
|
tstHelper("BZHAD");
|
|
tstHelper("BZHAG");
|
|
tstHelper("BZHAL");
|
|
tstHelper("BZHAM");
|
|
tstHelper("BZHAMS");
|
|
tstHelper("BZHAN");
|
|
tstHelper("BZHAR");
|
|
tstHelper("BZHAS");
|
|
tstHelper("BZHE");
|
|
tstHelper("BZHED");
|
|
tstHelper("BZHEGS");
|
|
tstHelper("BZHEN");
|
|
tstHelper("BZHENGS");
|
|
tstHelper("BZHES");
|
|
tstHelper("BZHI");
|
|
tstHelper("BZHI'AM");
|
|
tstHelper("BZHI'ANG");
|
|
tstHelper("BZHIB");
|
|
tstHelper("BZHIBS");
|
|
tstHelper("BZHIG");
|
|
tstHelper("BZHIGS");
|
|
tstHelper("BZHI'I");
|
|
tstHelper("BZHIL");
|
|
tstHelper("BZHI'MA");
|
|
tstHelper("BZHIN");
|
|
tstHelper("BZHING");
|
|
tstHelper("BZHINGS");
|
|
tstHelper("BZHINN");
|
|
tstHelper("BZHI'O");
|
|
tstHelper("BZHIR");
|
|
tstHelper("BZHIS");
|
|
tstHelper("BZHO");
|
|
tstHelper("BZHOG");
|
|
tstHelper("BZHON");
|
|
tstHelper("BZHOS");
|
|
tstHelper("BZHU");
|
|
tstHelper("BZHUD");
|
|
tstHelper("BZHUG");
|
|
tstHelper("BZHUGS");
|
|
tstHelper("BZHUNG");
|
|
tstHelper("BZHUS");
|
|
tstHelper("BZIN");
|
|
tstHelper("BZLA");
|
|
tstHelper("BZLA'O");
|
|
tstHelper("BZLAR");
|
|
tstHelper("BZLAS");
|
|
tstHelper("BZLOG");
|
|
tstHelper("BZLOGS");
|
|
tstHelper("BZLUGS");
|
|
tstHelper("BZLUM");
|
|
tstHelper("BZLUMS");
|
|
tstHelper("BZO");
|
|
tstHelper("BZO'AM");
|
|
tstHelper("BZOD");
|
|
tstHelper("BZO'I");
|
|
tstHelper("BZON");
|
|
tstHelper("BZONG");
|
|
tstHelper("BZOR");
|
|
tstHelper("BZOS");
|
|
tstHelper("BZUD");
|
|
tstHelper("BZUGS");
|
|
tstHelper("BZUNG");
|
|
tstHelper("BZUNGS");
|
|
tstHelper("BZUR");
|
|
tstHelper("CA");
|
|
tstHelper("CA'AM");
|
|
tstHelper("CAD");
|
|
tstHelper("'CAD");
|
|
tstHelper("CAG");
|
|
tstHelper("CAGS");
|
|
tstHelper("CA'I");
|
|
tstHelper("CAL");
|
|
tstHelper("CAM");
|
|
tstHelper("CAN");
|
|
tstHelper("CANG");
|
|
tstHelper("CAR");
|
|
tstHelper("CAS");
|
|
tstHelper("CE");
|
|
tstHelper("CE'AM");
|
|
tstHelper("CEG");
|
|
tstHelper("CEHN");
|
|
tstHelper("CE'I");
|
|
tstHelper("CEN");
|
|
tstHelper("CE'O");
|
|
tstHelper("CER");
|
|
tstHelper("CeS");
|
|
tstHelper("CES");
|
|
tstHelper("CHA");
|
|
tstHelper("'CHA");
|
|
tstHelper("'CHA'");
|
|
tstHelper("CHA'AM");
|
|
tstHelper("CHA'ANG");
|
|
tstHelper("CHAB");
|
|
tstHelper("'CHAB");
|
|
tstHelper("CHABS");
|
|
tstHelper("CHAD");
|
|
tstHelper("'CHAD");
|
|
tstHelper("CHAG");
|
|
tstHelper("'CHAG");
|
|
tstHelper("CHAGS");
|
|
tstHelper("'CHAGS");
|
|
tstHelper("'CHA'I");
|
|
tstHelper("CHA'I");
|
|
tstHelper("CHAL");
|
|
tstHelper("'CHAL");
|
|
tstHelper("CHAM");
|
|
tstHelper("'CHAM");
|
|
tstHelper("CHAN");
|
|
tstHelper("CHANG");
|
|
tstHelper("'CHANG");
|
|
tstHelper("CHANGS");
|
|
tstHelper("'CHA'O");
|
|
tstHelper("CHA'O");
|
|
tstHelper("CHAR");
|
|
tstHelper("'CHAR");
|
|
tstHelper("CHAS");
|
|
tstHelper("CHE");
|
|
tstHelper("'CHE");
|
|
tstHelper("'CHE'AM");
|
|
tstHelper("CHE'AM");
|
|
tstHelper("CHE'ANG");
|
|
tstHelper("CHEB");
|
|
tstHelper("CHED");
|
|
tstHelper("'CHEG");
|
|
tstHelper("CHE'I");
|
|
tstHelper("CHEL");
|
|
tstHelper("'CHEL");
|
|
tstHelper("CHEM");
|
|
tstHelper("CHEMS");
|
|
tstHelper("CHEN");
|
|
tstHelper("CHENN");
|
|
tstHelper("'CHE'O");
|
|
tstHelper("CHE'O");
|
|
tstHelper("CHER");
|
|
tstHelper("CHES");
|
|
tstHelper("'CHES");
|
|
tstHelper("CHI");
|
|
tstHelper("'CHI");
|
|
tstHelper("'CHI'AM");
|
|
tstHelper("'CHIB");
|
|
tstHelper("CHIBS");
|
|
tstHelper("CHIG");
|
|
tstHelper("'CHIG");
|
|
tstHelper("'CHI'I");
|
|
tstHelper("CHI'I");
|
|
tstHelper("CHIM");
|
|
tstHelper("CHIN");
|
|
tstHelper("CHING");
|
|
tstHelper("'CHING");
|
|
tstHelper("CHINGS");
|
|
tstHelper("'CHI'O");
|
|
tstHelper("CHI'O");
|
|
tstHelper("CHIR");
|
|
tstHelper("'CHIR");
|
|
tstHelper("CHIS");
|
|
tstHelper("'CHIS");
|
|
tstHelper("CHO");
|
|
tstHelper("'CHO");
|
|
tstHelper("CHOD");
|
|
tstHelper("CHOG");
|
|
tstHelper("CHOGS");
|
|
tstHelper("CHOL");
|
|
tstHelper("'CHOL");
|
|
tstHelper("CHOM");
|
|
tstHelper("CHOMS");
|
|
tstHelper("CHON");
|
|
tstHelper("CHONG");
|
|
tstHelper("CHONGS");
|
|
tstHelper("CHOR");
|
|
tstHelper("'CHOR");
|
|
tstHelper("CHOS");
|
|
tstHelper("'CHOS");
|
|
tstHelper("CHU");
|
|
tstHelper("'CHU");
|
|
tstHelper("CHU'AM");
|
|
tstHelper("CHUB");
|
|
tstHelper("CHUD");
|
|
tstHelper("'CHUD");
|
|
tstHelper("CHUG");
|
|
tstHelper("CHUGS");
|
|
tstHelper("'CHUGS");
|
|
tstHelper("CHU'I");
|
|
tstHelper("CHUL");
|
|
tstHelper("CHUMS");
|
|
tstHelper("'CHUMS");
|
|
tstHelper("CHUN");
|
|
tstHelper("CHUNG");
|
|
tstHelper("CHUNGS");
|
|
tstHelper("CHU'O");
|
|
tstHelper("CHUP");
|
|
tstHelper("CHUR");
|
|
tstHelper("CHUS");
|
|
tstHelper("'CHUS");
|
|
tstHelper("CI");
|
|
tstHelper("'CI");
|
|
tstHelper("CI'AM");
|
|
tstHelper("CI'ANG");
|
|
tstHelper("CID");
|
|
tstHelper("CI'DRA");
|
|
tstHelper("CIG");
|
|
tstHelper("CIGN");
|
|
tstHelper("CI'i");
|
|
tstHelper("CI'I");
|
|
tstHelper("CIL");
|
|
tstHelper("CIM");
|
|
tstHelper("CIN");
|
|
tstHelper("CING");
|
|
tstHelper("'CING");
|
|
tstHelper("CINGS");
|
|
tstHelper("CI'O");
|
|
tstHelper("CIR");
|
|
tstHelper("CIS");
|
|
tstHelper("CO");
|
|
tstHelper("COD");
|
|
tstHelper("COG");
|
|
tstHelper("CO'I");
|
|
tstHelper("COL");
|
|
tstHelper("COM");
|
|
tstHelper("CON");
|
|
tstHelper("COR");
|
|
tstHelper("COS");
|
|
tstHelper("CU");
|
|
tstHelper("CU'AM");
|
|
tstHelper("CUB");
|
|
tstHelper("CUD");
|
|
tstHelper("CUG");
|
|
tstHelper("CU'I");
|
|
tstHelper("CUNG");
|
|
tstHelper("CUR");
|
|
tstHelper("CUS");
|
|
tstHelper("D");
|
|
tstHelper("'D");
|
|
tstHelper("da");
|
|
tstHelper("dA");
|
|
tstHelper("d'A");
|
|
tstHelper("dA'");
|
|
tstHelper("DA");
|
|
tstHelper("'DA");
|
|
tstHelper("'D'A");
|
|
tstHelper("'DA'");
|
|
tstHelper("D'A");
|
|
tstHelper("DA'");
|
|
tstHelper("DA'AM");
|
|
tstHelper("DA'ANG");
|
|
tstHelper("dAB");
|
|
tstHelper("DAB");
|
|
tstHelper("'DAB");
|
|
tstHelper("'DABS");
|
|
tstHelper("DAD");
|
|
tstHelper("'DAD");
|
|
tstHelper("DAG");
|
|
tstHelper("'DAG");
|
|
tstHelper("'DAG'");
|
|
tstHelper("DAG'");
|
|
tstHelper("DAGN");
|
|
tstHelper("DAGS");
|
|
tstHelper("DAHA-'I");
|
|
tstHelper("dAI");
|
|
tstHelper("DA'I");
|
|
tstHelper("DAK");
|
|
tstHelper("DAL");
|
|
tstHelper("'DAL");
|
|
tstHelper("DAM");
|
|
tstHelper("'DAM");
|
|
tstHelper("DAM'");
|
|
tstHelper("DAMG");
|
|
tstHelper("DAMN");
|
|
tstHelper("DAMS");
|
|
tstHelper("'DAMS");
|
|
tstHelper("DAN");
|
|
tstHelper("'DAN");
|
|
tstHelper("DAND");
|
|
tstHelper("DAndA");
|
|
tstHelper("DAnd'A");
|
|
tstHelper("DAN-DA");
|
|
tstHelper("DANG");
|
|
tstHelper("'DANG");
|
|
tstHelper("DANG");
|
|
tstHelper("DANGDES");
|
|
tstHelper("DANG'GA-YES");
|
|
tstHelper("DANG'JIG");
|
|
tstHelper("DANGLO");
|
|
tstHelper("DANGME'I");
|
|
tstHelper("DANGNGA");
|
|
tstHelper("DANGRNAM");
|
|
tstHelper("DANGS");
|
|
tstHelper("DANGTSANGS");
|
|
tstHelper("'DA'O");
|
|
tstHelper("DAR");
|
|
tstHelper("'DAR");
|
|
tstHelper("D'AR");
|
|
tstHelper("DAR-BHA");
|
|
tstHelper("DAS");
|
|
tstHelper("'DAS");
|
|
tstHelper("D'AS");
|
|
tstHelper("'DAS");
|
|
tstHelper("KYIS");
|
|
tstHelper("DATA");
|
|
tstHelper("dA'U");
|
|
tstHelper("D'AU");
|
|
tstHelper("dA'URYA");
|
|
tstHelper("DA'URYA'I");
|
|
tstHelper("DBA'");
|
|
tstHelper("DBAB");
|
|
tstHelper("DBAG");
|
|
tstHelper("DBA'I");
|
|
tstHelper("DBAL");
|
|
tstHelper("DBAN");
|
|
tstHelper("DBANB");
|
|
tstHelper("DBANG");
|
|
tstHelper("DBAR");
|
|
tstHelper("DBAS");
|
|
tstHelper("DBE");
|
|
tstHelper("DBEN");
|
|
tstHelper("DBER");
|
|
tstHelper("DBES");
|
|
tstHelper("DBI");
|
|
tstHelper("DBO");
|
|
tstHelper("DBOG");
|
|
tstHelper("DBON");
|
|
tstHelper("DBRAL");
|
|
tstHelper("DBRI");
|
|
tstHelper("DBROG");
|
|
tstHelper("DBU");
|
|
tstHelper("DBUB");
|
|
tstHelper("DBUG");
|
|
tstHelper("DBUGS");
|
|
tstHelper("DBU'I");
|
|
tstHelper("DBUL");
|
|
tstHelper("DBUNG");
|
|
tstHelper("DBUR");
|
|
tstHelper("DBUS");
|
|
tstHelper("DBYA");
|
|
tstHelper("DBYAD");
|
|
tstHelper("DBYANG");
|
|
tstHelper("DBYANGS");
|
|
tstHelper("DBYAR");
|
|
tstHelper("DBYE");
|
|
tstHelper("DBYE'I");
|
|
tstHelper("DBYEN");
|
|
tstHelper("DBYE'O");
|
|
tstHelper("DBYER");
|
|
tstHelper("DBYES");
|
|
tstHelper("DBYI");
|
|
tstHelper("DBYIBS");
|
|
tstHelper("DBYID");
|
|
tstHelper("DBYIG");
|
|
tstHelper("DBYING");
|
|
tstHelper("DBYINGS");
|
|
tstHelper("DBYING-SU");
|
|
tstHelper("DBYOD");
|
|
tstHelper("DBYU");
|
|
tstHelper("DBYUG");
|
|
tstHelper("DBYUNG");
|
|
tstHelper("DD");
|
|
tstHelper("DD");
|
|
tstHelper("DDAHA");
|
|
tstHelper("DDANG");
|
|
tstHelper("DDHA");
|
|
tstHelper("dE");
|
|
tstHelper("DE");
|
|
tstHelper("'DE");
|
|
tstHelper("DE'");
|
|
tstHelper("DE'AM");
|
|
tstHelper("DE'ANG");
|
|
tstHelper("DEBS");
|
|
tstHelper("'DEBS");
|
|
tstHelper("DED");
|
|
tstHelper("'DED");
|
|
tstHelper("DEEHA");
|
|
tstHelper("DEG");
|
|
tstHelper("'DEG");
|
|
tstHelper("'DEGS");
|
|
tstHelper("'DE'I");
|
|
tstHelper("DE-'I");
|
|
tstHelper("DE'I");
|
|
tstHelper("DEL");
|
|
tstHelper("'DEL");
|
|
tstHelper("'DEMS");
|
|
tstHelper("DEN");
|
|
tstHelper("'DEN");
|
|
tstHelper("DENG");
|
|
tstHelper("'DENG");
|
|
tstHelper("DENGS");
|
|
tstHelper("DE'O");
|
|
tstHelper("DER");
|
|
tstHelper("DES");
|
|
tstHelper("'DES");
|
|
tstHelper("DE'U");
|
|
tstHelper("DGA");
|
|
tstHelper("DGA'");
|
|
tstHelper("DGA'AM");
|
|
tstHelper("DGA'-'AM");
|
|
tstHelper("DGA'AS");
|
|
tstHelper("DGAB");
|
|
tstHelper("DGA'BO");
|
|
tstHelper("DGAG");
|
|
tstHelper("DGAGS");
|
|
tstHelper("DGA'I");
|
|
tstHelper("DGA'I'O");
|
|
tstHelper("DGAL");
|
|
tstHelper("DGAN");
|
|
tstHelper("DGANG");
|
|
tstHelper("DGANGS");
|
|
tstHelper("DGA'O");
|
|
tstHelper("DGAR");
|
|
tstHelper("DGAS");
|
|
tstHelper("DG'AS");
|
|
tstHelper("DGA'S");
|
|
tstHelper("DGA'SA");
|
|
tstHelper("DGE");
|
|
tstHelper("DGE'I");
|
|
tstHelper("DGE'O");
|
|
tstHelper("DGER");
|
|
tstHelper("DGES");
|
|
tstHelper("DGO");
|
|
tstHelper("DGOD");
|
|
tstHelper("DGOG");
|
|
tstHelper("DGOL");
|
|
tstHelper("DGON");
|
|
tstHelper("DGONG");
|
|
tstHelper("DGONGS");
|
|
tstHelper("DGOS");
|
|
tstHelper("DGRA");
|
|
tstHelper("DGRA'I");
|
|
tstHelper("DGRAL");
|
|
tstHelper("DGRAM");
|
|
tstHelper("DGRA'O");
|
|
tstHelper("DGRAR");
|
|
tstHelper("DGRAS");
|
|
tstHelper("DGROGS");
|
|
tstHelper("DGROL");
|
|
tstHelper("DGRONG");
|
|
tstHelper("DGRONGS");
|
|
tstHelper("DGU");
|
|
tstHelper("DGU'AM");
|
|
tstHelper("DGUD");
|
|
tstHelper("DGUG");
|
|
tstHelper("DGU'I");
|
|
tstHelper("DGUM");
|
|
tstHelper("DGUN");
|
|
tstHelper("DGUNG");
|
|
tstHelper("DGU'O");
|
|
tstHelper("DGUR");
|
|
tstHelper("DGUS");
|
|
tstHelper("DGYE");
|
|
tstHelper("DGYED");
|
|
tstHelper("DGYE'O");
|
|
tstHelper("DGYER");
|
|
tstHelper("DGYES");
|
|
tstHelper("DGYIS");
|
|
tstHelper("dHA");
|
|
tstHelper("DHA");
|
|
tstHelper("DH'A");
|
|
tstHelper("DH'A'I");
|
|
tstHelper("DHA'I");
|
|
tstHelper("DH'A'I");
|
|
tstHelper("DHA-'I");
|
|
tstHelper("DHA'I");
|
|
tstHelper("DHA'I'O");
|
|
tstHelper("dhAm");
|
|
tstHelper("DHANYDZA");
|
|
tstHelper("DHAR");
|
|
tstHelper("DH'AR");
|
|
tstHelper("DHARA");
|
|
tstHelper("DH'ARA");
|
|
tstHelper("DHARMA");
|
|
tstHelper("DHA-RMA");
|
|
tstHelper("DHARM'A");
|
|
tstHelper("DHARMA'I");
|
|
tstHelper("DHARMAS");
|
|
tstHelper("DHARM'AS");
|
|
tstHelper("DHARMMA");
|
|
tstHelper("DHAS");
|
|
tstHelper("DHE");
|
|
tstHelper("DHI");
|
|
tstHelper("DHI'I");
|
|
tstHelper("dhU");
|
|
tstHelper("DHU");
|
|
tstHelper("DHVA");
|
|
tstHelper("DHWA");
|
|
tstHelper("DHYA");
|
|
tstHelper("dI");
|
|
tstHelper("d'I");
|
|
tstHelper("DI");
|
|
tstHelper("'DI");
|
|
tstHelper("D'I");
|
|
tstHelper("'DI'AM");
|
|
tstHelper("'DI-'ANG");
|
|
tstHelper("'DI'ANG");
|
|
tstHelper("'DIBS");
|
|
tstHelper("DIG");
|
|
tstHelper("'DIG");
|
|
tstHelper("'DI'I");
|
|
tstHelper("DI'I");
|
|
tstHelper("'DIL");
|
|
tstHelper("'DIN");
|
|
tstHelper("dING");
|
|
tstHelper("DING");
|
|
tstHelper("'DING");
|
|
tstHelper("'DINGS");
|
|
tstHelper("'DINI");
|
|
tstHelper("'DI'O");
|
|
tstHelper("'DIR");
|
|
tstHelper("'DIRAB");
|
|
tstHelper("'DIS");
|
|
tstHelper("DI'U");
|
|
tstHelper("DKA'");
|
|
tstHelper("DKA'AN");
|
|
tstHelper("DKA'I");
|
|
tstHelper("DKAN");
|
|
tstHelper("DKANG");
|
|
tstHelper("DKA'O");
|
|
tstHelper("DKAR");
|
|
tstHelper("DKAS");
|
|
tstHelper("DKOD");
|
|
tstHelper("DKON");
|
|
tstHelper("DKOR");
|
|
tstHelper("DKRI");
|
|
tstHelper("DKRIGS");
|
|
tstHelper("DKRIS");
|
|
tstHelper("DKROL");
|
|
tstHelper("DKRONGS");
|
|
tstHelper("DKRUG");
|
|
tstHelper("DKRUGS");
|
|
tstHelper("DKU");
|
|
tstHelper("DKUN");
|
|
tstHelper("DKUR");
|
|
tstHelper("DKYEL");
|
|
tstHelper("DKYES");
|
|
tstHelper("DKYIL");
|
|
tstHelper("DKYOG");
|
|
tstHelper("DKYUS");
|
|
tstHelper("DMA");
|
|
tstHelper("DMA'");
|
|
tstHelper("DMAD");
|
|
tstHelper("DMAG");
|
|
tstHelper("DMAN");
|
|
tstHelper("DMANG");
|
|
tstHelper("DMANGS");
|
|
tstHelper("DMA'O");
|
|
tstHelper("DMAR");
|
|
tstHelper("DMAS");
|
|
tstHelper("DME");
|
|
tstHelper("DMI");
|
|
tstHelper("DMIG");
|
|
tstHelper("DMIGS");
|
|
tstHelper("DMIN");
|
|
tstHelper("DMOD");
|
|
tstHelper("DMU");
|
|
tstHelper("DMUG");
|
|
tstHelper("DMUL");
|
|
tstHelper("DMUS");
|
|
tstHelper("DMYAL");
|
|
tstHelper("DNA");
|
|
tstHelper("DNAG");
|
|
tstHelper("DNGAGS");
|
|
tstHelper("DNGAN");
|
|
tstHelper("DNGANG");
|
|
tstHelper("DNGANGS");
|
|
tstHelper("DNGAR");
|
|
tstHelper("DNGAS");
|
|
tstHelper("DNGO");
|
|
tstHelper("DNGOM");
|
|
tstHelper("DNGON");
|
|
tstHelper("DNGOR");
|
|
tstHelper("DNGOS");
|
|
tstHelper("DNGUL");
|
|
tstHelper("DO");
|
|
tstHelper("'DO");
|
|
tstHelper("DOD");
|
|
tstHelper("'DOD");
|
|
tstHelper("DOG");
|
|
tstHelper("'DOG");
|
|
tstHelper("DOGS");
|
|
tstHelper("'DOGS");
|
|
tstHelper("DO'I");
|
|
tstHelper("'DOL");
|
|
tstHelper("DOM");
|
|
tstHelper("'DOM");
|
|
tstHelper("DOMS");
|
|
tstHelper("'DOMS");
|
|
tstHelper("DON");
|
|
tstHelper("'DON");
|
|
tstHelper("DONG");
|
|
tstHelper("'DONG");
|
|
tstHelper("DOR");
|
|
tstHelper("'DOR");
|
|
tstHelper("DOS");
|
|
tstHelper("'DOS");
|
|
tstHelper("DPA");
|
|
tstHelper("DPA'");
|
|
tstHelper("DPA'AM");
|
|
tstHelper("DPA'ANG");
|
|
tstHelper("DPA'CHEN");
|
|
tstHelper("DPAD");
|
|
tstHelper("DPAG");
|
|
tstHelper("DPAGS");
|
|
tstHelper("DPA'I");
|
|
tstHelper("DPAL");
|
|
tstHelper("DPANG");
|
|
tstHelper("DPA'O");
|
|
tstHelper("DPAR");
|
|
tstHelper("DPAS");
|
|
tstHelper("DPA'SEMS");
|
|
tstHelper("DPE");
|
|
tstHelper("DPE'AM");
|
|
tstHelper("DPE'I");
|
|
tstHelper("DPEN");
|
|
tstHelper("DPER");
|
|
tstHelper("DPES");
|
|
tstHelper("DPE'U");
|
|
tstHelper("DPHYANGS");
|
|
tstHelper("DPOG");
|
|
tstHelper("DPOGS");
|
|
tstHelper("DPON");
|
|
tstHelper("DPONG");
|
|
tstHelper("DPRAL");
|
|
tstHelper("DPROG");
|
|
tstHelper("DPUD");
|
|
tstHelper("DPUL");
|
|
tstHelper("DPUNG");
|
|
tstHelper("DPYA");
|
|
tstHelper("DPYAD");
|
|
tstHelper("DPYANG");
|
|
tstHelper("DPYANGS");
|
|
tstHelper("DPYAR");
|
|
tstHelper("DPYAS");
|
|
tstHelper("DPYE");
|
|
tstHelper("DPYID");
|
|
tstHelper("DPYI'I");
|
|
tstHelper("DPYOD");
|
|
tstHelper("DPYONGS");
|
|
tstHelper("DRA");
|
|
tstHelper("'DRA");
|
|
tstHelper("'DRA'AM");
|
|
tstHelper("'DRA'ANG");
|
|
tstHelper("DRAB");
|
|
tstHelper("'DRAB");
|
|
tstHelper("DRAG");
|
|
tstHelper("'DRAG");
|
|
tstHelper("DRAGS");
|
|
tstHelper("'DRA'I");
|
|
tstHelper("DRA'I");
|
|
tstHelper("DRAL");
|
|
tstHelper("'DRAL");
|
|
tstHelper("'DRAM");
|
|
tstHelper("DRAN");
|
|
tstHelper("'DRAN");
|
|
tstHelper("DRANG");
|
|
tstHelper("'DRANG");
|
|
tstHelper("DRANGS");
|
|
tstHelper("'DRANGS");
|
|
tstHelper("'DRA'O");
|
|
tstHelper("DR'A'O");
|
|
tstHelper("DRA'O");
|
|
tstHelper("DRAR");
|
|
tstHelper("'DRAR");
|
|
tstHelper("DRAS");
|
|
tstHelper("'DRAS");
|
|
tstHelper("DRE");
|
|
tstHelper("'DRE");
|
|
tstHelper("DRED");
|
|
tstHelper("DREG");
|
|
tstHelper("'DREG");
|
|
tstHelper("DREGS");
|
|
tstHelper("'DREL");
|
|
tstHelper("'DREN");
|
|
tstHelper("'DRES");
|
|
tstHelper("DRE'U");
|
|
tstHelper("DRE'U'I");
|
|
tstHelper("DRGYAL");
|
|
tstHelper("DRGYAS");
|
|
tstHelper("DRi");
|
|
tstHelper("DRI");
|
|
tstHelper("'DRI");
|
|
tstHelper("'DRI'AM");
|
|
tstHelper("DRI'AM");
|
|
tstHelper("DRI'ANG");
|
|
tstHelper("DRIB");
|
|
tstHelper("'DRIB");
|
|
tstHelper("DRID");
|
|
tstHelper("'DRID");
|
|
tstHelper("DRI'I");
|
|
tstHelper("DRIL");
|
|
tstHelper("'DRIL");
|
|
tstHelper("DRIM");
|
|
tstHelper("'DRIM");
|
|
tstHelper("DRIN");
|
|
tstHelper("'DRIN");
|
|
tstHelper("DRING");
|
|
tstHelper("'DRING");
|
|
tstHelper("'DRI'O");
|
|
tstHelper("DRI'O");
|
|
tstHelper("DRIR");
|
|
tstHelper("'DRIR");
|
|
tstHelper("DRIS");
|
|
tstHelper("'DRIS");
|
|
tstHelper("DRI'U");
|
|
tstHelper("DRNAG");
|
|
tstHelper("DRO");
|
|
tstHelper("'DRO");
|
|
tstHelper("'DROB");
|
|
tstHelper("DROD");
|
|
tstHelper("'DROG");
|
|
tstHelper("DRO'I");
|
|
tstHelper("DROL");
|
|
tstHelper("'DROL");
|
|
tstHelper("DRON");
|
|
tstHelper("'DRON");
|
|
tstHelper("DRONGS");
|
|
tstHelper("DRO'O");
|
|
tstHelper("DROS");
|
|
tstHelper("DRU");
|
|
tstHelper("'DRU");
|
|
tstHelper("DRUB");
|
|
tstHelper("'DRUB");
|
|
tstHelper("DRUBS");
|
|
tstHelper("DRUD");
|
|
tstHelper("'DRUD");
|
|
tstHelper("DRUG");
|
|
tstHelper("DRUL");
|
|
tstHelper("'DRUL");
|
|
tstHelper("'DRUMS");
|
|
tstHelper("DRUNG");
|
|
tstHelper("'DRUNG");
|
|
tstHelper("DRUNGS");
|
|
tstHelper("DRUNS");
|
|
tstHelper("DRUS");
|
|
tstHelper("DSGO");
|
|
tstHelper("DSKYED");
|
|
tstHelper("DSKYES");
|
|
tstHelper("DSMRAS");
|
|
tstHelper("dU");
|
|
tstHelper("d'U");
|
|
tstHelper("DU");
|
|
tstHelper("'DU");
|
|
tstHelper("D'U");
|
|
tstHelper("DU'AM");
|
|
tstHelper("DU'ANG");
|
|
tstHelper("DUB");
|
|
tstHelper("'DUB");
|
|
tstHelper("DUD");
|
|
tstHelper("'DUD");
|
|
tstHelper("DUG");
|
|
tstHelper("'DUG");
|
|
tstHelper("DUGS");
|
|
tstHelper("'DUGS");
|
|
tstHelper("'DU'I");
|
|
tstHelper("DU'I");
|
|
tstHelper("DUL");
|
|
tstHelper("'DUL");
|
|
tstHelper("'DUL");
|
|
tstHelper("DUM");
|
|
tstHelper("'DUM");
|
|
tstHelper("DU-MB'A");
|
|
tstHelper("DUM-BA");
|
|
tstHelper("DUM-B'A");
|
|
tstHelper("DUMS");
|
|
tstHelper("'DUMS");
|
|
tstHelper("DUN");
|
|
tstHelper("'DUN");
|
|
tstHelper("DUNG");
|
|
tstHelper("'DUNG");
|
|
tstHelper("'DU'O");
|
|
tstHelper("DU'O");
|
|
tstHelper("DUR");
|
|
tstHelper("'DUR");
|
|
tstHelper("D'UR");
|
|
tstHelper("d'URYA");
|
|
tstHelper("d'U-RYA");
|
|
tstHelper("D'URYA");
|
|
tstHelper("D'URYA'AM");
|
|
tstHelper("d'U-RYA'I");
|
|
tstHelper("d'URYA'I");
|
|
tstHelper("D'URYA'I");
|
|
tstHelper("d'URYAR");
|
|
tstHelper("D'URYARA");
|
|
tstHelper("d'U-RYAS");
|
|
tstHelper("D'URYAS");
|
|
tstHelper("d'URY'I");
|
|
tstHelper("D'UR+Y'I");
|
|
tstHelper("DUS");
|
|
tstHelper("'DUS");
|
|
tstHelper("DVA");
|
|
tstHelper("DVAGS");
|
|
tstHelper("DVANGS");
|
|
tstHelper("DVGAS");
|
|
tstHelper("DVRI");
|
|
tstHelper("DW");
|
|
tstHelper("DWAGS");
|
|
tstHelper("DYA");
|
|
tstHelper("DY'A");
|
|
tstHelper("dYAN");
|
|
tstHelper("DYAN");
|
|
tstHelper("DYOTTA");
|
|
tstHelper("DZA");
|
|
tstHelper("DZ'A");
|
|
tstHelper("DZAB");
|
|
tstHelper("'DZAD");
|
|
tstHelper("'DZAG");
|
|
tstHelper("'DZAGS");
|
|
tstHelper("DZA'I");
|
|
tstHelper("DZAM");
|
|
tstHelper("'DZAM");
|
|
tstHelper("DZAMBHA");
|
|
tstHelper("DZAMBU");
|
|
tstHelper("DZAM-BU");
|
|
tstHelper("DZAM-BU'I");
|
|
tstHelper("DZAMBU'I");
|
|
tstHelper("'DZAM-PU");
|
|
tstHelper("DZA'O");
|
|
tstHelper("DZAR");
|
|
tstHelper("'DZAR");
|
|
tstHelper("DZAS");
|
|
tstHelper("DZE");
|
|
tstHelper("'DZEG");
|
|
tstHelper("'DZEGS");
|
|
tstHelper("'DZEM");
|
|
tstHelper("'DZER");
|
|
tstHelper("'DZES");
|
|
tstHelper("DZHA");
|
|
tstHelper("DZI");
|
|
tstHelper("'DZI");
|
|
tstHelper("DZ'I");
|
|
tstHelper("'DZI'ANG");
|
|
tstHelper("'DZIG");
|
|
tstHelper("'DZIGS");
|
|
tstHelper("'DZI'I");
|
|
tstHelper("'DZIL");
|
|
tstHelper("'DZIM");
|
|
tstHelper("DZIN");
|
|
tstHelper("'DZIN");
|
|
tstHelper("''DZIN");
|
|
tstHelper("'DZING");
|
|
tstHelper("'DZINGS");
|
|
tstHelper("'DZINM");
|
|
tstHelper("DZIR");
|
|
tstHelper("'DZIS");
|
|
tstHelper("DZM-BU'I");
|
|
tstHelper("DZMBU'I");
|
|
tstHelper("DZny'A");
|
|
tstHelper("DZNY'A");
|
|
tstHelper("DZNYO");
|
|
tstHelper("DZOGS");
|
|
tstHelper("'DZOM");
|
|
tstHelper("DZU");
|
|
tstHelper("'DZUD");
|
|
tstHelper("'DZUG");
|
|
tstHelper("'DZUGS");
|
|
tstHelper("'DZUL");
|
|
tstHelper("'DZUM");
|
|
tstHelper("'DZUMS");
|
|
tstHelper("'DZUN");
|
|
tstHelper("DZUNI");
|
|
tstHelper("'DZUR");
|
|
tstHelper("DZWA");
|
|
tstHelper("E");
|
|
tstHelper("EDANG");
|
|
tstHelper("'EN");
|
|
tstHelper("FCHOS");
|
|
tstHelper("FNYID");
|
|
tstHelper("FTOG");
|
|
tstHelper("GA");
|
|
tstHelper("'GA");
|
|
tstHelper("'GA'");
|
|
tstHelper("G'A");
|
|
tstHelper("GA'A'I");
|
|
tstHelper("GA'AM");
|
|
tstHelper("'GA'ANG");
|
|
tstHelper("GAB");
|
|
tstHelper("'GAB");
|
|
tstHelper("GAD");
|
|
tstHelper("GADH'A");
|
|
tstHelper("GADH'A'I");
|
|
tstHelper("GAG");
|
|
tstHelper("'GAG");
|
|
tstHelper("GAGS");
|
|
tstHelper("'GAGS");
|
|
tstHelper("G'A'i");
|
|
tstHelper("'GA'I");
|
|
tstHelper("G'A'I");
|
|
tstHelper("GA'I");
|
|
tstHelper("GAL");
|
|
tstHelper("'GAL");
|
|
tstHelper("GAM");
|
|
tstHelper("'GAM");
|
|
tstHelper("GAMS");
|
|
tstHelper("GAn");
|
|
tstHelper("GAN");
|
|
tstHelper("G'AN");
|
|
tstHelper("GA-NAS");
|
|
tstHelper("GAnd'A'I");
|
|
tstHelper("GAndA'I");
|
|
tstHelper("GAN-DHA");
|
|
tstHelper("GANDHI");
|
|
tstHelper("GAnd'I");
|
|
tstHelper("GAnd'I'I");
|
|
tstHelper("GAndI'I");
|
|
tstHelper("GAnd'I'O");
|
|
tstHelper("GANG");
|
|
tstHelper("GANG'A'");
|
|
tstHelper("GANGA'G'I");
|
|
tstHelper("GANG'A'I");
|
|
tstHelper("GANGC");
|
|
tstHelper("GANGGA");
|
|
tstHelper("GANG-G'A");
|
|
tstHelper("GANG-GA'");
|
|
tstHelper("GANGG'A");
|
|
tstHelper("GANG-GA'A'I");
|
|
tstHelper("GANG-GA'A'I");
|
|
tstHelper("GANG-G'A'I");
|
|
tstHelper("GANG-GA'I");
|
|
tstHelper("GANG-GA''I");
|
|
tstHelper("GANGG'A'I");
|
|
tstHelper("GANGGA''I");
|
|
tstHelper("GANGG'ARA");
|
|
tstHelper("GANG'-'I");
|
|
tstHelper("GANG-LA");
|
|
tstHelper("GANG'O");
|
|
tstHelper("GANGS");
|
|
tstHelper("GANS");
|
|
tstHelper("GA-NYIS");
|
|
tstHelper("GA'O");
|
|
tstHelper("GAR");
|
|
tstHelper("'GAR");
|
|
tstHelper("G'AR");
|
|
tstHelper("GARBHA");
|
|
tstHelper("GARBHE");
|
|
tstHelper("GAS");
|
|
tstHelper("'GAS");
|
|
tstHelper("G'AS");
|
|
tstHelper("GA-SHE");
|
|
tstHelper("GA-SHEGS");
|
|
tstHelper("GASN");
|
|
tstHelper("GASR");
|
|
tstHelper("GATZTSA");
|
|
tstHelper("GA-Y'A");
|
|
tstHelper("GA-YA'");
|
|
tstHelper("GA-YAB");
|
|
tstHelper("GA-YAG");
|
|
tstHelper("GA-Y'A'I");
|
|
tstHelper("GA-YAN");
|
|
tstHelper("GA-YANG");
|
|
tstHelper("GA-YANGS");
|
|
tstHelper("GA-YAR");
|
|
tstHelper("GA-YAS");
|
|
tstHelper("GA-YEM");
|
|
tstHelper("GA-YEN");
|
|
tstHelper("GA-YENG");
|
|
tstHelper("GA-YENGS");
|
|
tstHelper("GA-YER");
|
|
tstHelper("GA-YO");
|
|
tstHelper("GA-YOB");
|
|
tstHelper("GA-YOD");
|
|
tstHelper("GAYOG");
|
|
tstHelper("GA-YOG");
|
|
tstHelper("GA-YOGS");
|
|
tstHelper("GA-YO'I");
|
|
tstHelper("GAYON");
|
|
tstHelper("GA-YON");
|
|
tstHelper("GA-YO'O");
|
|
tstHelper("GAYOS");
|
|
tstHelper("GA-YOS");
|
|
tstHelper("GA-YUL");
|
|
tstHelper("GA-YUNG");
|
|
tstHelper("GA-YUR");
|
|
tstHelper("GBA");
|
|
tstHelper("'GBOR");
|
|
tstHelper("GBRAL");
|
|
tstHelper("GBYA'O");
|
|
tstHelper("GBYED");
|
|
tstHelper("GCAD");
|
|
tstHelper("GCAG");
|
|
tstHelper("GCAGS");
|
|
tstHelper("GCAL");
|
|
tstHelper("GCAM");
|
|
tstHelper("GCAN");
|
|
tstHelper("GCE");
|
|
tstHelper("GCEN");
|
|
tstHelper("GCER");
|
|
tstHelper("GCES");
|
|
tstHelper("GCI");
|
|
tstHelper("GCI'AM");
|
|
tstHelper("GCIG");
|
|
tstHelper("GCIN");
|
|
tstHelper("GCINGS");
|
|
tstHelper("GCIR");
|
|
tstHelper("GCIS");
|
|
tstHelper("GCIT");
|
|
tstHelper("GCOD");
|
|
tstHelper("GCOD");
|
|
tstHelper("GCOG");
|
|
tstHelper("GCOM");
|
|
tstHelper("GCONG");
|
|
tstHelper("GCOR");
|
|
tstHelper("GCOS");
|
|
tstHelper("GCU");
|
|
tstHelper("GCUG");
|
|
tstHelper("GCUGS");
|
|
tstHelper("GCUNG");
|
|
tstHelper("GCUS");
|
|
tstHelper("GDA'");
|
|
tstHelper("GDAB");
|
|
tstHelper("GDAG");
|
|
tstHelper("GDAGS");
|
|
tstHelper("GDA'I");
|
|
tstHelper("GDAMS");
|
|
tstHelper("GDAN");
|
|
tstHelper("GDANG");
|
|
tstHelper("GDANGS");
|
|
tstHelper("GDA'O");
|
|
tstHelper("GDAR");
|
|
tstHelper("GDEG");
|
|
tstHelper("GDENG");
|
|
tstHelper("GDENGS");
|
|
tstHelper("GDH'A");
|
|
tstHelper("GDING");
|
|
tstHelper("GDO");
|
|
tstHelper("GDOD");
|
|
tstHelper("GDOL");
|
|
tstHelper("GDON");
|
|
tstHelper("GDONG");
|
|
tstHelper("GDOS");
|
|
tstHelper("GDRA");
|
|
tstHelper("GDU");
|
|
tstHelper("GDUB");
|
|
tstHelper("GDUD");
|
|
tstHelper("GDUG");
|
|
tstHelper("GDUGS");
|
|
tstHelper("GDUL");
|
|
tstHelper("GDUM");
|
|
tstHelper("GDUNG");
|
|
tstHelper("GDUNGS");
|
|
tstHelper("GDUS");
|
|
tstHelper("GE");
|
|
tstHelper("'GE");
|
|
tstHelper("GE'AM");
|
|
tstHelper("'GEBS");
|
|
tstHelper("'GED");
|
|
tstHelper("'GEG");
|
|
tstHelper("GEGS");
|
|
tstHelper("'GEGS");
|
|
tstHelper("GE'I");
|
|
tstHelper("GEL");
|
|
tstHelper("'GEL");
|
|
tstHelper("GEN");
|
|
tstHelper("'GENG");
|
|
tstHelper("'GENGS");
|
|
tstHelper("GE'O");
|
|
tstHelper("GER");
|
|
tstHelper("GES");
|
|
tstHelper("GGI");
|
|
tstHelper("GHA");
|
|
tstHelper("GH'A");
|
|
tstHelper("GHA'I");
|
|
tstHelper("GHEGS");
|
|
tstHelper("GHI");
|
|
tstHelper("GHI'I");
|
|
tstHelper("GHO");
|
|
tstHelper("GHOsh");
|
|
tstHelper("GI");
|
|
tstHelper("'GI");
|
|
tstHelper("GI'AM");
|
|
tstHelper("GI'ANG");
|
|
tstHelper("GID");
|
|
tstHelper("GIG");
|
|
tstHelper("GI'I");
|
|
tstHelper("GIIS");
|
|
tstHelper("GIM");
|
|
tstHelper("GING");
|
|
tstHelper("GI'O");
|
|
tstHelper("GIR");
|
|
tstHelper("GiS");
|
|
tstHelper("GIS");
|
|
tstHelper("'GIS");
|
|
tstHelper("GLA");
|
|
tstHelper("GLAD");
|
|
tstHelper("GLAG");
|
|
tstHelper("GLAGS");
|
|
tstHelper("GLAL");
|
|
tstHelper("GLAN");
|
|
tstHelper("GLANG");
|
|
tstHelper("GLAS");
|
|
tstHelper("GLDAN");
|
|
tstHelper("GLE");
|
|
tstHelper("GLEGS");
|
|
tstHelper("GLEN");
|
|
tstHelper("GLENG");
|
|
tstHelper("GLENGS");
|
|
tstHelper("GLI");
|
|
tstHelper("GLING");
|
|
tstHelper("GLO");
|
|
tstHelper("GLOB");
|
|
tstHelper("GLOG");
|
|
tstHelper("GLOGS");
|
|
tstHelper("GLO'I");
|
|
tstHelper("GLON");
|
|
tstHelper("GLONG");
|
|
tstHelper("GLONGS");
|
|
tstHelper("GLOR");
|
|
tstHelper("GLOS");
|
|
tstHelper("GLTUNG");
|
|
tstHelper("GLU");
|
|
tstHelper("GLUGS");
|
|
tstHelper("GLU'I");
|
|
tstHelper("GLUN");
|
|
tstHelper("GLUNG");
|
|
tstHelper("GMU");
|
|
tstHelper("GNA");
|
|
tstHelper("GNA'");
|
|
tstHelper("GNAD");
|
|
tstHelper("GNAG");
|
|
tstHelper("GNAM");
|
|
tstHelper("GNAN");
|
|
tstHelper("GNANG");
|
|
tstHelper("GNANGS");
|
|
tstHelper("GNAS");
|
|
tstHelper("Gnd'I");
|
|
tstHelper("GNGA");
|
|
tstHelper("GNGAN");
|
|
tstHelper("GNGAS");
|
|
tstHelper("GNGOL");
|
|
tstHelper("GNI");
|
|
tstHelper("GNOD");
|
|
tstHelper("GNON");
|
|
tstHelper("GNONG");
|
|
tstHelper("GNOS");
|
|
tstHelper("GNUBS");
|
|
tstHelper("GNYA'");
|
|
tstHelper("GNYAG");
|
|
tstHelper("GNYAN");
|
|
tstHelper("GNYAR");
|
|
tstHelper("GNYE");
|
|
tstHelper("GNYED");
|
|
tstHelper("GNYEN");
|
|
tstHelper("GNYER");
|
|
tstHelper("GNYES");
|
|
tstHelper("GNYE'U");
|
|
tstHelper("GNYI");
|
|
tstHelper("GNYID");
|
|
tstHelper("GNYIG");
|
|
tstHelper("GNYIGS");
|
|
tstHelper("GNYIR");
|
|
tstHelper("GNYIS");
|
|
tstHelper("GNYOD");
|
|
tstHelper("GNYOS");
|
|
tstHelper("GNYUG");
|
|
tstHelper("Go");
|
|
tstHelper("GO");
|
|
tstHelper("'GO");
|
|
tstHelper("GOD");
|
|
tstHelper("'GOD");
|
|
tstHelper("GODN");
|
|
tstHelper("GOG");
|
|
tstHelper("'GOG");
|
|
tstHelper("GOGS");
|
|
tstHelper("'GOGS");
|
|
tstHelper("GO'I");
|
|
tstHelper("GOL");
|
|
tstHelper("GOM");
|
|
tstHelper("GOMS");
|
|
tstHelper("GON");
|
|
tstHelper("'GON");
|
|
tstHelper("GONG");
|
|
tstHelper("'GONG");
|
|
tstHelper("GOO");
|
|
tstHelper("GOO");
|
|
tstHelper("GO'O");
|
|
tstHelper("GOR");
|
|
tstHelper("GOS");
|
|
tstHelper("'GOS");
|
|
tstHelper("GOshU");
|
|
tstHelper("GO'U");
|
|
tstHelper("GO'U");
|
|
tstHelper("GPAR");
|
|
tstHelper("GPHYIN");
|
|
tstHelper("GPOM");
|
|
tstHelper("GPU");
|
|
tstHelper("GRA");
|
|
tstHelper("GRAD");
|
|
tstHelper("GRAG");
|
|
tstHelper("GRAGS");
|
|
tstHelper("GRA'I");
|
|
tstHelper("GRAL");
|
|
tstHelper("'GRAL");
|
|
tstHelper("'GRAM");
|
|
tstHelper("GRAMS");
|
|
tstHelper("'GRAN");
|
|
tstHelper("GRANG");
|
|
tstHelper("'GRANG");
|
|
tstHelper("GRANGS");
|
|
tstHelper("'GRANGS");
|
|
tstHelper("GRAR");
|
|
tstHelper("GRAS");
|
|
tstHelper("'GRAS");
|
|
tstHelper("GRE");
|
|
tstHelper("'GRE");
|
|
tstHelper("GRED");
|
|
tstHelper("'GRED");
|
|
tstHelper("GREGS");
|
|
tstHelper("'GREL");
|
|
tstHelper("'GREMS");
|
|
tstHelper("'GRENG");
|
|
tstHelper("GRES");
|
|
tstHelper("'GRES");
|
|
tstHelper("GRE'U");
|
|
tstHelper("GRE'U'I");
|
|
tstHelper("GRi");
|
|
tstHelper("GR'i");
|
|
tstHelper("GRI");
|
|
tstHelper("'GRI");
|
|
tstHelper("GRIB");
|
|
tstHelper("'GRIB");
|
|
tstHelper("'GRIBS");
|
|
tstHelper("'GRIG");
|
|
tstHelper("GRI'I");
|
|
tstHelper("GRIL");
|
|
tstHelper("'GRIL");
|
|
tstHelper("'GRIM");
|
|
tstHelper("GRIMS");
|
|
tstHelper("'GRIN");
|
|
tstHelper("GRI'O");
|
|
tstHelper("GRIS");
|
|
tstHelper("GRNAGS");
|
|
tstHelper("GRO");
|
|
tstHelper("'GRO");
|
|
tstHelper("'GRO'AM");
|
|
tstHelper("'GRO'ANG");
|
|
tstHelper("'GROB");
|
|
tstHelper("GROD");
|
|
tstHelper("GRODHA");
|
|
tstHelper("GROG");
|
|
tstHelper("'GROG");
|
|
tstHelper("GROGS");
|
|
tstHelper("'GROGS");
|
|
tstHelper("'GRO'I");
|
|
tstHelper("GRO'I");
|
|
tstHelper("GROL");
|
|
tstHelper("'GROL");
|
|
tstHelper("GROM");
|
|
tstHelper("'GROM");
|
|
tstHelper("'GRON");
|
|
tstHelper("GRONG");
|
|
tstHelper("GRONGS");
|
|
tstHelper("'GRONGS");
|
|
tstHelper("'GRO'O");
|
|
tstHelper("GRO'O");
|
|
tstHelper("GROR");
|
|
tstHelper("'GROR");
|
|
tstHelper("GROS");
|
|
tstHelper("'GROS");
|
|
tstHelper("GRU");
|
|
tstHelper("'GRU");
|
|
tstHelper("GRUB");
|
|
tstHelper("'GRUB");
|
|
tstHelper("GRUG");
|
|
tstHelper("'GRUG");
|
|
tstHelper("GRUGS");
|
|
tstHelper("GRU'I");
|
|
tstHelper("GRUL");
|
|
tstHelper("GRUM");
|
|
tstHelper("'GRUM");
|
|
tstHelper("'GRUMS");
|
|
tstHelper("GRUNG");
|
|
tstHelper("GRUR");
|
|
tstHelper("GRUS");
|
|
tstHelper("'GRUS");
|
|
tstHelper("GRVA");
|
|
tstHelper("GRVA'I");
|
|
tstHelper("GRVAR");
|
|
tstHelper("GRWA");
|
|
tstHelper("GRWAR");
|
|
tstHelper("GR-WAR");
|
|
tstHelper("GSAB");
|
|
tstHelper("GSAD");
|
|
tstHelper("GSAG");
|
|
tstHelper("GSAL");
|
|
tstHelper("GSAM");
|
|
tstHelper("GSAN");
|
|
tstHelper("GSANG");
|
|
tstHelper("GSAR");
|
|
tstHelper("GSE");
|
|
tstHelper("GSEB");
|
|
tstHelper("GSEG");
|
|
tstHelper("GSEGS");
|
|
tstHelper("GSER");
|
|
tstHelper("GSES");
|
|
tstHelper("GSHA'");
|
|
tstHelper("GSHAD");
|
|
tstHelper("GSHAG");
|
|
tstHelper("GSHAGS");
|
|
tstHelper("GSHAM");
|
|
tstHelper("GSHAN");
|
|
tstHelper("GSHANG");
|
|
tstHelper("GSHE");
|
|
tstHelper("GSHED");
|
|
tstHelper("GSHEG");
|
|
tstHelper("GSHEGS");
|
|
tstHelper("GSHENG");
|
|
tstHelper("GSHER");
|
|
tstHelper("GSHES");
|
|
tstHelper("GSHI");
|
|
tstHelper("GSHIB");
|
|
tstHelper("GSHIBS");
|
|
tstHelper("GSHIGS");
|
|
tstHelper("GSHIN");
|
|
tstHelper("GSHIS");
|
|
tstHelper("GSHOG");
|
|
tstHelper("GSHOGS");
|
|
tstHelper("GSHOL");
|
|
tstHelper("GSHON");
|
|
tstHelper("GSHONG");
|
|
tstHelper("GSHOR");
|
|
tstHelper("GSHOS");
|
|
tstHelper("GSHUB");
|
|
tstHelper("GSHUBS");
|
|
tstHelper("GSHUL");
|
|
tstHelper("GSI");
|
|
tstHelper("GSIG");
|
|
tstHelper("GSIL");
|
|
tstHelper("GSING");
|
|
tstHelper("GSO");
|
|
tstHelper("GSOB");
|
|
tstHelper("GSOD");
|
|
tstHelper("GSOG");
|
|
tstHelper("GSO'I");
|
|
tstHelper("GSOL");
|
|
tstHelper("GSON");
|
|
tstHelper("GSONG");
|
|
tstHelper("GSO'O");
|
|
tstHelper("GSOR");
|
|
tstHelper("GSOS");
|
|
tstHelper("GSU");
|
|
tstHelper("GSUD");
|
|
tstHelper("GSUG");
|
|
tstHelper("GSUGS");
|
|
tstHelper("GSUm");
|
|
tstHelper("GSUM");
|
|
tstHelper("GSUNG");
|
|
tstHelper("GSUNGS");
|
|
tstHelper("GSUR");
|
|
tstHelper("GSUS");
|
|
tstHelper("GTA");
|
|
tstHelper("GTA'");
|
|
tstHelper("GTAD");
|
|
tstHelper("GTAG");
|
|
tstHelper("GTAGS");
|
|
tstHelper("GTAL");
|
|
tstHelper("GTAM");
|
|
tstHelper("GTAMS");
|
|
tstHelper("GTAN");
|
|
tstHelper("GTANG");
|
|
tstHelper("GTAR");
|
|
tstHelper("GTE");
|
|
tstHelper("GTEGS");
|
|
tstHelper("GTER");
|
|
tstHelper("GTE'U");
|
|
tstHelper("GTI");
|
|
tstHelper("GTIBS");
|
|
tstHelper("GTIG");
|
|
tstHelper("GTING");
|
|
tstHelper("GTO");
|
|
tstHelper("GTOD");
|
|
tstHelper("GTOG");
|
|
tstHelper("GTOGS");
|
|
tstHelper("GTOL");
|
|
tstHelper("GTONG");
|
|
tstHelper("GTONGS");
|
|
tstHelper("GTOR");
|
|
tstHelper("GTOS");
|
|
tstHelper("GTRAN");
|
|
tstHelper("GTSO");
|
|
tstHelper("GTSUL");
|
|
tstHelper("GTUB");
|
|
tstHelper("GTUBS");
|
|
tstHelper("GTUG");
|
|
tstHelper("GTUGS");
|
|
tstHelper("GTUM");
|
|
tstHelper("GTUN");
|
|
tstHelper("GTUNGS");
|
|
tstHelper("GTUR");
|
|
tstHelper("GTZA'");
|
|
tstHelper("GTZAD");
|
|
tstHelper("GTZAGS");
|
|
tstHelper("GTZANG");
|
|
tstHelper("GTZE");
|
|
tstHelper("GTZES");
|
|
tstHelper("GTZIGS");
|
|
tstHelper("GTZO");
|
|
tstHelper("GTZOR");
|
|
tstHelper("GTZOS");
|
|
tstHelper("GTZUB");
|
|
tstHelper("GTZUBS");
|
|
tstHelper("GTZUG");
|
|
tstHelper("GTZUGS");
|
|
tstHelper("GTZUN");
|
|
tstHelper("GU");
|
|
tstHelper("'GU");
|
|
tstHelper("GUBTA");
|
|
tstHelper("GUD");
|
|
tstHelper("GU'I");
|
|
tstHelper("GUL");
|
|
tstHelper("'GUL");
|
|
tstHelper("GUM");
|
|
tstHelper("'GUM");
|
|
tstHelper("'GUMS");
|
|
tstHelper("GUNG");
|
|
tstHelper("GUPTA");
|
|
tstHelper("GUPTA'I");
|
|
tstHelper("GUPTAS");
|
|
tstHelper("GUR");
|
|
tstHelper("'GUR");
|
|
tstHelper("GUS");
|
|
tstHelper("GY");
|
|
tstHelper("GYA");
|
|
tstHelper("G-YAB");
|
|
tstHelper("G-YABS");
|
|
tstHelper("GYAD");
|
|
tstHelper("G-YAG");
|
|
tstHelper("GYAL");
|
|
tstHelper("G-YAN");
|
|
tstHelper("GYANG");
|
|
tstHelper("G-YANG");
|
|
tstHelper("'GYANGS");
|
|
tstHelper("G-YANGS");
|
|
tstHelper("G-YA'O");
|
|
tstHelper("GYAR");
|
|
tstHelper("G-YAR");
|
|
tstHelper("GYAS");
|
|
tstHelper("G-YAS");
|
|
tstHelper("GYE");
|
|
tstHelper("GYED");
|
|
tstHelper("'GYED");
|
|
tstHelper("GYEL");
|
|
tstHelper("'GYEL");
|
|
tstHelper("G-YEL");
|
|
tstHelper("GYEM");
|
|
tstHelper("G-YEM");
|
|
tstHelper("GYEN");
|
|
tstHelper("G-YEN");
|
|
tstHelper("GYENG");
|
|
tstHelper("G-YENG");
|
|
tstHelper("GYENGS");
|
|
tstHelper("G-YENGS");
|
|
tstHelper("GYER");
|
|
tstHelper("G-YER");
|
|
tstHelper("GYES");
|
|
tstHelper("'GYES");
|
|
tstHelper("GYI");
|
|
tstHelper("'GYI");
|
|
tstHelper("GYI'AM");
|
|
tstHelper("GYI'ANG");
|
|
tstHelper("GYID");
|
|
tstHelper("'GYID");
|
|
tstHelper("'GYIL");
|
|
tstHelper("GYIM");
|
|
tstHelper("GYIN");
|
|
tstHelper("'GYING");
|
|
tstHelper("GYI'O");
|
|
tstHelper("GYIR");
|
|
tstHelper("GYIS");
|
|
tstHelper("'GYIS");
|
|
tstHelper("GYO");
|
|
tstHelper("'GYO");
|
|
tstHelper("G-YO");
|
|
tstHelper("G-YO'AM");
|
|
tstHelper("G-YOB");
|
|
tstHelper("GYOD");
|
|
tstHelper("'GYOD");
|
|
tstHelper("GYOG");
|
|
tstHelper("G-YOG");
|
|
tstHelper("GYOGS");
|
|
tstHelper("G-YOGS");
|
|
tstHelper("G-YO'I");
|
|
tstHelper("GYOL");
|
|
tstHelper("GYON");
|
|
tstHelper("G-YON");
|
|
tstHelper("GYONG");
|
|
tstHelper("G-YO'O");
|
|
tstHelper("'GYOR");
|
|
tstHelper("G-YOR");
|
|
tstHelper("GYOS");
|
|
tstHelper("G-YOS");
|
|
tstHelper("GYU");
|
|
tstHelper("'GYU");
|
|
tstHelper("GYU'AM");
|
|
tstHelper("GYUAR");
|
|
tstHelper("GYUB");
|
|
tstHelper("GYUL");
|
|
tstHelper("G-YUL");
|
|
tstHelper("GYUNG");
|
|
tstHelper("'GYUNG");
|
|
tstHelper("G-YUNG");
|
|
tstHelper("GYUR");
|
|
tstHelper("'GYUR");
|
|
tstHelper("G-YUR");
|
|
tstHelper("'GYURBDUD");
|
|
tstHelper("'GYURS");
|
|
tstHelper("GYUS");
|
|
tstHelper("GZA'");
|
|
tstHelper("GZABS");
|
|
tstHelper("GZAGS");
|
|
tstHelper("GZA'I");
|
|
tstHelper("GZAL");
|
|
tstHelper("GZAN");
|
|
tstHelper("GZANG");
|
|
tstHelper("GZANGS");
|
|
tstHelper("GZAR");
|
|
tstHelper("GZAS");
|
|
tstHelper("GZEB");
|
|
tstHelper("GZEG");
|
|
tstHelper("GZEGS");
|
|
tstHelper("GZEM");
|
|
tstHelper("GZENGS");
|
|
tstHelper("GZER");
|
|
tstHelper("GZHA");
|
|
tstHelper("GZHAG");
|
|
tstHelper("GZHA'I");
|
|
tstHelper("GZHAL");
|
|
tstHelper("GZHAN");
|
|
tstHelper("GZHANG");
|
|
tstHelper("GZHAR");
|
|
tstHelper("GZHEN");
|
|
tstHelper("GZHES");
|
|
tstHelper("GZHI");
|
|
tstHelper("GZHI'AM");
|
|
tstHelper("GZHI'ANG");
|
|
tstHelper("GZHIB");
|
|
tstHelper("GZHIG");
|
|
tstHelper("GZHIGS");
|
|
tstHelper("GZHI'I");
|
|
tstHelper("GZHIL");
|
|
tstHelper("GZHIN");
|
|
tstHelper("GZHING");
|
|
tstHelper("GZHI'O");
|
|
tstHelper("GZHIR");
|
|
tstHelper("GZHIS");
|
|
tstHelper("GZHOD");
|
|
tstHelper("GZHOG");
|
|
tstHelper("GZHOGS");
|
|
tstHelper("GZHOL");
|
|
tstHelper("GZHOM");
|
|
tstHelper("GZHON");
|
|
tstHelper("GZHONG");
|
|
tstHelper("GZHOR");
|
|
tstHelper("GZHU");
|
|
tstHelper("GZHUG");
|
|
tstHelper("GZHUGS");
|
|
tstHelper("GZHU'I");
|
|
tstHelper("GZHUNG");
|
|
tstHelper("GZHUNGS");
|
|
tstHelper("GZHU'O");
|
|
tstHelper("GZHUS");
|
|
tstHelper("GZI");
|
|
tstHelper("GZIG");
|
|
tstHelper("GZIGS");
|
|
tstHelper("GZI'I");
|
|
tstHelper("GZIL");
|
|
tstHelper("GZIM");
|
|
tstHelper("GZIMS");
|
|
tstHelper("GZIN");
|
|
tstHelper("GZINGS");
|
|
tstHelper("GZIR");
|
|
tstHelper("GZIS");
|
|
tstHelper("GZO");
|
|
tstHelper("GZOB");
|
|
tstHelper("GZOD");
|
|
tstHelper("GZOL");
|
|
tstHelper("GZOM");
|
|
tstHelper("GZON");
|
|
tstHelper("GZONG");
|
|
tstHelper("GZO'O");
|
|
tstHelper("GZOS");
|
|
tstHelper("GZU");
|
|
tstHelper("GZUD");
|
|
tstHelper("GZUG");
|
|
tstHelper("GZUGS");
|
|
tstHelper("GZUGSSDUG");
|
|
tstHelper("GZU'I");
|
|
tstHelper("GZUNG");
|
|
tstHelper("GZUNGS");
|
|
tstHelper("GZUR");
|
|
tstHelper("H");
|
|
tstHelper("h'A");
|
|
tstHelper("HA");
|
|
tstHelper("H'A");
|
|
tstHelper("HAB");
|
|
tstHelper("HA'I");
|
|
tstHelper("HANG");
|
|
tstHelper("HAS");
|
|
tstHelper("HE");
|
|
tstHelper("HE'I");
|
|
tstHelper("HERE");
|
|
tstHelper("HES");
|
|
tstHelper("HI");
|
|
tstHelper("H'I");
|
|
tstHelper("HLAGS");
|
|
tstHelper("HM'A");
|
|
tstHelper("HME");
|
|
tstHelper("HOR");
|
|
tstHelper("'HOR");
|
|
tstHelper("HRAL");
|
|
tstHelper("HRI");
|
|
tstHelper("HRUD");
|
|
tstHelper("HU");
|
|
tstHelper("HUD");
|
|
tstHelper("HUL");
|
|
tstHelper("HUNG");
|
|
tstHelper("HUR");
|
|
tstHelper("HVA");
|
|
tstHelper("HVAGS");
|
|
tstHelper("HVI");
|
|
tstHelper("HYA");
|
|
tstHelper("HYIN");
|
|
tstHelper("I");
|
|
tstHelper("'I");
|
|
tstHelper("II");
|
|
tstHelper("IYIS");
|
|
tstHelper("JA");
|
|
tstHelper("'JA'");
|
|
tstHelper("'JAB");
|
|
tstHelper("'JAG");
|
|
tstHelper("'JA'I");
|
|
tstHelper("'JAL");
|
|
tstHelper("JAM");
|
|
tstHelper("'JAM");
|
|
tstHelper("'JAMS");
|
|
tstHelper("'JAR");
|
|
tstHelper("'JAS");
|
|
tstHelper("JE");
|
|
tstHelper("'JEBS");
|
|
tstHelper("'JED");
|
|
tstHelper("'JEGS");
|
|
tstHelper("'JEN");
|
|
tstHelper("JI");
|
|
tstHelper("'JI");
|
|
tstHelper("JIG");
|
|
tstHelper("'JIG");
|
|
tstHelper("'JIGS");
|
|
tstHelper("JI'I");
|
|
tstHelper("'JIL");
|
|
tstHelper("'JIM");
|
|
tstHelper("'JIN");
|
|
tstHelper("JING");
|
|
tstHelper("'JING");
|
|
tstHelper("JO");
|
|
tstHelper("'JO");
|
|
tstHelper("'JOG");
|
|
tstHelper("'JOGS");
|
|
tstHelper("JO'I");
|
|
tstHelper("'JOL");
|
|
tstHelper("'JOM");
|
|
tstHelper("'JOMS");
|
|
tstHelper("'JONG");
|
|
tstHelper("'JOS");
|
|
tstHelper("JPAR");
|
|
tstHelper("'JU");
|
|
tstHelper("'JUD");
|
|
tstHelper("JUG");
|
|
tstHelper("'JUG");
|
|
tstHelper("'JUGS");
|
|
tstHelper("'JU'I");
|
|
tstHelper("'JUM");
|
|
tstHelper("'JUN");
|
|
tstHelper("JUNG");
|
|
tstHelper("'JUNGS");
|
|
tstHelper("'JU'O");
|
|
tstHelper("'JUR");
|
|
tstHelper("'JUS");
|
|
tstHelper("JYI");
|
|
tstHelper("KA");
|
|
tstHelper("K'A");
|
|
tstHelper("KA'");
|
|
tstHelper("KA'AM");
|
|
tstHelper("KA'ANG");
|
|
tstHelper("'KAB");
|
|
tstHelper("KABS");
|
|
tstHelper("KAD");
|
|
tstHelper("K'A'E");
|
|
tstHelper("K'A'I");
|
|
tstHelper("KA'I");
|
|
tstHelper("KAL");
|
|
tstHelper("KAm");
|
|
tstHelper("KAM");
|
|
tstHelper("KAN");
|
|
tstHelper("KANG");
|
|
tstHelper("KAnthA'I");
|
|
tstHelper("KA'O");
|
|
tstHelper("KAR");
|
|
tstHelper("K'AR");
|
|
tstHelper("KARA");
|
|
tstHelper("K'ARA");
|
|
tstHelper("KARMA");
|
|
tstHelper("KARnA");
|
|
tstHelper("K'ARsh'A");
|
|
tstHelper("KAS");
|
|
tstHelper("K'AS");
|
|
tstHelper("KATYA'I");
|
|
tstHelper("KD");
|
|
tstHelper("KE");
|
|
tstHelper("KENG");
|
|
tstHelper("KER");
|
|
tstHelper("KE'U");
|
|
tstHelper("KHA");
|
|
tstHelper("KH'A");
|
|
tstHelper("KHA'");
|
|
tstHelper("KHA'AM");
|
|
tstHelper("KHAB");
|
|
tstHelper("'KHAB");
|
|
tstHelper("KHAD");
|
|
tstHelper("KHAG");
|
|
tstHelper("KHA'I");
|
|
tstHelper("KHAL");
|
|
tstHelper("'KHAL");
|
|
tstHelper("KHAM");
|
|
tstHelper("KHAMS");
|
|
tstHelper("KHAn");
|
|
tstHelper("KHAN");
|
|
tstHelper("KHAnad");
|
|
tstHelper("KHAndA");
|
|
tstHelper("KHANG");
|
|
tstHelper("'KHANG");
|
|
tstHelper("'KHANGS");
|
|
tstHelper("KHAR");
|
|
tstHelper("'KHAR");
|
|
tstHelper("KHAS");
|
|
tstHelper("KHE");
|
|
tstHelper("KHEBS");
|
|
tstHelper("KHENGS");
|
|
tstHelper("KHE'U");
|
|
tstHelper("KHIMS");
|
|
tstHelper("KHING");
|
|
tstHelper("KHO");
|
|
tstHelper("'KHO");
|
|
tstHelper("KHOB");
|
|
tstHelper("'KHOB");
|
|
tstHelper("KHOD");
|
|
tstHelper("'KHOD");
|
|
tstHelper("KHOG");
|
|
tstHelper("'KHOGS");
|
|
tstHelper("KHO'I");
|
|
tstHelper("KHOL");
|
|
tstHelper("'KHOL");
|
|
tstHelper("KHOM");
|
|
tstHelper("KHON");
|
|
tstHelper("'KHON");
|
|
tstHelper("KHONG");
|
|
tstHelper("'KHONG");
|
|
tstHelper("KHONGS");
|
|
tstHelper("KHOR");
|
|
tstHelper("'KHOR");
|
|
tstHelper("KHRA");
|
|
tstHelper("'KHRA");
|
|
tstHelper("KHRAB");
|
|
tstHelper("'KHRAB");
|
|
tstHelper("KHRAG");
|
|
tstHelper("KHRAGS");
|
|
tstHelper("KHRA'I");
|
|
tstHelper("KHRA'ING");
|
|
tstHelper("KHRAL");
|
|
tstHelper("'KHRAL");
|
|
tstHelper("KHRAM");
|
|
tstHelper("KHRAS");
|
|
tstHelper("'KHRAS");
|
|
tstHelper("KHRE");
|
|
tstHelper("'KHRE");
|
|
tstHelper("KHREG");
|
|
tstHelper("KHREL");
|
|
tstHelper("'KHREN");
|
|
tstHelper("KHRE'U");
|
|
tstHelper("KHRI");
|
|
tstHelper("'KHRI");
|
|
tstHelper("KHRI'AM");
|
|
tstHelper("KHRI'ANG");
|
|
tstHelper("KHRID");
|
|
tstHelper("'KHRID");
|
|
tstHelper("KHRIG");
|
|
tstHelper("'KHRIG");
|
|
tstHelper("'KHRIGS");
|
|
tstHelper("KHRI'I");
|
|
tstHelper("KHRIL");
|
|
tstHelper("'KHRIL");
|
|
tstHelper("KHRIMS");
|
|
tstHelper("'KHRIMS");
|
|
tstHelper("'KHRI'O");
|
|
tstHelper("KHRIR");
|
|
tstHelper("KHRIS");
|
|
tstHelper("'KHRIS");
|
|
tstHelper("KHRI'U");
|
|
tstHelper("KHRI'U'AM");
|
|
tstHelper("KHRI'U'I");
|
|
tstHelper("KHRI'UR");
|
|
tstHelper("KHRO");
|
|
tstHelper("KHROD");
|
|
tstHelper("KHRO'I");
|
|
tstHelper("KHROL");
|
|
tstHelper("'KHROL");
|
|
tstHelper("KHROM");
|
|
tstHelper("KHROMS");
|
|
tstHelper("KHRON");
|
|
tstHelper("KHRONG");
|
|
tstHelper("KHROR");
|
|
tstHelper("KHROS");
|
|
tstHelper("KHRU");
|
|
tstHelper("'KHRU");
|
|
tstHelper("'KHRU'AM");
|
|
tstHelper("'KHRUB");
|
|
tstHelper("KHRUD");
|
|
tstHelper("KHRUG");
|
|
tstHelper("'KHRUG");
|
|
tstHelper("'KHRUGS");
|
|
tstHelper("KHRU'I");
|
|
tstHelper("'KHRUL");
|
|
tstHelper("KHRUMS");
|
|
tstHelper("KHRUN");
|
|
tstHelper("KHRUNG");
|
|
tstHelper("KHRUNGS");
|
|
tstHelper("'KHRUNGS");
|
|
tstHelper("'KHRUR");
|
|
tstHelper("KHRUS");
|
|
tstHelper("'KHRUS");
|
|
tstHelper("KHU");
|
|
tstHelper("'KHU");
|
|
tstHelper("KHU'AM");
|
|
tstHelper("KHU'ANG");
|
|
tstHelper("KHUD");
|
|
tstHelper("KHUG");
|
|
tstHelper("KHUGS");
|
|
tstHelper("'KHUGS");
|
|
tstHelper("KHU'I");
|
|
tstHelper("KHUM");
|
|
tstHelper("KHUMS");
|
|
tstHelper("'KHUMS");
|
|
tstHelper("KHUN");
|
|
tstHelper("'KHUN");
|
|
tstHelper("KHUNG");
|
|
tstHelper("KHUNGS");
|
|
tstHelper("KHU'O");
|
|
tstHelper("KHUR");
|
|
tstHelper("KHUS");
|
|
tstHelper("'KHUS");
|
|
tstHelper("KHVA");
|
|
tstHelper("KHVA'AM");
|
|
tstHelper("KHVA'I");
|
|
tstHelper("KHVAS");
|
|
tstHelper("KHWA");
|
|
tstHelper("KHYAB");
|
|
tstHelper("KHYAD");
|
|
tstHelper("'KHYAG");
|
|
tstHelper("KHYAM");
|
|
tstHelper("'KHYAM");
|
|
tstHelper("KHYAMS");
|
|
tstHelper("'KHYAMS");
|
|
tstHelper("KHYAR");
|
|
tstHelper("KHYE");
|
|
tstHelper("KHYE'AU");
|
|
tstHelper("KHYED");
|
|
tstHelper("KHYEN");
|
|
tstHelper("'KHYEN");
|
|
tstHelper("KHYER");
|
|
tstHelper("'KHYER");
|
|
tstHelper("KHYES");
|
|
tstHelper("KHYE'U");
|
|
tstHelper("KHYE'U'AM");
|
|
tstHelper("KHYE'U'I");
|
|
tstHelper("KHYE'U'O");
|
|
tstHelper("KHYE'UR");
|
|
tstHelper("KHYE'US");
|
|
tstHelper("KHYI");
|
|
tstHelper("KHYI'AM");
|
|
tstHelper("KHYID");
|
|
tstHelper("KHYIG");
|
|
tstHelper("KHYI'I");
|
|
tstHelper("'KHYIL");
|
|
tstHelper("KHYIM");
|
|
tstHelper("KHYIMS");
|
|
tstHelper("KHYIR");
|
|
tstHelper("KHYI'U");
|
|
tstHelper("KHYO");
|
|
tstHelper("KHYOD");
|
|
tstHelper("KHYOGS");
|
|
tstHelper("KHYOL");
|
|
tstHelper("KHYON");
|
|
tstHelper("KHYONG");
|
|
tstHelper("KHYOR");
|
|
tstHelper("'KHYOR");
|
|
tstHelper("KHYOS");
|
|
tstHelper("KHYU");
|
|
tstHelper("KHYUD");
|
|
tstHelper("'KHYUD");
|
|
tstHelper("KHYU'I");
|
|
tstHelper("KHYUNG");
|
|
tstHelper("KHYUR");
|
|
tstHelper("KHYUS");
|
|
tstHelper("KI");
|
|
tstHelper("K'I");
|
|
tstHelper("KI'AM");
|
|
tstHelper("K'I'I");
|
|
tstHelper("KI'I");
|
|
tstHelper("KIM");
|
|
tstHelper("KI-MPA");
|
|
tstHelper("KIM-PA");
|
|
tstHelper("KIRTI");
|
|
tstHelper("K'IRTI");
|
|
tstHelper("K'I-RTI");
|
|
tstHelper("K'IRTI'I");
|
|
tstHelper("K'IRTIS");
|
|
tstHelper("KIS");
|
|
tstHelper("K'IS");
|
|
tstHelper("K'ISA");
|
|
tstHelper("KI'U");
|
|
tstHelper("KKU");
|
|
tstHelper("KLA");
|
|
tstHelper("KLAD");
|
|
tstHelper("KLAG");
|
|
tstHelper("KLAGS");
|
|
tstHelper("KLAM");
|
|
tstHelper("KLAN");
|
|
tstHelper("KLANG");
|
|
tstHelper("KLAS");
|
|
tstHelper("KLEGS");
|
|
tstHelper("KLING");
|
|
tstHelper("KLO");
|
|
tstHelper("KLOD");
|
|
tstHelper("KLOG");
|
|
tstHelper("KLOGS");
|
|
tstHelper("KLO'I");
|
|
tstHelper("KLONG");
|
|
tstHelper("KLU");
|
|
tstHelper("KLU'AM");
|
|
tstHelper("KLUB");
|
|
tstHelper("'KLUBS");
|
|
tstHelper("KLUD");
|
|
tstHelper("KLU'I");
|
|
tstHelper("KLUNG");
|
|
tstHelper("KLUNGS");
|
|
tstHelper("KLUS");
|
|
tstHelper("Ko");// o is punct, but KAo would make more sense.
|
|
tstHelper("KO");
|
|
tstHelper("KOG");
|
|
tstHelper("KON");
|
|
tstHelper("KOndI");
|
|
tstHelper("KONG");
|
|
tstHelper("Koo");
|
|
tstHelper("KOO");
|
|
tstHelper("KOO'dI");
|
|
tstHelper("KOO-nAdI");
|
|
tstHelper("KOOndA");
|
|
tstHelper("KOOndI");
|
|
tstHelper("KOOndINA");
|
|
tstHelper("KOR");
|
|
tstHelper("KOS");
|
|
tstHelper("KO'U");
|
|
tstHelper("KO'UdI");
|
|
tstHelper("KO'UdIN+YA");
|
|
tstHelper("KRA");
|
|
tstHelper("K'RA");
|
|
tstHelper("KRA'I");
|
|
tstHelper("KRAL");
|
|
tstHelper("KRE");
|
|
tstHelper("KRi");
|
|
tstHelper("KRI");
|
|
tstHelper("KRI'I");
|
|
tstHelper("KRIS");
|
|
tstHelper("KRishnA");
|
|
tstHelper("KRIshnA");
|
|
tstHelper("KROL");
|
|
tstHelper("KRUN");
|
|
tstHelper("KRUNG");
|
|
tstHelper("KRUS");
|
|
tstHelper("KshA");
|
|
tstHelper("KshI");
|
|
tstHelper("Ksh'I");
|
|
tstHelper("KSHI");
|
|
tstHelper("KshU");
|
|
tstHelper("KU");
|
|
tstHelper("KUB");
|
|
tstHelper("KUD");
|
|
tstHelper("KULLE'I");
|
|
tstHelper("KUM");
|
|
tstHelper("'KUM");
|
|
tstHelper("KUN");
|
|
tstHelper("KUNDA");
|
|
tstHelper("KUN-DA");
|
|
tstHelper("KUNGS");
|
|
tstHelper("KUN-NGA'I");
|
|
tstHelper("KUR");
|
|
tstHelper("KUS");
|
|
tstHelper("KVA'");
|
|
tstHelper("KVA'E");
|
|
tstHelper("KVA'I");
|
|
tstHelper("KWA'E");
|
|
tstHelper("KYA");
|
|
tstHelper("KYAD");
|
|
tstHelper("KYAG");
|
|
tstHelper("KYA'I");
|
|
tstHelper("KYAL");
|
|
tstHelper("KYAN");
|
|
tstHelper("KYAND");
|
|
tstHelper("KYANG");
|
|
tstHelper("'KYANG");
|
|
tstHelper("KYANGS");
|
|
tstHelper("KYAR");
|
|
tstHelper("KYE");
|
|
tstHelper("KYED");
|
|
tstHelper("KYEE");
|
|
tstHelper("KYEGS");
|
|
tstHelper("KYEM");
|
|
tstHelper("KYER");
|
|
tstHelper("KYES");
|
|
tstHelper("KYE'U");
|
|
tstHelper("KYI");
|
|
tstHelper("KYI'AM");
|
|
tstHelper("KYI'ANG");
|
|
tstHelper("KYID");
|
|
tstHelper("KYIL");
|
|
tstHelper("KYIM");
|
|
tstHelper("KYIN");
|
|
tstHelper("KYI'O");
|
|
tstHelper("KYIR");
|
|
tstHelper("KYIS");
|
|
tstHelper("KYO");
|
|
tstHelper("KYOD");
|
|
tstHelper("KYOG");
|
|
tstHelper("KYOR");
|
|
tstHelper("KYU");
|
|
tstHelper("KYUR");
|
|
tstHelper("KYUS");
|
|
tstHelper("LA");
|
|
tstHelper("L'A");
|
|
tstHelper("LA'AM");
|
|
tstHelper("LA'ANG");
|
|
tstHelper("LAB");
|
|
tstHelper("LABLO");
|
|
tstHelper("LABYANG");
|
|
tstHelper("LAD");
|
|
tstHelper("LADS");
|
|
tstHelper("LAG");
|
|
tstHelper("LAGS");
|
|
tstHelper("LAH");
|
|
tstHelper("LA'I");
|
|
tstHelper("LAKshM'I'I");
|
|
tstHelper("LAL");
|
|
tstHelper("LAm");
|
|
tstHelper("LAM");
|
|
tstHelper("LAN");
|
|
tstHelper("LANDA");
|
|
tstHelper("LANG");
|
|
tstHelper("LANGKA");
|
|
tstHelper("LANG-KA");
|
|
tstHelper("LANG-KA'");
|
|
tstHelper("LANG-KA'I");
|
|
tstHelper("LANGKA'I");
|
|
tstHelper("LANGKAR");
|
|
tstHelper("LANG-KAR");
|
|
tstHelper("LANGKARA");
|
|
tstHelper("LANGKR");
|
|
tstHelper("LANGS");
|
|
tstHelper("LA'O");
|
|
tstHelper("LA'ONGS");
|
|
tstHelper("LAR");
|
|
tstHelper("LAS");
|
|
tstHelper("LBA");
|
|
tstHelper("LBAG");
|
|
tstHelper("LBANG");
|
|
tstHelper("LCAG");
|
|
tstHelper("LCAGS");
|
|
tstHelper("LCANG");
|
|
tstHelper("LCE");
|
|
tstHelper("LCE'ANG");
|
|
tstHelper("LCE'I");
|
|
tstHelper("LCE'O");
|
|
tstHelper("LCER");
|
|
tstHelper("LCES");
|
|
tstHelper("LCI");
|
|
tstHelper("LCIBS");
|
|
tstHelper("LCID");
|
|
tstHelper("LCIG");
|
|
tstHelper("LCO");
|
|
tstHelper("LCOG");
|
|
tstHelper("LCOGS");
|
|
tstHelper("LCONG");
|
|
tstHelper("LCUB");
|
|
tstHelper("LCUG");
|
|
tstHelper("LDA");
|
|
tstHelper("LDA'");
|
|
tstHelper("LDAB");
|
|
tstHelper("LDAD");
|
|
tstHelper("LDAG");
|
|
tstHelper("LDAGS");
|
|
tstHelper("LDA'I");
|
|
tstHelper("LDAM");
|
|
tstHelper("LDAN");
|
|
tstHelper("LDANG");
|
|
tstHelper("LDANGS");
|
|
tstHelper("LDAR");
|
|
tstHelper("LDAS");
|
|
tstHelper("LDE");
|
|
tstHelper("LDEG");
|
|
tstHelper("LDEGS");
|
|
tstHelper("LDE'I");
|
|
tstHelper("LDEM");
|
|
tstHelper("LDENG");
|
|
tstHelper("LDES");
|
|
tstHelper("LDE'U");
|
|
tstHelper("LDI");
|
|
tstHelper("LDIB");
|
|
tstHelper("LDID");
|
|
tstHelper("LDI'I");
|
|
tstHelper("LDING");
|
|
tstHelper("LDINGS");
|
|
tstHelper("LDIR");
|
|
tstHelper("LDIS");
|
|
tstHelper("LDOG");
|
|
tstHelper("LDON");
|
|
tstHelper("LDONG");
|
|
tstHelper("LDONGS");
|
|
tstHelper("LDUD");
|
|
tstHelper("LDUGS");
|
|
tstHelper("LDUM");
|
|
tstHelper("LE");
|
|
tstHelper("LEB");
|
|
tstHelper("LEBS");
|
|
tstHelper("LEG");
|
|
tstHelper("LEGS");
|
|
tstHelper("LE'I");
|
|
tstHelper("LEN");
|
|
tstHelper("LENDRA");
|
|
tstHelper("LER");
|
|
tstHelper("LES");
|
|
tstHelper("LESG");
|
|
tstHelper("LESS");
|
|
tstHelper("LE'U");
|
|
tstHelper("LE'U'I");
|
|
tstHelper("LE'U'O");
|
|
tstHelper("LE'UR");
|
|
tstHelper("LG");
|
|
tstHelper("LGA'I");
|
|
tstHelper("LGANG");
|
|
tstHelper("LGAS");
|
|
tstHelper("LHA");
|
|
tstHelper("LHA'AM");
|
|
tstHelper("LHAB");
|
|
tstHelper("LHAD");
|
|
tstHelper("LHAG");
|
|
tstHelper("LHAGS");
|
|
tstHelper("LHA'I");
|
|
tstHelper("LHAM");
|
|
tstHelper("LHAN");
|
|
tstHelper("LHANG");
|
|
tstHelper("LHA'O");
|
|
tstHelper("LHAR");
|
|
tstHelper("LHAS");
|
|
tstHelper("LHEB");
|
|
tstHelper("LHI");
|
|
tstHelper("LHO");
|
|
tstHelper("LHOD");
|
|
tstHelper("LHOG");
|
|
tstHelper("LHOGS");
|
|
tstHelper("LHO'I");
|
|
tstHelper("LHONG");
|
|
tstHelper("LHU");
|
|
tstHelper("LHUB");
|
|
tstHelper("LHUG");
|
|
tstHelper("LHUMS");
|
|
tstHelper("LHUN");
|
|
tstHelper("LHUNG");
|
|
tstHelper("LHUR");
|
|
tstHelper("LI");
|
|
tstHelper("LIGS");
|
|
tstHelper("LI'I");
|
|
tstHelper("LIN");
|
|
tstHelper("LIN-DA'I");
|
|
tstHelper("LINDI");
|
|
tstHelper("LINE");
|
|
tstHelper("LING");
|
|
tstHelper("LINGA'I");
|
|
tstHelper("LING-KA");
|
|
tstHelper("LINGKA'I");
|
|
tstHelper("LIN-NGA'I");
|
|
tstHelper("LIR");
|
|
tstHelper("LIS");
|
|
tstHelper("LITZTSA");
|
|
tstHelper("LJAGS");
|
|
tstHelper("LJAN");
|
|
tstHelper("LJANG");
|
|
tstHelper("LJAS");
|
|
tstHelper("LJID");
|
|
tstHelper("LJIN");
|
|
tstHelper("LJON");
|
|
tstHelper("LJONG");
|
|
tstHelper("LJONGS");
|
|
tstHelper("LKA");
|
|
tstHelper("LKOG");
|
|
tstHelper("LKUG");
|
|
tstHelper("LKUGS");
|
|
tstHelper("LNGA");
|
|
tstHelper("LNGA'AM");
|
|
tstHelper("LNGA'ANG");
|
|
tstHelper("LNGA'I");
|
|
tstHelper("LNGAN");
|
|
tstHelper("LNGANG");
|
|
tstHelper("LNGANGS");
|
|
tstHelper("LNGA'O");
|
|
tstHelper("LNGAR");
|
|
tstHelper("LNGAS");
|
|
tstHelper("LNGE'I");
|
|
tstHelper("LNGI");
|
|
tstHelper("LNGO");
|
|
tstHelper("LNGOG");
|
|
tstHelper("LNGON");
|
|
tstHelper("LNGONGS");
|
|
tstHelper("LO");
|
|
tstHelper("LO'AM");
|
|
tstHelper("LO'ANG");
|
|
tstHelper("LOBS");
|
|
tstHelper("LOD");
|
|
tstHelper("LOG");
|
|
tstHelper("LOGS");
|
|
tstHelper("LO'I");
|
|
tstHelper("LOM");
|
|
tstHelper("LON");
|
|
tstHelper("LONG");
|
|
tstHelper("LONGS");
|
|
tstHelper("LO'O");
|
|
tstHelper("LOR");
|
|
tstHelper("LOS");
|
|
tstHelper("LPAGS");
|
|
tstHelper("LPAR");
|
|
tstHelper("LS");
|
|
tstHelper("LTA");
|
|
tstHelper("LTA'AM");
|
|
tstHelper("LTA'ANG");
|
|
tstHelper("LTAB");
|
|
tstHelper("LTABS");
|
|
tstHelper("LTAD");
|
|
tstHelper("LTAG");
|
|
tstHelper("LTAGS");
|
|
tstHelper("LTA'I");
|
|
tstHelper("LTAM");
|
|
tstHelper("LTAMS");
|
|
tstHelper("LTAN");
|
|
tstHelper("LTANG");
|
|
tstHelper("LTANGS");
|
|
tstHelper("LTA'O");
|
|
tstHelper("LTAR");
|
|
tstHelper("LTAS");
|
|
tstHelper("LTE");
|
|
tstHelper("LTENG");
|
|
tstHelper("LTER");
|
|
tstHelper("LTIR");
|
|
tstHelper("LTO");
|
|
tstHelper("LTOD");
|
|
tstHelper("LTOG");
|
|
tstHelper("LTOGS");
|
|
tstHelper("LTO'I");
|
|
tstHelper("LTONG");
|
|
tstHelper("LTONGS");
|
|
tstHelper("LTOR");
|
|
tstHelper("LTOS");
|
|
tstHelper("LTRA");
|
|
tstHelper("LTU");
|
|
tstHelper("LTUNG");
|
|
tstHelper("LU");
|
|
tstHelper("LUD");
|
|
tstHelper("LUG");
|
|
tstHelper("LUGS");
|
|
tstHelper("LU'I");
|
|
tstHelper("LUM");
|
|
tstHelper("LUMBI");
|
|
tstHelper("LUM-BI");
|
|
tstHelper("LUMS");
|
|
tstHelper("LUNDHA'I");
|
|
tstHelper("LUNG");
|
|
tstHelper("LUNGS");
|
|
tstHelper("LUR");
|
|
tstHelper("LUS");
|
|
tstHelper("LVA");
|
|
tstHelper("LWA");
|
|
tstHelper("LWA'I");
|
|
tstHelper("LYA");
|
|
tstHelper("LYE");
|
|
tstHelper("MA");
|
|
tstHelper("'MA");
|
|
tstHelper("M'A");
|
|
tstHelper("MA'");
|
|
tstHelper("MA'AM");
|
|
tstHelper("MA'ANG");
|
|
tstHelper("MAD");
|
|
tstHelper("MAG");
|
|
tstHelper("MAGS");
|
|
tstHelper("MA-H'A");
|
|
tstHelper("MAH'A");
|
|
tstHelper("MA'I");
|
|
tstHelper("MA'IS");
|
|
tstHelper("MAL");
|
|
tstHelper("MAm");
|
|
tstHelper("MAM");
|
|
tstHelper("MAMS");
|
|
tstHelper("MAN");
|
|
tstHelper("MAndA");
|
|
tstHelper("MANDA");
|
|
tstHelper("MAN-D'A");
|
|
tstHelper("MAN-DA'");
|
|
tstHelper("MAND'A");
|
|
tstHelper("MAN-D'AR");
|
|
tstHelper("MANG");
|
|
tstHelper("MANGA");
|
|
tstHelper("MANGGA");
|
|
tstHelper("MANG-GA'I");
|
|
tstHelper("MANGL");
|
|
tstHelper("MANGS");
|
|
tstHelper("MANL");
|
|
tstHelper("MAN-NGA");
|
|
tstHelper("MANTA");
|
|
tstHelper("MANTRA");
|
|
tstHelper("MAN-TRA");
|
|
tstHelper("MAN-TRE");
|
|
tstHelper("MA-NYA");
|
|
tstHelper("MANYDZU");
|
|
tstHelper("MANY-DZU");
|
|
tstHelper("MA'O");
|
|
tstHelper("MA'ONGS");
|
|
tstHelper("MAR");
|
|
tstHelper("M'AR");
|
|
tstHelper("MAS");
|
|
tstHelper("MASTU");
|
|
tstHelper("MA-YOG");
|
|
tstHelper("MBA");
|
|
tstHelper("MBA'");
|
|
tstHelper("MBAS");
|
|
tstHelper("MBI");
|
|
tstHelper("M+B'I");
|
|
tstHelper("MBU'I");
|
|
tstHelper("MBYON");
|
|
tstHelper("MCAN");
|
|
tstHelper("MCED");
|
|
tstHelper("MCHAD");
|
|
tstHelper("MCHAG");
|
|
tstHelper("MCHAGS");
|
|
tstHelper("MCHAN");
|
|
tstHelper("MCHE");
|
|
tstHelper("MCHED");
|
|
tstHelper("MCHER");
|
|
tstHelper("MCHES");
|
|
tstHelper("MCHE'U");
|
|
tstHelper("MCHI");
|
|
tstHelper("MCHI'AM");
|
|
tstHelper("MCHID");
|
|
tstHelper("MCHIG");
|
|
tstHelper("MCHI'I");
|
|
tstHelper("MCHIL");
|
|
tstHelper("MCHIM");
|
|
tstHelper("MCHIMS");
|
|
tstHelper("MCHIN");
|
|
tstHelper("MCHING");
|
|
tstHelper("MCHI'O");
|
|
tstHelper("MCHIR");
|
|
tstHelper("MCHIS");
|
|
tstHelper("MCHO");
|
|
tstHelper("MCHOD");
|
|
tstHelper("MCHOG");
|
|
tstHelper("MCHONG");
|
|
tstHelper("MCHONGS");
|
|
tstHelper("MCHOS");
|
|
tstHelper("MCHU");
|
|
tstHelper("MCHUD");
|
|
tstHelper("MCHU'I");
|
|
tstHelper("MCHUNGS");
|
|
tstHelper("MCHUR");
|
|
tstHelper("MCHUS");
|
|
tstHelper("MCIS");
|
|
tstHelper("MCOM");
|
|
tstHelper("MDA'");
|
|
tstHelper("MDAG");
|
|
tstHelper("MDAGS");
|
|
tstHelper("MDA'I");
|
|
tstHelper("MDANG");
|
|
tstHelper("MDANGS");
|
|
tstHelper("MDAS");
|
|
tstHelper("MDE");
|
|
tstHelper("MDE'U");
|
|
tstHelper("MDO");
|
|
tstHelper("MDO'AM");
|
|
tstHelper("MDO'ANG");
|
|
tstHelper("MDOD");
|
|
tstHelper("MDOG");
|
|
tstHelper("MDO'I");
|
|
tstHelper("MDOMS");
|
|
tstHelper("MDON");
|
|
tstHelper("MDONG");
|
|
tstHelper("MDONGS");
|
|
tstHelper("MDOR");
|
|
tstHelper("MDOS");
|
|
tstHelper("MDRIS");
|
|
tstHelper("MDROS");
|
|
tstHelper("MDUD");
|
|
tstHelper("MDUM");
|
|
tstHelper("MDUN");
|
|
tstHelper("MDUNG");
|
|
tstHelper("MDZA'");
|
|
tstHelper("MDZAD");
|
|
tstHelper("MDZA'I");
|
|
tstHelper("MDZANGS");
|
|
tstHelper("MDZAS");
|
|
tstHelper("MDZE");
|
|
tstHelper("MDZE'AM");
|
|
tstHelper("MDZED");
|
|
tstHelper("MDZER");
|
|
tstHelper("MDZES");
|
|
tstHelper("MDZOD");
|
|
tstHelper("MDZOL");
|
|
tstHelper("MDZOS");
|
|
tstHelper("MDZUB");
|
|
tstHelper("ME");
|
|
tstHelper("ME'AM");
|
|
tstHelper("ME'ANG");
|
|
tstHelper("MED");
|
|
tstHelper("MEE");
|
|
tstHelper("MEG");
|
|
tstHelper("ME'I");
|
|
tstHelper("MEL");
|
|
tstHelper("MEMD");
|
|
tstHelper("MEN");
|
|
tstHelper("MENG");
|
|
tstHelper("MER");
|
|
tstHelper("MES");
|
|
tstHelper("MGAL");
|
|
tstHelper("MGAR");
|
|
tstHelper("MGAS");
|
|
tstHelper("MGO");
|
|
tstHelper("MGO'ANG");
|
|
tstHelper("MGO'I");
|
|
tstHelper("MGOL");
|
|
tstHelper("MGON");
|
|
tstHelper("MGOR");
|
|
tstHelper("MGOS");
|
|
tstHelper("MGRIN");
|
|
tstHelper("MGROL");
|
|
tstHelper("MGRON");
|
|
tstHelper("MGRONG");
|
|
tstHelper("MGRUB");
|
|
tstHelper("MGU");
|
|
tstHelper("MGUL");
|
|
tstHelper("MGU'O");
|
|
tstHelper("MGUR");
|
|
tstHelper("MGYES");
|
|
tstHelper("MGYOGS");
|
|
tstHelper("MGYUR");
|
|
tstHelper("MI");
|
|
tstHelper("M'I");
|
|
tstHelper("M''I");
|
|
tstHelper("MI'AM");
|
|
tstHelper("MI'AS");
|
|
tstHelper("MID");
|
|
tstHelper("MIG");
|
|
tstHelper("MI'GYUR");
|
|
tstHelper("M'I'I");
|
|
tstHelper("MI'I");
|
|
tstHelper("MIM");
|
|
tstHelper("MI'M");
|
|
tstHelper("MIN");
|
|
tstHelper("MING");
|
|
tstHelper("MI'O");
|
|
tstHelper("MIR");
|
|
tstHelper("MIS");
|
|
tstHelper("M'IS");
|
|
tstHelper("M'ISA");
|
|
tstHelper("MISSING");
|
|
tstHelper("MITRA");
|
|
tstHelper("MI'U");
|
|
tstHelper("MJA'");
|
|
tstHelper("MJAD");
|
|
tstHelper("MJAL");
|
|
tstHelper("MJANG");
|
|
tstHelper("MJED");
|
|
tstHelper("MJE'I");
|
|
tstHelper("MJES");
|
|
tstHelper("MJING");
|
|
tstHelper("MJOS");
|
|
tstHelper("MJUG");
|
|
tstHelper("MKHA");
|
|
tstHelper("MKHA'");
|
|
tstHelper("MKHA'I");
|
|
tstHelper("MKHAL");
|
|
tstHelper("MKHAM");
|
|
tstHelper("MKHAMS");
|
|
tstHelper("MKHAN");
|
|
tstHelper("MKHA'O");
|
|
tstHelper("MKHAR");
|
|
tstHelper("MKHAS");
|
|
tstHelper("MKHO");
|
|
tstHelper("MKHOB");
|
|
tstHelper("MKHOS");
|
|
tstHelper("MKHRANG");
|
|
tstHelper("MKHREGS");
|
|
tstHelper("MKHRI");
|
|
tstHelper("MKHRID");
|
|
tstHelper("MKHRIG");
|
|
tstHelper("MKHRIS");
|
|
tstHelper("MKHUR");
|
|
tstHelper("MKHYED");
|
|
tstHelper("MKHYEN");
|
|
tstHelper("MKHYER");
|
|
tstHelper("MKHYUD");
|
|
tstHelper("MNA");
|
|
tstHelper("MNA'");
|
|
tstHelper("MNABS");
|
|
tstHelper("MNAD'A");
|
|
tstHelper("MNAG");
|
|
tstHelper("MNAGS");
|
|
tstHelper("MNAL");
|
|
tstHelper("MNAM");
|
|
tstHelper("MNAMS");
|
|
tstHelper("MNAN");
|
|
tstHelper("MNAR");
|
|
tstHelper("MND'A");
|
|
tstHelper("MNGA'");
|
|
tstHelper("MNGA'AM");
|
|
tstHelper("MNGA'AS");
|
|
tstHelper("MNGAG");
|
|
tstHelper("MNGAGS");
|
|
tstHelper("MNGA'I");
|
|
tstHelper("MNGAL");
|
|
tstHelper("MNGAN");
|
|
tstHelper("MNGA'O");
|
|
tstHelper("MNGAR");
|
|
tstHelper("MNGAS");
|
|
tstHelper("MNGO");
|
|
tstHelper("MNGON");
|
|
tstHelper("MNO");
|
|
tstHelper("MNOBS");
|
|
tstHelper("MNOD");
|
|
tstHelper("MNOG");
|
|
tstHelper("MNOM");
|
|
tstHelper("MNON");
|
|
tstHelper("MNONG");
|
|
tstHelper("MNOS");
|
|
tstHelper("MNUS");
|
|
tstHelper("MNYA-DZU");
|
|
tstHelper("MNYAL");
|
|
tstHelper("MNYAM");
|
|
tstHelper("MNYAMS");
|
|
tstHelper("MNYAN");
|
|
tstHelper("MNYANGS");
|
|
tstHelper("MNYDZU");
|
|
tstHelper("MNY-DZU");
|
|
tstHelper("MNYE");
|
|
tstHelper("MNYE'AM");
|
|
tstHelper("MNYED");
|
|
tstHelper("MNYEL");
|
|
tstHelper("MNYEN");
|
|
tstHelper("MNYES");
|
|
tstHelper("MNYID");
|
|
tstHelper("MNYONG");
|
|
tstHelper("MO");
|
|
tstHelper("M'O");
|
|
tstHelper("MO'AM");
|
|
tstHelper("MO'ANG");
|
|
tstHelper("MOD");
|
|
tstHelper("MOG");
|
|
tstHelper("MOGS");
|
|
tstHelper("MO'I");
|
|
tstHelper("MO'I'O");
|
|
tstHelper("MOL");
|
|
tstHelper("MOM");
|
|
tstHelper("MO'MA");
|
|
tstHelper("MON");
|
|
tstHelper("MONG");
|
|
tstHelper("MONGS");
|
|
tstHelper("MOO");
|
|
tstHelper("MO'O");
|
|
tstHelper("MOOD");
|
|
tstHelper("MOONG");
|
|
tstHelper("MOO-NGA-GAL");
|
|
tstHelper("MOONGGAL");
|
|
tstHelper("MOO-NGGAL");
|
|
tstHelper("MOONG-GAL");
|
|
tstHelper("MOONGGL");
|
|
tstHelper("MOO'U");
|
|
tstHelper("MOR");
|
|
tstHelper("MOS");
|
|
tstHelper("MO'U");
|
|
tstHelper("MPA");
|
|
tstHelper("MRA");
|
|
tstHelper("MRAG");
|
|
tstHelper("MRA'I");
|
|
tstHelper("MRDE");
|
|
tstHelper("MRDZOGS");
|
|
tstHelper("MRGAD");
|
|
tstHelper("MRi");
|
|
tstHelper("MRNYED");
|
|
tstHelper("MRTOG");
|
|
tstHelper("MRTOL");
|
|
tstHelper("MRTZIGS");
|
|
tstHelper("MSHAR");
|
|
tstHelper("MTAMS");
|
|
tstHelper("MTAN");
|
|
tstHelper("MTHA'");
|
|
tstHelper("MTHAD");
|
|
tstHelper("MTHAG");
|
|
tstHelper("MTHA'I");
|
|
tstHelper("MTHAMS");
|
|
tstHelper("MTHANG");
|
|
tstHelper("MTHA'O");
|
|
tstHelper("MTHAR");
|
|
tstHelper("MTHAS");
|
|
tstHelper("MTHE");
|
|
tstHelper("MTHENG");
|
|
tstHelper("MTHI");
|
|
tstHelper("MTHIL");
|
|
tstHelper("MTHING");
|
|
tstHelper("MTHO");
|
|
tstHelper("MTHOB");
|
|
tstHelper("MTHOD");
|
|
tstHelper("MTHOGS");
|
|
tstHelper("MTHO'I");
|
|
tstHelper("MTHOL");
|
|
tstHelper("MTHON");
|
|
tstHelper("MTHONG");
|
|
tstHelper("MTHONGS");
|
|
tstHelper("MTHOR");
|
|
tstHelper("MTHOS");
|
|
tstHelper("MTHU");
|
|
tstHelper("MTHU'ANG");
|
|
tstHelper("MTHUD");
|
|
tstHelper("MTHUG");
|
|
tstHelper("MTHU'I");
|
|
tstHelper("MTHUN");
|
|
tstHelper("MTHUNG");
|
|
tstHelper("MTHUNGS");
|
|
tstHelper("MTHU'O");
|
|
tstHelper("MTHUR");
|
|
tstHelper("MTHUS");
|
|
tstHelper("MTONG");
|
|
tstHelper("MTSA");
|
|
tstHelper("MTSA'");
|
|
tstHelper("MTSAD");
|
|
tstHelper("MTSAL");
|
|
tstHelper("MTSAMS");
|
|
tstHelper("MTSAN");
|
|
tstHelper("MTSANG");
|
|
tstHelper("MTSAR");
|
|
tstHelper("MTSE");
|
|
tstHelper("MTSER");
|
|
tstHelper("MTSE'U");
|
|
tstHelper("MTSE'U'I");
|
|
tstHelper("MTSE'US");
|
|
tstHelper("MTSID");
|
|
tstHelper("MTSIMS");
|
|
tstHelper("MTSIN");
|
|
tstHelper("MTSO");
|
|
tstHelper("MTSO'AM");
|
|
tstHelper("MTSOG");
|
|
tstHelper("MTSOGS");
|
|
tstHelper("MTSO'I");
|
|
tstHelper("MTSOL");
|
|
tstHelper("MTSON");
|
|
tstHelper("MTSOR");
|
|
tstHelper("MTSOS");
|
|
tstHelper("MTSO'U");
|
|
tstHelper("MTSUN");
|
|
tstHelper("MTSUNGS");
|
|
tstHelper("MTSUR");
|
|
tstHelper("MTTHUN");
|
|
tstHelper("MTZAN");
|
|
tstHelper("MU");
|
|
tstHelper("M'U");
|
|
tstHelper("MUD");
|
|
tstHelper("MUG");
|
|
tstHelper("MU'I");
|
|
tstHelper("MU-KKE");
|
|
tstHelper("MUKTA");
|
|
tstHelper("MU-KTA");
|
|
tstHelper("MUK-TA");
|
|
tstHelper("MU-KTE");
|
|
tstHelper("MUN");
|
|
tstHelper("MU-NYZA");
|
|
tstHelper("MUR");
|
|
tstHelper("MUS");
|
|
tstHelper("MUT-KA");
|
|
tstHelper("MU-TKU");
|
|
tstHelper("MYA");
|
|
tstHelper("MYAGS");
|
|
tstHelper("MYAL");
|
|
tstHelper("MYAN");
|
|
tstHelper("MYANG");
|
|
tstHelper("MYANGS");
|
|
tstHelper("MYAR");
|
|
tstHelper("MYO");
|
|
tstHelper("MYOG");
|
|
tstHelper("MYONG");
|
|
tstHelper("MYONGS");
|
|
tstHelper("MYOS");
|
|
tstHelper("MYU");
|
|
tstHelper("MYUNG");
|
|
tstHelper("MYUR");
|
|
tstHelper("MZA'");
|
|
tstHelper("MZAD");
|
|
tstHelper("MZHU");
|
|
tstHelper("MZHUGS");
|
|
tstHelper("MZHUM");
|
|
tstHelper("nA");
|
|
tstHelper("n'A");
|
|
tstHelper("NA");
|
|
tstHelper("N'A");
|
|
tstHelper("NA'ANG");
|
|
tstHelper("NAB");
|
|
tstHelper("NABS");
|
|
tstHelper("NAD");
|
|
tstHelper("NA'DU");
|
|
tstHelper("NAG");
|
|
tstHelper("NAGS");
|
|
tstHelper("nA'I");
|
|
tstHelper("NA'I");
|
|
tstHelper("NAL");
|
|
tstHelper("nAM");
|
|
tstHelper("NAm");
|
|
tstHelper("NAM");
|
|
tstHelper("NAmS");
|
|
tstHelper("NAMS");
|
|
tstHelper("NAN");
|
|
tstHelper("NANDA");
|
|
tstHelper("NANDA'I");
|
|
tstHelper("NANG");
|
|
tstHelper("NA'NG");
|
|
tstHelper("NANGS");
|
|
tstHelper("NA'O");
|
|
tstHelper("NAR");
|
|
tstHelper("NAS");
|
|
tstHelper("NA-ttE");
|
|
tstHelper("NA-YA");
|
|
tstHelper("NA+YA");
|
|
tstHelper("NA-YA'I");
|
|
tstHelper("NA-YAS");
|
|
tstHelper("ndA");
|
|
tstHelper("NDA'I");
|
|
tstHelper("NDANG");
|
|
tstHelper("nDDBCOM");
|
|
tstHelper("ndI");
|
|
tstHelper("nE");
|
|
tstHelper("Ne");
|
|
tstHelper("NE");
|
|
tstHelper("NEE");
|
|
tstHelper("NEE");
|
|
tstHelper("NEM");
|
|
tstHelper("NENG");
|
|
tstHelper("NER");
|
|
tstHelper("NERNYDZA");
|
|
tstHelper("NE'U");
|
|
tstHelper("NGA");
|
|
tstHelper("'NGA'");
|
|
tstHelper("NGA'");
|
|
tstHelper("NGA'AI");
|
|
tstHelper("NGA'ANG");
|
|
tstHelper("NGAB");
|
|
tstHelper("NGAD");
|
|
tstHelper("NGAG");
|
|
tstHelper("NGAGS");
|
|
tstHelper("NGA'I");
|
|
tstHelper("NGAK");
|
|
tstHelper("NGAL");
|
|
tstHelper("NGAM");
|
|
tstHelper("NGAN");
|
|
tstHelper("NGANG");
|
|
tstHelper("NGA'O");
|
|
tstHelper("NGAR");
|
|
tstHelper("NGAS");
|
|
tstHelper("NGE");
|
|
tstHelper("NGED");
|
|
tstHelper("NGE'I");
|
|
tstHelper("NGENG");
|
|
tstHelper("NGE'O");
|
|
tstHelper("NGER");
|
|
tstHelper("NGES");
|
|
tstHelper("NGHU");
|
|
tstHelper("NGO");
|
|
tstHelper("NGOGS");
|
|
tstHelper("NGO'I");
|
|
tstHelper("NGOM");
|
|
tstHelper("NGOMS");
|
|
tstHelper("NGON");
|
|
tstHelper("NGOR");
|
|
tstHelper("NGOS");
|
|
tstHelper("NGU");
|
|
tstHelper("NGU'AM");
|
|
tstHelper("NGU'ANG");
|
|
tstHelper("NGU'I");
|
|
tstHelper("NGUL");
|
|
tstHelper("NGUR");
|
|
tstHelper("NGUS");
|
|
tstHelper("nI");
|
|
tstHelper("n'I");
|
|
tstHelper("Ni");
|
|
tstHelper("NI");
|
|
tstHelper("N'I");
|
|
tstHelper("NID");
|
|
tstHelper("NIG");
|
|
tstHelper("NI'I");
|
|
tstHelper("NIM");
|
|
tstHelper("NIN");
|
|
tstHelper("NING");
|
|
tstHelper("NIR");
|
|
tstHelper("NIS");
|
|
tstHelper("NNGOS");
|
|
tstHelper("nO");
|
|
tstHelper("NO");
|
|
tstHelper("NOD");
|
|
tstHelper("NO'DI");
|
|
tstHelper("NOG");
|
|
tstHelper("NOGAL");
|
|
tstHelper("NOGS");
|
|
tstHelper("NOM");
|
|
tstHelper("NON");
|
|
tstHelper("NONGS");
|
|
tstHelper("NOR");
|
|
tstHelper("NOS");
|
|
tstHelper("nRi");
|
|
tstHelper("NRi");
|
|
tstHelper("NRi-tt'A");
|
|
tstHelper("NRTZIS");
|
|
tstHelper("NTA");
|
|
tstHelper("NTE");
|
|
tstHelper("NU");
|
|
tstHelper("NU'AM");
|
|
tstHelper("NU'ANG");
|
|
tstHelper("NUB");
|
|
tstHelper("NUG");
|
|
tstHelper("NU'I");
|
|
tstHelper("NUL");
|
|
tstHelper("NU'O");
|
|
tstHelper("NUR");
|
|
tstHelper("NUS");
|
|
tstHelper("nYA");
|
|
tstHelper("NYA");
|
|
tstHelper("N-YA");
|
|
tstHelper("N+YA");
|
|
tstHelper("NY'A");
|
|
tstHelper("NYA'AM");
|
|
tstHelper("NYADZA");
|
|
tstHelper("NYAG");
|
|
tstHelper("N+YA'I");
|
|
tstHelper("NYA'I");
|
|
tstHelper("NYAJS");
|
|
tstHelper("NYAL");
|
|
tstHelper("nYAM");
|
|
tstHelper("NYAM");
|
|
tstHelper("NYAMS");
|
|
tstHelper("NYAN");
|
|
tstHelper("NYANG");
|
|
tstHelper("N+YANG");
|
|
tstHelper("NYAR");
|
|
tstHelper("NYAS");
|
|
tstHelper("N-YAS");
|
|
tstHelper("N+YAS");
|
|
tstHelper("N+YASA");
|
|
tstHelper("NYDI");
|
|
tstHelper("NYDZA");
|
|
tstHelper("nYE");
|
|
tstHelper("NYE");
|
|
tstHelper("NYED");
|
|
tstHelper("NYEES");
|
|
tstHelper("NYE'I");
|
|
tstHelper("NYEN");
|
|
tstHelper("NYE'O");
|
|
tstHelper("NYER");
|
|
tstHelper("NYES");
|
|
tstHelper("NYI");
|
|
tstHelper("NYI'AM");
|
|
tstHelper("NYID");
|
|
tstHelper("NYI'I");
|
|
tstHelper("NYIL");
|
|
tstHelper("NYIM");
|
|
tstHelper("NYIN");
|
|
tstHelper("NYING");
|
|
tstHelper("NYIR");
|
|
tstHelper("NYIS");
|
|
tstHelper("NYO");
|
|
tstHelper("NYOL");
|
|
tstHelper("NYOM");
|
|
tstHelper("NYON");
|
|
tstHelper("NYOR");
|
|
tstHelper("NYOS");
|
|
tstHelper("NYTZA");
|
|
tstHelper("NYU");
|
|
tstHelper("NYUD");
|
|
tstHelper("NYUG");
|
|
tstHelper("NYUL");
|
|
tstHelper("NYUNG");
|
|
tstHelper("NYUNGS");
|
|
tstHelper("'O");
|
|
tstHelper("'OBS");
|
|
tstHelper("'OD");
|
|
tstHelper("'OG");
|
|
tstHelper("'OGS");
|
|
tstHelper("'OL");
|
|
tstHelper("'ON");
|
|
tstHelper("'ONG");
|
|
tstHelper("'ONGS");
|
|
tstHelper("'OR");
|
|
tstHelper("'OS");
|
|
tstHelper("pA");
|
|
tstHelper("PA");
|
|
tstHelper("P'A");
|
|
tstHelper("PA'");
|
|
tstHelper("PA'AI");
|
|
tstHelper("PA'AM");
|
|
tstHelper("PA'ANG");
|
|
tstHelper("PAD");
|
|
tstHelper("PAD-");
|
|
tstHelper("PA'DI");
|
|
tstHelper("PADMA");
|
|
tstHelper("PAD-MA");
|
|
tstHelper("PAD-MA");
|
|
tstHelper("PADM'A");
|
|
tstHelper("PADMA'AM");
|
|
tstHelper("PAD-MA'I");
|
|
tstHelper("PAD-MA'I");
|
|
tstHelper("PADMA'I");
|
|
tstHelper("PAD-MAS");
|
|
tstHelper("PADMASA");
|
|
tstHelper("PAD-MED");
|
|
tstHelper("PADM'I");
|
|
tstHelper("PADMO");
|
|
tstHelper("PAD-MO");
|
|
tstHelper("PAD-MO'I");
|
|
tstHelper("PADMO'I");
|
|
tstHelper("PADMOS");
|
|
tstHelper("PAG");
|
|
tstHelper("PAGE");
|
|
tstHelper("PAGS");
|
|
tstHelper("PAH");
|
|
tstHelper("PA'I");
|
|
tstHelper("PA'I");
|
|
tstHelper("PA'IJ");
|
|
tstHelper("PA'I'O");
|
|
tstHelper("PAKOO");
|
|
tstHelper("PAL");
|
|
tstHelper("PALG");
|
|
tstHelper("PAm");
|
|
tstHelper("PAM");
|
|
tstHelper("PAn");
|
|
tstHelper("PAN");
|
|
tstHelper("PAndI");
|
|
tstHelper("PANdI");
|
|
tstHelper("PANG");
|
|
tstHelper("PANG-KI'I");
|
|
tstHelper("PANYTZA");
|
|
tstHelper("PA'O");
|
|
tstHelper("PAR");
|
|
tstHelper("PARMA");
|
|
tstHelper("PARnA");
|
|
tstHelper("PARNA");
|
|
tstHelper("PARNAM");
|
|
tstHelper("PARshA");
|
|
tstHelper("PARSHA");
|
|
tstHelper("PAR-SHA");
|
|
tstHelper("PAR-SHI");
|
|
tstHelper("PAS");
|
|
tstHelper("PD");
|
|
tstHelper("PDMA");
|
|
tstHelper("PDM'AI");
|
|
tstHelper("PE");
|
|
tstHelper("PE'I");
|
|
tstHelper("PER");
|
|
tstHelper("PE'U");
|
|
tstHelper("PH");
|
|
tstHelper("PHA");
|
|
tstHelper("'PHA");
|
|
tstHelper("PH'A");
|
|
tstHelper("PHA'AM");
|
|
tstHelper("PHAB");
|
|
tstHelper("PHABS");
|
|
tstHelper("PHAG");
|
|
tstHelper("'PHAG");
|
|
tstHelper("PHAGS");
|
|
tstHelper("'PHAGS");
|
|
tstHelper("PHA'I");
|
|
tstHelper("PHAL");
|
|
tstHelper("'PHAL");
|
|
tstHelper("PHAM");
|
|
tstHelper("'PHAM");
|
|
tstHelper("PHAN");
|
|
tstHelper("'PHAN");
|
|
tstHelper("PHANG");
|
|
tstHelper("'PHANG");
|
|
tstHelper("PHANGS");
|
|
tstHelper("'PHANGS");
|
|
tstHelper("PHA'O");
|
|
tstHelper("PHAR");
|
|
tstHelper("'PHAR");
|
|
tstHelper("PHARG");
|
|
tstHelper("PHAS");
|
|
tstHelper("PHAYG");
|
|
tstHelper("PHE");
|
|
tstHelper("PHEBS");
|
|
tstHelper("PHEG");
|
|
tstHelper("PHEL");
|
|
tstHelper("'PHEL");
|
|
tstHelper("'PHEN");
|
|
tstHelper("PHIGS");
|
|
tstHelper("PHIN");
|
|
tstHelper("PHIR");
|
|
tstHelper("PHO");
|
|
tstHelper("'PHO");
|
|
tstHelper("'PHO'AM");
|
|
tstHelper("PHO'AM");
|
|
tstHelper("'PHO'ANG");
|
|
tstHelper("PHOB");
|
|
tstHelper("PHOD");
|
|
tstHelper("'PHOD");
|
|
tstHelper("PHOG");
|
|
tstHelper("'PHOG");
|
|
tstHelper("'PHOGS");
|
|
tstHelper("'PHO'I");
|
|
tstHelper("PHO'I");
|
|
tstHelper("PHOL");
|
|
tstHelper("PHONG");
|
|
tstHelper("'PHONG");
|
|
tstHelper("PHONGS");
|
|
tstHelper("'PHONGS");
|
|
tstHelper("PHO'O");
|
|
tstHelper("PHOR");
|
|
tstHelper("'PHOR");
|
|
tstHelper("PHOS");
|
|
tstHelper("'PHOS");
|
|
tstHelper("PHRA");
|
|
tstHelper("'PHRA");
|
|
tstHelper("PHRAB");
|
|
tstHelper("PHRAD");
|
|
tstHelper("'PHRAD");
|
|
tstHelper("PHRAG");
|
|
tstHelper("'PHRAG");
|
|
tstHelper("PHRAGS");
|
|
tstHelper("PHRAL");
|
|
tstHelper("'PHRAL");
|
|
tstHelper("PHRAM");
|
|
tstHelper("PHRAN");
|
|
tstHelper("PHRANG");
|
|
tstHelper("PHRAR");
|
|
tstHelper("'PHRAS");
|
|
tstHelper("'PHRE");
|
|
tstHelper("PHRED");
|
|
tstHelper("'PHRED");
|
|
tstHelper("PHREN");
|
|
tstHelper("PHRENG");
|
|
tstHelper("'PHRENG");
|
|
tstHelper("PHRE'U");
|
|
tstHelper("PHRI");
|
|
tstHelper("PHRI'ANG");
|
|
tstHelper("PHRIB");
|
|
tstHelper("PHRIG");
|
|
tstHelper("'PHRIG");
|
|
tstHelper("'PHRIGS");
|
|
tstHelper("PHRIN");
|
|
tstHelper("'PHRIN");
|
|
tstHelper("PHRING");
|
|
tstHelper("'PHRO");
|
|
tstHelper("'PHROD");
|
|
tstHelper("PHROG");
|
|
tstHelper("'PHROG");
|
|
tstHelper("PHROGS");
|
|
tstHelper("'PHROGS");
|
|
tstHelper("'PHRO'I");
|
|
tstHelper("PHROL");
|
|
tstHelper("'PHRO'O");
|
|
tstHelper("'PHROR");
|
|
tstHelper("'PHROS");
|
|
tstHelper("PHRU");
|
|
tstHelper("'PHRU");
|
|
tstHelper("PHRUG");
|
|
tstHelper("PHRUGS");
|
|
tstHelper("PHRUL");
|
|
tstHelper("'PHRUL");
|
|
tstHelper("PHRUM");
|
|
tstHelper("PHU");
|
|
tstHelper("PHUB");
|
|
tstHelper("PHUBS");
|
|
tstHelper("PHUD");
|
|
tstHelper("PHUG");
|
|
tstHelper("PHUGS");
|
|
tstHelper("PHUL");
|
|
tstHelper("'PHUL");
|
|
tstHelper("PHUN");
|
|
tstHelper("PHUNG");
|
|
tstHelper("'PHUNG");
|
|
tstHelper("PHUR");
|
|
tstHelper("'PHUR");
|
|
tstHelper("PHYA");
|
|
tstHelper("'PHYA");
|
|
tstHelper("'PHYA'AM");
|
|
tstHelper("PHYAD");
|
|
tstHelper("'PHYAD");
|
|
tstHelper("PHYAG");
|
|
tstHelper("'PHYAG");
|
|
tstHelper("PHYAGG");
|
|
tstHelper("PHYAGS");
|
|
tstHelper("PHYAL");
|
|
tstHelper("PHYAM");
|
|
tstHelper("PHYAN");
|
|
tstHelper("'PHYAN");
|
|
tstHelper("PHYANG");
|
|
tstHelper("'PHYANG");
|
|
tstHelper("'PHYANGS");
|
|
tstHelper("PHYAR");
|
|
tstHelper("'PHYAR");
|
|
tstHelper("PHYAS");
|
|
tstHelper("'PHYAS");
|
|
tstHelper("PHYE");
|
|
tstHelper("'PHYE");
|
|
tstHelper("PHYE'AM");
|
|
tstHelper("PHYED");
|
|
tstHelper("'PHYE'I");
|
|
tstHelper("PHYE'I");
|
|
tstHelper("PHYEL");
|
|
tstHelper("PHYEM");
|
|
tstHelper("PHYEN");
|
|
tstHelper("PHYENG");
|
|
tstHelper("PHYE'O");
|
|
tstHelper("PHYER");
|
|
tstHelper("'PHYER");
|
|
tstHelper("PHYES");
|
|
tstHelper("'PHYES");
|
|
tstHelper("PHYI");
|
|
tstHelper("'PHYI");
|
|
tstHelper("PHYI'AM");
|
|
tstHelper("PHYIGS");
|
|
tstHelper("PHYI'I");
|
|
tstHelper("PHYI'I'AM");
|
|
tstHelper("PHYIM");
|
|
tstHelper("PHYIN");
|
|
tstHelper("'PHYIN");
|
|
tstHelper("PHYIN");
|
|
tstHelper("PHYING");
|
|
tstHelper("PHYI'O");
|
|
tstHelper("PHYIR");
|
|
tstHelper("'PHYIR");
|
|
tstHelper("PHYIS");
|
|
tstHelper("'PHYIS");
|
|
tstHelper("'PHYO");
|
|
tstHelper("'PHYO'AM");
|
|
tstHelper("PHYOGS");
|
|
tstHelper("'PHYON");
|
|
tstHelper("PHYOR");
|
|
tstHelper("PHYUG");
|
|
tstHelper("PHYUGS");
|
|
tstHelper("PHYUNG");
|
|
tstHelper("'PHYUNG");
|
|
tstHelper("PHYUNGS");
|
|
tstHelper("PHYUR");
|
|
tstHelper("PI");
|
|
tstHelper("PID");
|
|
tstHelper("PIDHA");
|
|
tstHelper("PIN");
|
|
tstHelper("PING");
|
|
tstHelper("PING-KA");
|
|
tstHelper("PI-NGKA");
|
|
tstHelper("PING-KA");
|
|
tstHelper("PING-KA'I");
|
|
tstHelper("PINGKA'I");
|
|
tstHelper("PIR");
|
|
tstHelper("PIS");
|
|
tstHelper("PO");
|
|
tstHelper("'PO");
|
|
tstHelper("PO'AM");
|
|
tstHelper("PO'ANG");
|
|
tstHelper("POD");
|
|
tstHelper("POE");
|
|
tstHelper("POG");
|
|
tstHelper("POGS");
|
|
tstHelper("'POGS");
|
|
tstHelper("PO'I");
|
|
tstHelper("PO'ID");
|
|
tstHelper("PO'IG");
|
|
tstHelper("PO'I'O");
|
|
tstHelper("POM");
|
|
tstHelper("PO'O");
|
|
tstHelper("POR");
|
|
tstHelper("POS");
|
|
tstHelper("PRA");
|
|
tstHelper("PR'A");
|
|
tstHelper("PRAD");
|
|
tstHelper("PRADZNY'A");
|
|
tstHelper("PRAG");
|
|
tstHelper("'PREL");
|
|
tstHelper("PRGYUN");
|
|
tstHelper("PRi");
|
|
tstHelper("PRI");
|
|
tstHelper("PRIS");
|
|
tstHelper("PRiTZTSVA");
|
|
tstHelper("PRO");
|
|
tstHelper("PROS");
|
|
tstHelper("PRU");
|
|
tstHelper("PRUGS");
|
|
tstHelper("PU");
|
|
tstHelper("P'U");
|
|
tstHelper("PUD");
|
|
tstHelper("PU'I");
|
|
tstHelper("PU-KKA");
|
|
tstHelper("PUL");
|
|
tstHelper("PUndA");
|
|
tstHelper("PUnYA");
|
|
tstHelper("PUnYE");
|
|
tstHelper("PUR");
|
|
tstHelper("P'UrnA");
|
|
tstHelper("P'URnnA");
|
|
tstHelper("PUS");
|
|
tstHelper("PUSTA");
|
|
tstHelper("PUSTI");
|
|
tstHelper("PYA");
|
|
tstHelper("PYAD");
|
|
tstHelper("PYED");
|
|
tstHelper("PYIN");
|
|
tstHelper("PYIR");
|
|
tstHelper("PYUNG");
|
|
tstHelper("RA");
|
|
tstHelper("R'A");
|
|
tstHelper("RAB");
|
|
tstHelper("RABS");
|
|
tstHelper("RAD");
|
|
tstHelper("RADV");
|
|
tstHelper("RADVA");
|
|
tstHelper("RA-DWA");
|
|
tstHelper("RAG");
|
|
tstHelper("RAGB");
|
|
tstHelper("RAGS");
|
|
tstHelper("RA'I");
|
|
tstHelper("RAKshA");
|
|
tstHelper("RAKshI");
|
|
tstHelper("RAL");
|
|
tstHelper("RALI");
|
|
tstHelper("RAM");
|
|
tstHelper("RAMS");
|
|
tstHelper("RAN");
|
|
tstHelper("RAnAdA");
|
|
tstHelper("RAndA");
|
|
tstHelper("RANG");
|
|
tstHelper("RANGS");
|
|
tstHelper("RAnn'A");
|
|
tstHelper("RANYDZA");
|
|
tstHelper("RA'O");
|
|
tstHelper("RAP");
|
|
tstHelper("RAPAR");
|
|
tstHelper("RAR");
|
|
tstHelper("RAS");
|
|
tstHelper("RATNA");
|
|
tstHelper("RATNA'I");
|
|
tstHelper("RBA");
|
|
tstHelper("RBAB");
|
|
tstHelper("RBAD");
|
|
tstHelper("RBANG");
|
|
tstHelper("RBBA");
|
|
tstHelper("RBB'A");
|
|
tstHelper("RBEG");
|
|
tstHelper("RBOD");
|
|
tstHelper("RDA");
|
|
tstHelper("RDAB");
|
|
tstHelper("RDA'I");
|
|
tstHelper("RDAL");
|
|
tstHelper("RDAM");
|
|
tstHelper("RDAN");
|
|
tstHelper("RDE");
|
|
tstHelper("RDEB");
|
|
tstHelper("RDEBS");
|
|
tstHelper("RDEG");
|
|
tstHelper("RDEGS");
|
|
tstHelper("RDENG");
|
|
tstHelper("RDE'U");
|
|
tstHelper("RDIB");
|
|
tstHelper("RDO");
|
|
tstHelper("RDO");
|
|
tstHelper("RDOB");
|
|
tstHelper("RDOBS");
|
|
tstHelper("RDOD");
|
|
tstHelper("RDOG");
|
|
tstHelper("RDOGS");
|
|
tstHelper("RDO'I");
|
|
tstHelper("RDOL");
|
|
tstHelper("RDON");
|
|
tstHelper("RDOR");
|
|
tstHelper("RDOS");
|
|
tstHelper("RDU");
|
|
tstHelper("RDUB");
|
|
tstHelper("RDUG");
|
|
tstHelper("RDUGS");
|
|
tstHelper("RDUL");
|
|
tstHelper("RDUM");
|
|
tstHelper("RDUNG");
|
|
tstHelper("RDUNGS");
|
|
tstHelper("RDU'O");
|
|
tstHelper("RDUR");
|
|
tstHelper("RDUS");
|
|
tstHelper("RDVI");
|
|
tstHelper("RDZA");
|
|
tstHelper("RDZ'A");
|
|
tstHelper("RDZAB");
|
|
tstHelper("RDZAGS");
|
|
tstHelper("RDZA'I");
|
|
tstHelper("RDZANGS");
|
|
tstHelper("RDZAS");
|
|
tstHelper("RDZE");
|
|
tstHelper("RDZE'U");
|
|
tstHelper("RDZE'U'I");
|
|
tstHelper("RDZI");
|
|
tstHelper("RDZI'AM");
|
|
tstHelper("RDZID");
|
|
tstHelper("RDZI'I");
|
|
tstHelper("RDZIM");
|
|
tstHelper("RDZING");
|
|
tstHelper("RDZIR");
|
|
tstHelper("RDZIS");
|
|
tstHelper("RDZI'U");
|
|
tstHelper("RDZOB");
|
|
tstHelper("RDZOD");
|
|
tstHelper("RDZOG");
|
|
tstHelper("RDZOGS");
|
|
tstHelper("RDZONG");
|
|
tstHelper("RDZONGS");
|
|
tstHelper("RDZU");
|
|
tstHelper("'RDZU");
|
|
tstHelper("RDZUB");
|
|
tstHelper("RDZUBS");
|
|
tstHelper("RDZUD");
|
|
tstHelper("RDZUN");
|
|
tstHelper("RDZU'O");
|
|
tstHelper("RDZUS");
|
|
tstHelper("RE");
|
|
tstHelper("RE'AM");
|
|
tstHelper("RE'ANG");
|
|
tstHelper("RED");
|
|
tstHelper("REG");
|
|
tstHelper("REGS");
|
|
tstHelper("RE'I");
|
|
tstHelper("REL");
|
|
tstHelper("REM");
|
|
tstHelper("REN");
|
|
tstHelper("RENDRA");
|
|
tstHelper("RENG");
|
|
tstHelper("RENGS");
|
|
tstHelper("RE'O");
|
|
tstHelper("RER");
|
|
tstHelper("RES");
|
|
tstHelper("RGA");
|
|
tstHelper("RGAD");
|
|
tstHelper("RGA'I");
|
|
tstHelper("RGAL");
|
|
tstHelper("RGAN");
|
|
tstHelper("RGANG");
|
|
tstHelper("RGA'O");
|
|
tstHelper("RGAS");
|
|
tstHelper("RGHO");
|
|
tstHelper("RGO'AM");
|
|
tstHelper("RGOD");
|
|
tstHelper("RGOL");
|
|
tstHelper("RGON");
|
|
tstHelper("RGOS");
|
|
tstHelper("RGU");
|
|
tstHelper("RGUD");
|
|
tstHelper("RGU'I");
|
|
tstHelper("RGUN");
|
|
tstHelper("RGUNG");
|
|
tstHelper("RGUR");
|
|
tstHelper("RGYA");
|
|
tstHelper("RGYA'AM");
|
|
tstHelper("RGYA'ANG");
|
|
tstHelper("RGYAB");
|
|
tstHelper("RGYAD");
|
|
tstHelper("RGYAGS");
|
|
tstHelper("RGYA'I");
|
|
tstHelper("RGYAL");
|
|
tstHelper("RGYAM");
|
|
tstHelper("RGYAN");
|
|
tstHelper("RGYANG");
|
|
tstHelper("RGYANGS");
|
|
tstHelper("RGYA'O");
|
|
tstHelper("RGYAR");
|
|
tstHelper("RGYAS");
|
|
tstHelper("RGYASD");
|
|
tstHelper("RGYASKYI");
|
|
tstHelper("RGYEL");
|
|
tstHelper("RGYEN");
|
|
tstHelper("RGYI'U");
|
|
tstHelper("RGYOB");
|
|
tstHelper("RGYU");
|
|
tstHelper("RGYU'AM");
|
|
tstHelper("RGYU'ANG");
|
|
tstHelper("RGYUB");
|
|
tstHelper("RGYUD");
|
|
tstHelper("RGYUG");
|
|
tstHelper("RGYUGS");
|
|
tstHelper("RGYU'I");
|
|
tstHelper("RGYUN");
|
|
tstHelper("RGYU'O");
|
|
tstHelper("RGYUR");
|
|
tstHelper("RGYUS");
|
|
tstHelper("RHA");
|
|
tstHelper("RI");
|
|
tstHelper("R'I");
|
|
tstHelper("RI'AM");
|
|
tstHelper("RIB");
|
|
tstHelper("RID");
|
|
tstHelper("RIG");
|
|
tstHelper("RiGS");
|
|
tstHelper("RIGS");
|
|
tstHelper("RI'I");
|
|
tstHelper("RIL");
|
|
tstHelper("RIM");
|
|
tstHelper("RIMS");
|
|
tstHelper("RIN");
|
|
tstHelper("RING");
|
|
tstHelper("RINGS");
|
|
tstHelper("RI'O");
|
|
tstHelper("RIR");
|
|
tstHelper("RIS");
|
|
tstHelper("RIshA");
|
|
tstHelper("RJAM");
|
|
tstHelper("RJAS");
|
|
tstHelper("RJE");
|
|
tstHelper("RJE");
|
|
tstHelper("RJE'ANG");
|
|
tstHelper("RJED");
|
|
tstHelper("RJEDS");
|
|
tstHelper("RJE'I");
|
|
tstHelper("RJEN");
|
|
tstHelper("RJER");
|
|
tstHelper("RJES");
|
|
tstHelper("RJE'U");
|
|
tstHelper("RJE'U'I");
|
|
tstHelper("RJI");
|
|
tstHelper("RJID");
|
|
tstHelper("'RJID");
|
|
tstHelper("RJING");
|
|
tstHelper("RJIS");
|
|
tstHelper("RJOB");
|
|
tstHelper("RJOD");
|
|
tstHelper("RJOGS");
|
|
tstHelper("RJU");
|
|
tstHelper("RJUD");
|
|
tstHelper("RKA");
|
|
tstHelper("RKAD");
|
|
tstHelper("RKAM");
|
|
tstHelper("RKAN");
|
|
tstHelper("RKANG");
|
|
tstHelper("RKE");
|
|
tstHelper("RKEB");
|
|
tstHelper("RKED");
|
|
tstHelper("RKO");
|
|
tstHelper("RKOM");
|
|
tstHelper("RKOR");
|
|
tstHelper("RKOS");
|
|
tstHelper("RKU");
|
|
tstHelper("RKUB");
|
|
tstHelper("RKUM");
|
|
tstHelper("RKUN");
|
|
tstHelper("RKUR");
|
|
tstHelper("RKUS");
|
|
tstHelper("RKYA");
|
|
tstHelper("RKYAL");
|
|
tstHelper("RKYAN");
|
|
tstHelper("RKYANG");
|
|
tstHelper("RKYAS");
|
|
tstHelper("RKYE");
|
|
tstHelper("RKYEN");
|
|
tstHelper("RKYONG");
|
|
tstHelper("RLAB");
|
|
tstHelper("RLABS");
|
|
tstHelper("RLAG");
|
|
tstHelper("RLAM");
|
|
tstHelper("RLAN");
|
|
tstHelper("RLANG");
|
|
tstHelper("RLANGS");
|
|
tstHelper("RLINGS");
|
|
tstHelper("RLO");
|
|
tstHelper("RLOB");
|
|
tstHelper("RLOBS");
|
|
tstHelper("RLOG");
|
|
tstHelper("RLOM");
|
|
tstHelper("RLOMS");
|
|
tstHelper("RLON");
|
|
tstHelper("RLUBS");
|
|
tstHelper("RLUGS");
|
|
tstHelper("RLUNG");
|
|
tstHelper("RLUS");
|
|
tstHelper("RMA");
|
|
tstHelper("RMAD");
|
|
tstHelper("RMAG");
|
|
tstHelper("RMA'I");
|
|
tstHelper("RMAN");
|
|
tstHelper("RMANG");
|
|
tstHelper("RMAR");
|
|
tstHelper("RMAS");
|
|
tstHelper("RME");
|
|
tstHelper("RMED");
|
|
tstHelper("RMEG");
|
|
tstHelper("RMEL");
|
|
tstHelper("RMEN");
|
|
tstHelper("RMI");
|
|
tstHelper("RMID");
|
|
tstHelper("RMIG");
|
|
tstHelper("RMIS");
|
|
tstHelper("RMMA");
|
|
tstHelper("RMO");
|
|
tstHelper("RMOD");
|
|
tstHelper("RMON");
|
|
tstHelper("RMONGS");
|
|
tstHelper("RMOS");
|
|
tstHelper("RMTHONG");
|
|
tstHelper("RMU");
|
|
tstHelper("RMUGS");
|
|
tstHelper("RMYA");
|
|
tstHelper("RNA");
|
|
tstHelper("RNAB");
|
|
tstHelper("RNABS");
|
|
tstHelper("RNAG");
|
|
tstHelper("RNAGS");
|
|
tstHelper("RNA'I");
|
|
tstHelper("RNAL");
|
|
tstHelper("RNALM");
|
|
tstHelper("RNAM");
|
|
tstHelper("'RNAM");
|
|
tstHelper("RNAMPAMI");
|
|
tstHelper("RNAMPAR");
|
|
tstHelper("RNAMS");
|
|
tstHelper("RNANG");
|
|
tstHelper("RNAR");
|
|
tstHelper("RNAS");
|
|
tstHelper("RNASM");
|
|
tstHelper("RndA");
|
|
tstHelper("Rnd'I");
|
|
tstHelper("RNGA");
|
|
tstHelper("RNGA'AM");
|
|
tstHelper("RNGAD");
|
|
tstHelper("RNGA'I");
|
|
tstHelper("RNGAL");
|
|
tstHelper("RNGAM");
|
|
tstHelper("RNGAMS");
|
|
tstHelper("RNGAN");
|
|
tstHelper("RNGAR");
|
|
tstHelper("RNGE'I");
|
|
tstHelper("RNGES");
|
|
tstHelper("RNGO");
|
|
tstHelper("RNGOD");
|
|
tstHelper("RNGOG");
|
|
tstHelper("RNGOGS");
|
|
tstHelper("RNGON");
|
|
tstHelper("RNGOR");
|
|
tstHelper("RNGOS");
|
|
tstHelper("RNGU");
|
|
tstHelper("RNGUB");
|
|
tstHelper("RNGU'I");
|
|
tstHelper("RNGUL");
|
|
tstHelper("RNGUR");
|
|
tstHelper("RNGUS");
|
|
tstHelper("RNL");
|
|
tstHelper("RNO");
|
|
tstHelper("RNOB");
|
|
tstHelper("RNON");
|
|
tstHelper("RNYAD");
|
|
tstHelper("RNYANG");
|
|
tstHelper("RNYDZA");
|
|
tstHelper("RNY-DZA");
|
|
tstHelper("RNYED");
|
|
tstHelper("RNYEN");
|
|
tstHelper("RNYENG");
|
|
tstHelper("RNYI");
|
|
tstHelper("RNYID");
|
|
tstHelper("RNYIL");
|
|
tstHelper("RNYING");
|
|
tstHelper("RNYINGS");
|
|
tstHelper("RNYIS");
|
|
tstHelper("RNYOG");
|
|
tstHelper("RNYOGS");
|
|
tstHelper("RNYONG");
|
|
tstHelper("RNYONGS");
|
|
tstHelper("RNYOS");
|
|
tstHelper("RO");
|
|
tstHelper("RO'AM");
|
|
tstHelper("RO'ANG");
|
|
tstHelper("ROD");
|
|
tstHelper("ROG");
|
|
tstHelper("ROGS");
|
|
tstHelper("RO'I");
|
|
tstHelper("ROL");
|
|
tstHelper("ROM");
|
|
tstHelper("RON");
|
|
tstHelper("RONG");
|
|
tstHelper("RO'O");
|
|
tstHelper("ROR");
|
|
tstHelper("ROS");
|
|
tstHelper("RTA");
|
|
tstHelper("RTA'AM");
|
|
tstHelper("RTAB");
|
|
tstHelper("RTABS");
|
|
tstHelper("RTAG");
|
|
tstHelper("RTAGS");
|
|
tstHelper("RTA'I");
|
|
tstHelper("RTAN");
|
|
tstHelper("RTANG");
|
|
tstHelper("RTAR");
|
|
tstHelper("RTAS");
|
|
tstHelper("RTE");
|
|
tstHelper("RTEGS");
|
|
tstHelper("RTEN");
|
|
tstHelper("RTE'U");
|
|
tstHelper("RTI");
|
|
tstHelper("RTIB");
|
|
tstHelper("RTIG");
|
|
tstHelper("RTIN");
|
|
tstHelper("RTING");
|
|
tstHelper("RTO");
|
|
tstHelper("RTOD");
|
|
tstHelper("RTOG");
|
|
tstHelper("RTOGS");
|
|
tstHelper("RTOL");
|
|
tstHelper("RTON");
|
|
tstHelper("RTONG");
|
|
tstHelper("RTUG");
|
|
tstHelper("RTUL");
|
|
tstHelper("RTUN");
|
|
tstHelper("RTZA");
|
|
tstHelper("RTZAB");
|
|
tstHelper("RTZABS");
|
|
tstHelper("RTZAD");
|
|
tstHelper("RTZA'I");
|
|
tstHelper("RTZAL");
|
|
tstHelper("RTZAMS");
|
|
tstHelper("RTZANG");
|
|
tstHelper("RTZANGS");
|
|
tstHelper("RTZAR");
|
|
tstHelper("RTZE");
|
|
tstHelper("RTZEB");
|
|
tstHelper("RTZED");
|
|
tstHelper("RTZEG");
|
|
tstHelper("RTZE'I");
|
|
tstHelper("RTZEN");
|
|
tstHelper("RTZENGS");
|
|
tstHelper("RTZE'O");
|
|
tstHelper("RTZER");
|
|
tstHelper("RTZES");
|
|
tstHelper("RTZI");
|
|
tstHelper("RTZI'AM");
|
|
tstHelper("RTZIB");
|
|
tstHelper("RTZIBS");
|
|
tstHelper("RTZIG");
|
|
tstHelper("RTZIGS");
|
|
tstHelper("RTZI'I");
|
|
tstHelper("RTZI'O");
|
|
tstHelper("RTZIR");
|
|
tstHelper("RTZIS");
|
|
tstHelper("RTZOD");
|
|
tstHelper("RTZOG");
|
|
tstHelper("RTZOL");
|
|
tstHelper("RTZOM");
|
|
tstHelper("RTZOMS");
|
|
tstHelper("RTZON");
|
|
tstHelper("RTZU");
|
|
tstHelper("RTZUB");
|
|
tstHelper("RTZUM");
|
|
tstHelper("RTZVA");
|
|
tstHelper("RTZVA");
|
|
tstHelper("RTZVA'AM");
|
|
tstHelper("RTZVA'I");
|
|
tstHelper("RTZVA'O");
|
|
tstHelper("RTZVAS");
|
|
tstHelper("RTZVI");
|
|
tstHelper("RTZWA");
|
|
tstHelper("RTZWA'AM");
|
|
tstHelper("RTZWA'I");
|
|
tstHelper("RTZWAS");
|
|
tstHelper("RU");
|
|
tstHelper("R'U");
|
|
tstHelper("RU'AM");
|
|
tstHelper("RU'ANG");
|
|
tstHelper("RUB");
|
|
tstHelper("RUD");
|
|
tstHelper("RU'I");
|
|
tstHelper("RUL");
|
|
tstHelper("RUM");
|
|
tstHelper("RUN");
|
|
tstHelper("RUNG");
|
|
tstHelper("RUNGS");
|
|
tstHelper("RU'O");
|
|
tstHelper("RUS");
|
|
tstHelper("RUT");
|
|
tstHelper("RVA");
|
|
tstHelper("RVA'I");
|
|
tstHelper("RVAS");
|
|
tstHelper("RWA");
|
|
tstHelper("RWA'ANG");
|
|
tstHelper("RWA'I");
|
|
tstHelper("RYA");
|
|
tstHelper("R+YA");
|
|
tstHelper("RY'A");
|
|
tstHelper("R+YA'I");
|
|
tstHelper("RYA'I");
|
|
tstHelper("RYAS");
|
|
tstHelper("R+Y'I");
|
|
tstHelper("RYYA");
|
|
tstHelper("RZDOGS");
|
|
tstHelper("S");
|
|
tstHelper("SA");
|
|
tstHelper("S'A");
|
|
tstHelper("SA'");
|
|
tstHelper("SA'AM");
|
|
tstHelper("SA'ANG");
|
|
tstHelper("SAB");
|
|
tstHelper("SAD");
|
|
tstHelper("SADDHARMA");
|
|
tstHelper("SAG");
|
|
tstHelper("SAHA");
|
|
tstHelper("S'A-H'A");
|
|
tstHelper("SA-HO");
|
|
tstHelper("SA'I");
|
|
tstHelper("SAKD");
|
|
tstHelper("SAL");
|
|
tstHelper("SAm");
|
|
tstHelper("SAM");
|
|
tstHelper("S'AM");
|
|
tstHelper("SAmBHA");
|
|
tstHelper("SAMS");
|
|
tstHelper("SAN");
|
|
tstHelper("SANG");
|
|
tstHelper("SANG-GHA");
|
|
tstHelper("SANGS");
|
|
tstHelper("SANS");
|
|
tstHelper("SA'O");
|
|
tstHelper("SAPTA");
|
|
tstHelper("SAR");
|
|
tstHelper("S'AR");
|
|
tstHelper("SARBA");
|
|
tstHelper("SARDZA");
|
|
tstHelper("SAS");
|
|
tstHelper("SBA");
|
|
tstHelper("SBABS");
|
|
tstHelper("SBAD");
|
|
tstHelper("SBAGS");
|
|
tstHelper("SBA'I");
|
|
tstHelper("SBAL");
|
|
tstHelper("SBAM");
|
|
tstHelper("SBAMS");
|
|
tstHelper("SBANG");
|
|
tstHelper("SBANGS");
|
|
tstHelper("SBA'O");
|
|
tstHelper("SBAR");
|
|
tstHelper("SBAS");
|
|
tstHelper("SBED");
|
|
tstHelper("SBENGS");
|
|
tstHelper("SBO");
|
|
tstHelper("SBOBS");
|
|
tstHelper("SBOGS");
|
|
tstHelper("SBOM");
|
|
tstHelper("SBOMS");
|
|
tstHelper("SBOR");
|
|
tstHelper("SBOS");
|
|
tstHelper("SBRA");
|
|
tstHelper("SBRAD");
|
|
tstHelper("SBRA'I");
|
|
tstHelper("SBRAM");
|
|
tstHelper("SBRAN");
|
|
tstHelper("SBRANG");
|
|
tstHelper("SBRAS");
|
|
tstHelper("SBREBS");
|
|
tstHelper("SBREL");
|
|
tstHelper("SBRENG");
|
|
tstHelper("SBRENGS");
|
|
tstHelper("SBRIN");
|
|
tstHelper("SBRING");
|
|
tstHelper("SBRO");
|
|
tstHelper("SBRO'AM");
|
|
tstHelper("SBRON");
|
|
tstHelper("SBRO'O");
|
|
tstHelper("SBRU");
|
|
tstHelper("SBRUG");
|
|
tstHelper("SBRUGS");
|
|
tstHelper("SBRUL");
|
|
tstHelper("SBRUM");
|
|
tstHelper("SBRUS");
|
|
tstHelper("SBU");
|
|
tstHelper("SBUB");
|
|
tstHelper("SBUBS");
|
|
tstHelper("SBUD");
|
|
tstHelper("SBUG");
|
|
tstHelper("SBUN");
|
|
tstHelper("SBUR");
|
|
tstHelper("SBYAD");
|
|
tstHelper("SBYAN");
|
|
tstHelper("SBYANG");
|
|
tstHelper("SBYANGS");
|
|
tstHelper("SBYAR");
|
|
tstHelper("SBYE");
|
|
tstHelper("SBYED");
|
|
tstHelper("SBYEN");
|
|
tstHelper("SBYI");
|
|
tstHelper("SBYIB");
|
|
tstHelper("SBYI'I");
|
|
tstHelper("SBYIL");
|
|
tstHelper("SBYIN");
|
|
tstHelper("SBYIR");
|
|
tstHelper("SBYO");
|
|
tstHelper("SBYOD");
|
|
tstHelper("SBYOMS");
|
|
tstHelper("SBYON");
|
|
tstHelper("SBYONG");
|
|
tstHelper("SBYONGS");
|
|
tstHelper("SBYOR");
|
|
tstHelper("SBYOS");
|
|
tstHelper("SBYUG");
|
|
tstHelper("SBYUGS");
|
|
tstHelper("SCAL");
|
|
tstHelper("SDA");
|
|
tstHelper("SDAD");
|
|
tstHelper("SDAGS");
|
|
tstHelper("SDAM");
|
|
tstHelper("SDAN");
|
|
tstHelper("SDANG");
|
|
tstHelper("SDANGS");
|
|
tstHelper("SDAR");
|
|
tstHelper("SDAS");
|
|
tstHelper("SDE");
|
|
tstHelper("SDE'AM");
|
|
tstHelper("SDEB");
|
|
tstHelper("SDEB");
|
|
tstHelper("SDEG");
|
|
tstHelper("SDE'I");
|
|
tstHelper("SDEM");
|
|
tstHelper("SDENG");
|
|
tstHelper("SDE'O");
|
|
tstHelper("SDER");
|
|
tstHelper("SDES");
|
|
tstHelper("SDE'U");
|
|
tstHelper("SDE'U'I");
|
|
tstHelper("SDIG");
|
|
tstHelper("SDIGS");
|
|
tstHelper("SDINGS");
|
|
tstHelper("SDO");
|
|
tstHelper("SDOD");
|
|
tstHelper("SDOG");
|
|
tstHelper("SDOGS");
|
|
tstHelper("SDO'I");
|
|
tstHelper("SDOM");
|
|
tstHelper("SDOMS");
|
|
tstHelper("SDON");
|
|
tstHelper("SDONG");
|
|
tstHelper("SDOR");
|
|
tstHelper("SDOS");
|
|
tstHelper("SDU");
|
|
tstHelper("SDUD");
|
|
tstHelper("SDUG");
|
|
tstHelper("SDUM");
|
|
tstHelper("SDUMS");
|
|
tstHelper("SDUN");
|
|
tstHelper("SDUR");
|
|
tstHelper("SDUS");
|
|
tstHelper("SE");
|
|
tstHelper("SED");
|
|
tstHelper("SEEMS");
|
|
tstHelper("SEG");
|
|
tstHelper("SEGS");
|
|
tstHelper("SEHS");
|
|
tstHelper("SE'I");
|
|
tstHelper("SEIS");
|
|
tstHelper("SEL");
|
|
tstHelper("SEM");
|
|
tstHelper("SEMS");
|
|
tstHelper("SEN");
|
|
tstHelper("SENG");
|
|
tstHelper("SENG-");
|
|
tstHelper("SENG-DGE'I");
|
|
tstHelper("SEN-GE");
|
|
tstHelper("SENGEGA'I");
|
|
tstHelper("SENGGE");
|
|
tstHelper("SENG-GE");
|
|
tstHelper("SENG-GE");
|
|
tstHelper("SENGGE'AM");
|
|
tstHelper("SENG-GE'I");
|
|
tstHelper("SENGGE'I");
|
|
tstHelper("SENGGES");
|
|
tstHelper("SENG-GES");
|
|
tstHelper("SER");
|
|
tstHelper("SESM");
|
|
tstHelper("SE'U");
|
|
tstHelper("SE'U'I");
|
|
tstHelper("SGA");
|
|
tstHelper("SGAD");
|
|
tstHelper("SGA'I");
|
|
tstHelper("SGAL");
|
|
tstHelper("SGAM");
|
|
tstHelper("SGANG");
|
|
tstHelper("SGAR");
|
|
tstHelper("SGEG");
|
|
tstHelper("SGE'U");
|
|
tstHelper("SGO");
|
|
tstHelper("SGO'AM");
|
|
tstHelper("SGOG");
|
|
tstHelper("SGO'I");
|
|
tstHelper("SGOM");
|
|
tstHelper("SGOMS");
|
|
tstHelper("SGONG");
|
|
tstHelper("SGO'O");
|
|
tstHelper("SGOR");
|
|
tstHelper("SGOS");
|
|
tstHelper("SGRA");
|
|
tstHelper("SGRA'AM");
|
|
tstHelper("SGRA'ANG");
|
|
tstHelper("SGRAB");
|
|
tstHelper("SGRAG");
|
|
tstHelper("SGRA'I");
|
|
tstHelper("SGRAL");
|
|
tstHelper("SGRANG");
|
|
tstHelper("SGRA'O");
|
|
tstHelper("SGRAR");
|
|
tstHelper("SGRAS");
|
|
tstHelper("SGRE");
|
|
tstHelper("SGREGS");
|
|
tstHelper("SGREN");
|
|
tstHelper("SGRENG");
|
|
tstHelper("SGRENGS");
|
|
tstHelper("SGRIB");
|
|
tstHelper("SGRIG");
|
|
tstHelper("SGRIL");
|
|
tstHelper("SGRIM");
|
|
tstHelper("SGRIMS");
|
|
tstHelper("SGRIN");
|
|
tstHelper("SGRO");
|
|
tstHelper("SGROG");
|
|
tstHelper("SGROGS");
|
|
tstHelper("SGROL");
|
|
tstHelper("SGROM");
|
|
tstHelper("SGRON");
|
|
tstHelper("SGROS");
|
|
tstHelper("SGRU");
|
|
tstHelper("SGRUB");
|
|
tstHelper("SGRUBS");
|
|
tstHelper("SGRUL");
|
|
tstHelper("SGRUM");
|
|
tstHelper("SGRUN");
|
|
tstHelper("SGRUNG");
|
|
tstHelper("SGUGS");
|
|
tstHelper("SGUL");
|
|
tstHelper("SGUR");
|
|
tstHelper("SGYE");
|
|
tstHelper("SGYED");
|
|
tstHelper("SGYEGS");
|
|
tstHelper("SGYEL");
|
|
tstHelper("SGYE'U");
|
|
tstHelper("SGYI");
|
|
tstHelper("SGYID");
|
|
tstHelper("SGYIGS");
|
|
tstHelper("SGYIN");
|
|
tstHelper("SGYING");
|
|
tstHelper("SGYOGS");
|
|
tstHelper("SGYONG");
|
|
tstHelper("SGYOR");
|
|
tstHelper("SGYU");
|
|
tstHelper("SGYU'AM");
|
|
tstHelper("SGYU'ANG");
|
|
tstHelper("SGYUG");
|
|
tstHelper("SGYU'I");
|
|
tstHelper("SGYUR");
|
|
tstHelper("SGYUS");
|
|
tstHelper("shA");
|
|
tstHelper("sh'A");
|
|
tstHelper("sHA");
|
|
tstHelper("SHA");
|
|
tstHelper("SH'A");
|
|
tstHelper("SHA'");
|
|
tstHelper("SHA'AM");
|
|
tstHelper("SHA'ANG");
|
|
tstHelper("SHAD");
|
|
tstHelper("SHAG");
|
|
tstHelper("SHAGS");
|
|
tstHelper("shA'I");
|
|
tstHelper("SHA'I");
|
|
tstHelper("shAK");
|
|
tstHelper("SH'A-KA");
|
|
tstHelper("SH'AKYA");
|
|
tstHelper("SH'A-KYA");
|
|
tstHelper("SHA'KYA");
|
|
tstHelper("SHA'-KYA");
|
|
tstHelper("SH'A-KYA'I");
|
|
tstHelper("SH'A-KYA'I");
|
|
tstHelper("SH'AKYA'I");
|
|
tstHelper("SHA'KYA'I");
|
|
tstHelper("SHAKYA'I");
|
|
tstHelper("SH'A-KYAS");
|
|
tstHelper("SH'AKYATHUB");
|
|
tstHelper("SH'AKYI");
|
|
tstHelper("SH'A-KY'I");
|
|
tstHelper("SHAL");
|
|
tstHelper("SHAM");
|
|
tstHelper("SH'AM");
|
|
tstHelper("SH'AMBA'I'I");
|
|
tstHelper("SH'AMBA'IRA");
|
|
tstHelper("SHAMBHI'I");
|
|
tstHelper("SH'AMB'I");
|
|
tstHelper("SH'AMB'I'I");
|
|
tstHelper("SH'AMB'IR");
|
|
tstHelper("SH'AMB'IRA");
|
|
tstHelper("SHAMS");
|
|
tstHelper("SHAn");
|
|
tstHelper("SHAN");
|
|
tstHelper("SHANG");
|
|
tstHelper("SHANGS");
|
|
tstHelper("SH'ANTA");
|
|
tstHelper("SH'A-NTE");
|
|
tstHelper("SH'ANTI");
|
|
tstHelper("SHANTIm");
|
|
tstHelper("SH'ANTIm");
|
|
tstHelper("sh'APAn");
|
|
tstHelper("SHAR");
|
|
tstHelper("SH'ARI'I");
|
|
tstHelper("SHAS");
|
|
tstHelper("SHATA'I");
|
|
tstHelper("SHD");
|
|
tstHelper("SHE");
|
|
tstHelper("SHE'AM");
|
|
tstHelper("SHED");
|
|
tstHelper("SHEG");
|
|
tstHelper("SHEGS");
|
|
tstHelper("SHEL");
|
|
tstHelper("SHEMS");
|
|
tstHelper("SHEN");
|
|
tstHelper("SHENG");
|
|
tstHelper("SHER");
|
|
tstHelper("SHER");
|
|
tstHelper("SHES");
|
|
tstHelper("shI");
|
|
tstHelper("sHI");
|
|
tstHelper("SHI");
|
|
tstHelper("SH'I");
|
|
tstHelper("SHI'AM");
|
|
tstHelper("SHI'ANG");
|
|
tstHelper("SHIB");
|
|
tstHelper("SHID");
|
|
tstHelper("SHIG");
|
|
tstHelper("SHIGS");
|
|
tstHelper("SHI'I");
|
|
tstHelper("SHIL");
|
|
tstHelper("SHIN");
|
|
tstHelper("SHING");
|
|
tstHelper("SHINGS");
|
|
tstHelper("SHI'O");
|
|
tstHelper("SHIR");
|
|
tstHelper("SHIRshA");
|
|
tstHelper("SHIRshAD");
|
|
tstHelper("SHIS");
|
|
tstHelper("SH'KA");
|
|
tstHelper("SH'KYA");
|
|
tstHelper("SHLO");
|
|
tstHelper("SHLOO");
|
|
tstHelper("SHMA");
|
|
tstHelper("SHO");
|
|
tstHelper("S+HO");
|
|
tstHelper("SHOB");
|
|
tstHelper("SHOD");
|
|
tstHelper("SHOG");
|
|
tstHelper("SHOGS");
|
|
tstHelper("SHOL");
|
|
tstHelper("SHOM");
|
|
tstHelper("SHOMS");
|
|
tstHelper("SHON");
|
|
tstHelper("SHONG");
|
|
tstHelper("SHOR");
|
|
tstHelper("SHOS");
|
|
tstHelper("SHRA");
|
|
tstHelper("SHRADDHA");
|
|
tstHelper("SHRADDH'A");
|
|
tstHelper("SHR'I");
|
|
tstHelper("SHR'I'I");
|
|
tstHelper("SHRI'I");
|
|
tstHelper("SHRim");
|
|
tstHelper("SHRU");
|
|
tstHelper("shtA");
|
|
tstHelper("shtE");
|
|
tstHelper("shthA'I");
|
|
tstHelper("shtRA");
|
|
tstHelper("SHU");
|
|
tstHelper("SHU'AM");
|
|
tstHelper("SHUBS");
|
|
tstHelper("SHUD");
|
|
tstHelper("SHU-DADHI");
|
|
tstHelper("SHUDDHA");
|
|
tstHelper("SHUG");
|
|
tstHelper("SHUGS");
|
|
tstHelper("SHU'I");
|
|
tstHelper("SHUL");
|
|
tstHelper("SHUM");
|
|
tstHelper("SHUN");
|
|
tstHelper("SHUR");
|
|
tstHelper("SHUS");
|
|
tstHelper("sh'VA");
|
|
tstHelper("SHVA");
|
|
tstHelper("SHVAD");
|
|
tstHelper("SHVATTHA'I");
|
|
tstHelper("SHWA");
|
|
tstHelper("SHWANG-THA'I");
|
|
tstHelper("shYA");
|
|
tstHelper("sHYA");
|
|
tstHelper("SHYA");
|
|
tstHelper("SI");
|
|
tstHelper("S'I");
|
|
tstHelper("SIDDHI");
|
|
tstHelper("SI-DIdhI");
|
|
tstHelper("S'I'I");
|
|
tstHelper("SI'I");
|
|
tstHelper("SIL");
|
|
tstHelper("SIm");
|
|
tstHelper("SIM");
|
|
tstHelper("SIN");
|
|
tstHelper("S'IN");
|
|
tstHelper("S'INA");
|
|
tstHelper("SING");
|
|
tstHelper("SINGGA");
|
|
tstHelper("SINGGHA");
|
|
tstHelper("SINGHA");
|
|
tstHelper("SING-HA");
|
|
tstHelper("SIR");
|
|
tstHelper("S'IR");
|
|
tstHelper("S'IRA");
|
|
tstHelper("SKA");
|
|
tstHelper("SKA'");
|
|
tstHelper("SKABS");
|
|
tstHelper("SKAD");
|
|
tstHelper("SKAG");
|
|
tstHelper("SKAL");
|
|
tstHelper("SKAM");
|
|
tstHelper("SKAMS");
|
|
tstHelper("SKAN");
|
|
tstHelper("SKANG");
|
|
tstHelper("SKAR");
|
|
tstHelper("SKAS");
|
|
tstHelper("SKE");
|
|
tstHelper("SKED");
|
|
tstHelper("SKEGS");
|
|
tstHelper("SKEM");
|
|
tstHelper("SKEMS");
|
|
tstHelper("SKO");
|
|
tstHelper("SKOL");
|
|
tstHelper("SKOM");
|
|
tstHelper("SKOMS");
|
|
tstHelper("SKON");
|
|
tstHelper("SKONG");
|
|
tstHelper("SKONGS");
|
|
tstHelper("SKO'O");
|
|
tstHelper("SKOR");
|
|
tstHelper("SKOS");
|
|
tstHelper("SKRA");
|
|
tstHelper("SKRA'AM");
|
|
tstHelper("SKRA'ANG");
|
|
tstHelper("SKRABS");
|
|
tstHelper("SKRAD");
|
|
tstHelper("SKRAG");
|
|
tstHelper("SKRA'I");
|
|
tstHelper("SKRAL");
|
|
tstHelper("SKRAN");
|
|
tstHelper("SKRANGS");
|
|
tstHelper("SKRAS");
|
|
tstHelper("SKRIN");
|
|
tstHelper("SKRO");
|
|
tstHelper("SKROD");
|
|
tstHelper("SKROGS");
|
|
tstHelper("SKROM");
|
|
tstHelper("SKRUN");
|
|
tstHelper("SKRUR");
|
|
tstHelper("SKU");
|
|
tstHelper("SKU'AM");
|
|
tstHelper("SKU'ANG");
|
|
tstHelper("SKUD");
|
|
tstHelper("SKUG");
|
|
tstHelper("SKUGS");
|
|
tstHelper("SKU'I");
|
|
tstHelper("SKUL");
|
|
tstHelper("SKUM");
|
|
tstHelper("SKUN");
|
|
tstHelper("SKUNG");
|
|
tstHelper("SKU'O");
|
|
tstHelper("SKUR");
|
|
tstHelper("SKUS");
|
|
tstHelper("SKYA");
|
|
tstHelper("SKYAB");
|
|
tstHelper("SKYABS");
|
|
tstHelper("SKYAD");
|
|
tstHelper("SKYAG");
|
|
tstHelper("SKYAGS");
|
|
tstHelper("SKYA'I");
|
|
tstHelper("SKYANG");
|
|
tstHelper("SKYANGS");
|
|
tstHelper("SKYA'O");
|
|
tstHelper("SKYAR");
|
|
tstHelper("SKYAS");
|
|
tstHelper("SKYE");
|
|
tstHelper("SKYEB");
|
|
tstHelper("SKYED");
|
|
tstHelper("SKYEGS");
|
|
tstHelper("SKYE'I");
|
|
tstHelper("SKYEL");
|
|
tstHelper("SKYEMS");
|
|
tstHelper("SKYEN");
|
|
tstHelper("SKYENGS");
|
|
tstHelper("SKYE'O");
|
|
tstHelper("SKYER");
|
|
tstHelper("SKYES");
|
|
tstHelper("SKYI");
|
|
tstHelper("SKYIBS");
|
|
tstHelper("SKYID");
|
|
tstHelper("SKYIGS");
|
|
tstHelper("SKYIL");
|
|
tstHelper("SKYIM");
|
|
tstHelper("SKYIN");
|
|
tstHelper("SKYIS");
|
|
tstHelper("SKYO");
|
|
tstHelper("SKYOB");
|
|
tstHelper("SKYOBS");
|
|
tstHelper("SKYOD");
|
|
tstHelper("SKYOG");
|
|
tstHelper("SKYOGS");
|
|
tstHelper("SKYOL");
|
|
tstHelper("SKYON");
|
|
tstHelper("SKYONG");
|
|
tstHelper("SKYONGS");
|
|
tstHelper("SKYOR");
|
|
tstHelper("SKYOS");
|
|
tstHelper("SKYU");
|
|
tstHelper("SKYUD");
|
|
tstHelper("SKYUG");
|
|
tstHelper("SKYUGS");
|
|
tstHelper("SKYUNG");
|
|
tstHelper("SKYUR");
|
|
tstHelper("SLA");
|
|
tstHelper("SLA'AM");
|
|
tstHelper("SLAB");
|
|
tstHelper("SLAD");
|
|
tstHelper("SLA'I");
|
|
tstHelper("SLAN");
|
|
tstHelper("SLANG");
|
|
tstHelper("SLA'O");
|
|
tstHelper("SLAR");
|
|
tstHelper("SLAS");
|
|
tstHelper("SLE");
|
|
tstHelper("SLEB");
|
|
tstHelper("SLEBS");
|
|
tstHelper("SLEGS");
|
|
tstHelper("SLEN");
|
|
tstHelper("SLO");
|
|
tstHelper("SLOB");
|
|
tstHelper("SLOBS");
|
|
tstHelper("SLOD");
|
|
tstHelper("SLOGS");
|
|
tstHelper("SLOM");
|
|
tstHelper("SLON");
|
|
tstHelper("SLONG");
|
|
tstHelper("SLONGS");
|
|
tstHelper("SLU");
|
|
tstHelper("SLUS");
|
|
tstHelper("SMA");
|
|
tstHelper("SMAD");
|
|
tstHelper("SMAG");
|
|
tstHelper("SMAN");
|
|
tstHelper("SMANG");
|
|
tstHelper("SMARS");
|
|
tstHelper("SMAS");
|
|
tstHelper("SME");
|
|
tstHelper("SMEL");
|
|
tstHelper("SMES");
|
|
tstHelper("SMIG");
|
|
tstHelper("SMIN");
|
|
tstHelper("SMOD");
|
|
tstHelper("SMOM");
|
|
tstHelper("SMON");
|
|
tstHelper("SMOS");
|
|
tstHelper("SMRA");
|
|
tstHelper("SMRA'AM");
|
|
tstHelper("SMRA'ANG");
|
|
tstHelper("SMRAB");
|
|
tstHelper("SMRA'BA'I");
|
|
tstHelper("SMRA'I");
|
|
tstHelper("SMRAN");
|
|
tstHelper("SMRA'O");
|
|
tstHelper("SMRAR");
|
|
tstHelper("SMRAS");
|
|
tstHelper("SMRE");
|
|
tstHelper("SMREG");
|
|
tstHelper("SMRER");
|
|
tstHelper("SMRES");
|
|
tstHelper("SMRi");
|
|
tstHelper("SMRI");
|
|
tstHelper("SMRIG");
|
|
tstHelper("SMRIN");
|
|
tstHelper("SMROS");
|
|
tstHelper("SMUG");
|
|
tstHelper("SMYAGS");
|
|
tstHelper("SMYAM");
|
|
tstHelper("SMYAN");
|
|
tstHelper("SMYANG");
|
|
tstHelper("SMYANGS");
|
|
tstHelper("SMYIG");
|
|
tstHelper("SMYON");
|
|
tstHelper("SMYOS");
|
|
tstHelper("SMYU");
|
|
tstHelper("SMYUG");
|
|
tstHelper("SMYUGS");
|
|
tstHelper("SMYUNG");
|
|
tstHelper("SMYUR");
|
|
tstHelper("SNA");
|
|
tstHelper("SNA'AM");
|
|
tstHelper("SNA'ANG");
|
|
tstHelper("SNABS");
|
|
tstHelper("SNAD");
|
|
tstHelper("SNAG");
|
|
tstHelper("SNAGS");
|
|
tstHelper("SNA'I");
|
|
tstHelper("SNAM");
|
|
tstHelper("SNAMS");
|
|
tstHelper("SNAN");
|
|
tstHelper("SNANG");
|
|
tstHelper("SNA'O");
|
|
tstHelper("SNAR");
|
|
tstHelper("SNAS");
|
|
tstHelper("SNEL");
|
|
tstHelper("SNGA");
|
|
tstHelper("SNGAD");
|
|
tstHelper("SNGA-GHA");
|
|
tstHelper("SNGAGS");
|
|
tstHelper("SNGAL");
|
|
tstHelper("SNGAM");
|
|
tstHelper("SNGAN");
|
|
tstHelper("SNGANG");
|
|
tstHelper("SNGANGS");
|
|
tstHelper("SNGAR");
|
|
tstHelper("SNGAS");
|
|
tstHelper("SNGE");
|
|
tstHelper("SNGEB");
|
|
tstHelper("SNGEM");
|
|
tstHelper("SNGER");
|
|
tstHelper("SNGE'U");
|
|
tstHelper("SNGE'U'I");
|
|
tstHelper("SNGIG");
|
|
tstHelper("SNGO");
|
|
tstHelper("SNGOD");
|
|
tstHelper("SNGOGS");
|
|
tstHelper("SNGO'I");
|
|
tstHelper("SNGOM");
|
|
tstHelper("SNGON");
|
|
tstHelper("SNGONG");
|
|
tstHelper("SNGO'O");
|
|
tstHelper("SNGOR");
|
|
tstHelper("SNGOS");
|
|
tstHelper("SNGUG");
|
|
tstHelper("SNI");
|
|
tstHelper("SNIN");
|
|
tstHelper("SNOD");
|
|
tstHelper("SNOL");
|
|
tstHelper("SNOM");
|
|
tstHelper("SNOMS");
|
|
tstHelper("SNON");
|
|
tstHelper("SNONG");
|
|
tstHelper("SNREL");
|
|
tstHelper("SNRON");
|
|
tstHelper("SNUBS");
|
|
tstHelper("SNUM");
|
|
tstHelper("SNUMS");
|
|
tstHelper("SNUN");
|
|
tstHelper("SNYA");
|
|
tstHelper("SNYAD");
|
|
tstHelper("SNYAM");
|
|
tstHelper("SNYAM'AM");
|
|
tstHelper("SNYAMS");
|
|
tstHelper("SNYAN");
|
|
tstHelper("SNYE");
|
|
tstHelper("SNYED");
|
|
tstHelper("SNYEGS");
|
|
tstHelper("SNYEM");
|
|
tstHelper("SNYEMS");
|
|
tstHelper("SNYEN");
|
|
tstHelper("SNYENG");
|
|
tstHelper("SNYES");
|
|
tstHelper("SNYI");
|
|
tstHelper("SNYID");
|
|
tstHelper("SNYIGN");
|
|
tstHelper("SNYIGS");
|
|
tstHelper("SNYIL");
|
|
tstHelper("SNYIM");
|
|
tstHelper("SNYING");
|
|
tstHelper("SNYIR");
|
|
tstHelper("SNYOD");
|
|
tstHelper("SNYOGS");
|
|
tstHelper("SNYOL");
|
|
tstHelper("SNYOM");
|
|
tstHelper("SNYOMS");
|
|
tstHelper("SNYON");
|
|
tstHelper("SNYONG");
|
|
tstHelper("SNYONS");
|
|
tstHelper("SNYOSM");
|
|
tstHelper("SNYUG");
|
|
tstHelper("SNYUGS");
|
|
tstHelper("SNYUN");
|
|
tstHelper("SO");
|
|
tstHelper("'SO");
|
|
tstHelper("SO'AM");
|
|
tstHelper("SOBS");
|
|
tstHelper("SOD");
|
|
tstHelper("SOG");
|
|
tstHelper("SOGS");
|
|
tstHelper("SO-HO");
|
|
tstHelper("SO'I");
|
|
tstHelper("SO'I'O");
|
|
tstHelper("SOL");
|
|
tstHelper("SOM");
|
|
tstHelper("SOMS");
|
|
tstHelper("SON");
|
|
tstHelper("SONG");
|
|
tstHelper("SONGS");
|
|
tstHelper("SOO");
|
|
tstHelper("SOR");
|
|
tstHelper("SOS");
|
|
tstHelper("SOSL");
|
|
tstHelper("SPA");
|
|
tstHelper("SPABS");
|
|
tstHelper("SPAD");
|
|
tstHelper("SPAGS");
|
|
tstHelper("SPAL");
|
|
tstHelper("SPANG");
|
|
tstHelper("SPANGS");
|
|
tstHelper("SPAR");
|
|
tstHelper("SPAS");
|
|
tstHelper("SPEL");
|
|
tstHelper("SPEN");
|
|
tstHelper("SPHRUL");
|
|
tstHelper("SPO");
|
|
tstHelper("SPOB");
|
|
tstHelper("SPOBS");
|
|
tstHelper("SPOD");
|
|
tstHelper("SPOGS");
|
|
tstHelper("SPOL");
|
|
tstHelper("SPOM");
|
|
tstHelper("SPONG");
|
|
tstHelper("SPONGS");
|
|
tstHelper("SPOR");
|
|
tstHelper("SPOS");
|
|
tstHelper("SPRA");
|
|
tstHelper("SPRAD");
|
|
tstHelper("SPRAN");
|
|
tstHelper("SPRANG");
|
|
tstHelper("SPRANGS");
|
|
tstHelper("SPRA'O");
|
|
tstHelper("SPRAS");
|
|
tstHelper("SPREBS");
|
|
tstHelper("SPREL");
|
|
tstHelper("SPRENGS");
|
|
tstHelper("SPRE'U");
|
|
tstHelper("SPRE'U'I");
|
|
tstHelper("SPRE'UR");
|
|
tstHelper("SPRE'US");
|
|
tstHelper("SPRID");
|
|
tstHelper("SPRIN");
|
|
tstHelper("SPRING");
|
|
tstHelper("SPRIS");
|
|
tstHelper("SPRO");
|
|
tstHelper("SPRO'AM");
|
|
tstHelper("SPROB");
|
|
tstHelper("SPROD");
|
|
tstHelper("SPROG");
|
|
tstHelper("SPRO'I");
|
|
tstHelper("SPRON");
|
|
tstHelper("SPRO'O");
|
|
tstHelper("SPROS");
|
|
tstHelper("SPRUG");
|
|
tstHelper("SPRUGS");
|
|
tstHelper("SPRUL");
|
|
tstHelper("SPRUM");
|
|
tstHelper("SPRUS");
|
|
tstHelper("SPU");
|
|
tstHelper("SPU'");
|
|
tstHelper("SPU'AM");
|
|
tstHelper("SPUD");
|
|
tstHelper("SPUG");
|
|
tstHelper("SPU'I");
|
|
tstHelper("SPUN");
|
|
tstHelper("SPUNG");
|
|
tstHelper("SPUNGS");
|
|
tstHelper("SPUR");
|
|
tstHelper("SPUS");
|
|
tstHelper("SPYA");
|
|
tstHelper("SPYAD");
|
|
tstHelper("SPYAGS");
|
|
tstHelper("SPYAN");
|
|
tstHelper("SPYANG");
|
|
tstHelper("SPYANGS");
|
|
tstHelper("SPYAR");
|
|
tstHelper("SPYED");
|
|
tstHelper("SPYES");
|
|
tstHelper("SPYI");
|
|
tstHelper("SPYIG");
|
|
tstHelper("SPYI'I");
|
|
tstHelper("SPYIL");
|
|
tstHelper("SPYIN");
|
|
tstHelper("SPYIR");
|
|
tstHelper("SPYI'U");
|
|
tstHelper("SPYO");
|
|
tstHelper("SPYOD");
|
|
tstHelper("SPYOMS");
|
|
tstHelper("SPYON");
|
|
tstHelper("SPYONG");
|
|
tstHelper("SPYO'O");
|
|
tstHelper("SPYOR");
|
|
tstHelper("SPYOS");
|
|
tstHelper("SPYUG");
|
|
tstHelper("SPYUGS");
|
|
tstHelper("SRA");
|
|
tstHelper("SRAB");
|
|
tstHelper("SRABS");
|
|
tstHelper("SRAD");
|
|
tstHelper("SRAM");
|
|
tstHelper("SRAN");
|
|
tstHelper("SRANG");
|
|
tstHelper("SRAR");
|
|
tstHelper("SRAS");
|
|
tstHelper("SRE");
|
|
tstHelper("SRED");
|
|
tstHelper("SREG");
|
|
tstHelper("SREGS");
|
|
tstHelper("SREL");
|
|
tstHelper("SREN");
|
|
tstHelper("SRENG");
|
|
tstHelper("SRE'O");
|
|
tstHelper("SRGYA");
|
|
tstHelper("SRI");
|
|
tstHelper("SRID");
|
|
tstHelper("SRIL");
|
|
tstHelper("SRIN");
|
|
tstHelper("SRING");
|
|
tstHelper("SRINGS");
|
|
tstHelper("SRO");
|
|
tstHelper("SROD");
|
|
tstHelper("SROG");
|
|
tstHelper("SROGS");
|
|
tstHelper("SROL");
|
|
tstHelper("SRONG");
|
|
tstHelper("SRONGS");
|
|
tstHelper("SROS");
|
|
tstHelper("SRU");
|
|
tstHelper("SRUB");
|
|
tstHelper("SRUBS");
|
|
tstHelper("SRUD");
|
|
tstHelper("SRUG");
|
|
tstHelper("SRU'I");
|
|
tstHelper("SRUL");
|
|
tstHelper("SRUN");
|
|
tstHelper("SRUNG");
|
|
tstHelper("SRUNGS");
|
|
tstHelper("SSAM");
|
|
tstHelper("SSGRA");
|
|
tstHelper("SSKYES");
|
|
tstHelper("STA");
|
|
tstHelper("ST'A");
|
|
tstHelper("STABS");
|
|
tstHelper("STAG");
|
|
tstHelper("STAL");
|
|
tstHelper("STAM");
|
|
tstHelper("STAN");
|
|
tstHelper("STANG");
|
|
tstHelper("STANGS");
|
|
tstHelper("STAR");
|
|
tstHelper("STE");
|
|
tstHelper("STED");
|
|
tstHelper("STEG");
|
|
tstHelper("STEGS");
|
|
tstHelper("STEN");
|
|
tstHelper("STENG");
|
|
tstHelper("STENGS");
|
|
tstHelper("STE'O");
|
|
tstHelper("STER");
|
|
tstHelper("STES");
|
|
tstHelper("STE'U");
|
|
tstHelper("STE'UR");
|
|
tstHelper("STHA");
|
|
tstHelper("STH'U");
|
|
tstHelper("STI");
|
|
tstHelper("STIGS");
|
|
tstHelper("STI'I");
|
|
tstHelper("STIL");
|
|
tstHelper("STING");
|
|
tstHelper("STIR");
|
|
tstHelper("STIS");
|
|
tstHelper("STO");
|
|
tstHelper("STOB");
|
|
tstHelper("STOBS");
|
|
tstHelper("STOD");
|
|
tstHelper("STOGS");
|
|
tstHelper("STON");
|
|
tstHelper("STONG");
|
|
tstHelper("STONGS");
|
|
tstHelper("STOR");
|
|
tstHelper("STOS");
|
|
tstHelper("STRIN");
|
|
tstHelper("STU");
|
|
tstHelper("STUG");
|
|
tstHelper("STUN");
|
|
tstHelper("STUNG");
|
|
tstHelper("STXAL");
|
|
tstHelper("STZA");
|
|
tstHelper("STZAL");
|
|
tstHelper("STZAM");
|
|
tstHelper("STZANG");
|
|
tstHelper("STZOGS");
|
|
tstHelper("STZOL");
|
|
tstHelper("STZUR");
|
|
tstHelper("STZUS");
|
|
tstHelper("SU");
|
|
tstHelper("S'U");
|
|
tstHelper("SU'AM");
|
|
tstHelper("SU'ANG");
|
|
tstHelper("SU-BH'A");
|
|
tstHelper("SUBS");
|
|
tstHelper("SUD");
|
|
tstHelper("SUG");
|
|
tstHelper("SU'I");
|
|
tstHelper("SUL");
|
|
tstHelper("SUM");
|
|
tstHelper("SUN");
|
|
tstHelper("SUNG");
|
|
tstHelper("SUNGS");
|
|
tstHelper("SU'O");
|
|
tstHelper("SUR");
|
|
tstHelper("S'UR");
|
|
tstHelper("SURENDRA");
|
|
tstHelper("SUS");
|
|
tstHelper("SVA");
|
|
tstHelper("SV'A");
|
|
tstHelper("SVA'AHA");
|
|
tstHelper("SV'AH'A");
|
|
tstHelper("SVAHA'A");
|
|
tstHelper("SWA");
|
|
tstHelper("SW'A-H'A");
|
|
tstHelper("SYA");
|
|
tstHelper("SY'A");
|
|
tstHelper("tA");
|
|
tstHelper("t'A");
|
|
tstHelper("TA");
|
|
tstHelper("T'A");
|
|
tstHelper("TA'");
|
|
tstHelper("TAB");
|
|
tstHelper("TADYA");
|
|
tstHelper("TA-DYA");
|
|
tstHelper("TAG");
|
|
tstHelper("tA'I");
|
|
tstHelper("TA'I");
|
|
tstHelper("T'AKshA");
|
|
tstHelper("TAL");
|
|
tstHelper("TAm");
|
|
tstHelper("T'Am");
|
|
tstHelper("TAM");
|
|
tstHelper("TAMS");
|
|
tstHelper("TAN");
|
|
tstHelper("TANG");
|
|
tstHelper("TA-PAL");
|
|
tstHelper("TAR");
|
|
tstHelper("TAS");
|
|
tstHelper("tE");
|
|
tstHelper("TE");
|
|
tstHelper("TE'");
|
|
tstHelper("TE'AM");
|
|
tstHelper("TE'DAS");
|
|
tstHelper("TEG");
|
|
tstHelper("TEN");
|
|
tstHelper("TENG");
|
|
tstHelper("TENGS");
|
|
tstHelper("TE'O");
|
|
tstHelper("TES");
|
|
tstHelper("TE'U");
|
|
tstHelper("TE'U'AM");
|
|
tstHelper("TE'U'I");
|
|
tstHelper("thA");
|
|
tstHelper("THA");
|
|
tstHelper("'THA'");
|
|
tstHelper("TH'A");
|
|
tstHelper("THA'");
|
|
tstHelper("THAB");
|
|
tstHelper("'THAB");
|
|
tstHelper("THABS");
|
|
tstHelper("'THABS");
|
|
tstHelper("THAD");
|
|
tstHelper("'THAD");
|
|
tstHelper("THAG");
|
|
tstHelper("'THAG");
|
|
tstHelper("THAGS");
|
|
tstHelper("THA'I");
|
|
tstHelper("THAL");
|
|
tstHelper("THAM");
|
|
tstHelper("'THAM");
|
|
tstHelper("THAMD");
|
|
tstHelper("THAMS");
|
|
tstHelper("'THAMS");
|
|
tstHelper("THAN");
|
|
tstHelper("THANG");
|
|
tstHelper("THAR");
|
|
tstHelper("'THAR");
|
|
tstHelper("THAS");
|
|
tstHelper("'THAS");
|
|
tstHelper("THASM");
|
|
tstHelper("THE");
|
|
tstHelper("THEB");
|
|
tstHelper("'THEB");
|
|
tstHelper("THEBS");
|
|
tstHelper("THEG");
|
|
tstHelper("THEGS");
|
|
tstHelper("THEM");
|
|
tstHelper("THEN");
|
|
tstHelper("'THEN");
|
|
tstHelper("THENG");
|
|
tstHelper("'THENG");
|
|
tstHelper("THER");
|
|
tstHelper("THE'U");
|
|
tstHelper("THI");
|
|
tstHelper("THIB");
|
|
tstHelper("THIBS");
|
|
tstHelper("THIG");
|
|
tstHelper("THIGS");
|
|
tstHelper("THIL");
|
|
tstHelper("'THIL");
|
|
tstHelper("THILA'I");
|
|
tstHelper("THIM");
|
|
tstHelper("THING");
|
|
tstHelper("'THING");
|
|
tstHelper("THIS");
|
|
tstHelper("THO");
|
|
tstHelper("THOB");
|
|
tstHelper("'THOB");
|
|
tstHelper("THOBS");
|
|
tstHelper("THOD");
|
|
tstHelper("THOG");
|
|
tstHelper("'THOG");
|
|
tstHelper("THOGS");
|
|
tstHelper("'THOM");
|
|
tstHelper("THON");
|
|
tstHelper("'THON");
|
|
tstHelper("THONG");
|
|
tstHelper("'THONG");
|
|
tstHelper("THONGS");
|
|
tstHelper("THOR");
|
|
tstHelper("'THOR");
|
|
tstHelper("THOS");
|
|
tstHelper("THRIG");
|
|
tstHelper("thU");
|
|
tstHelper("THU");
|
|
tstHelper("THUB");
|
|
tstHelper("'THUB");
|
|
tstHelper("THUBS");
|
|
tstHelper("THUD");
|
|
tstHelper("'THUD");
|
|
tstHelper("THUG");
|
|
tstHelper("THUGS");
|
|
tstHelper("'THUGS");
|
|
tstHelper("THU'I");
|
|
tstHelper("THUL");
|
|
tstHelper("'THUL");
|
|
tstHelper("THUM");
|
|
tstHelper("THUN");
|
|
tstHelper("'THUN");
|
|
tstHelper("THUNG");
|
|
tstHelper("'THUNG");
|
|
tstHelper("THUNGS");
|
|
tstHelper("'THUNGS");
|
|
tstHelper("THU'O");
|
|
tstHelper("THUR");
|
|
tstHelper("tI");
|
|
tstHelper("t'I");
|
|
tstHelper("TI");
|
|
tstHelper("T'I");
|
|
tstHelper("TIG");
|
|
tstHelper("TI'I");
|
|
tstHelper("t'IK");
|
|
tstHelper("TIL");
|
|
tstHelper("TIN");
|
|
tstHelper("TIN-DU");
|
|
tstHelper("tING");
|
|
tstHelper("TING");
|
|
tstHelper("TING-GA");
|
|
tstHelper("TIR");
|
|
tstHelper("TI'U");
|
|
tstHelper("TO");
|
|
tstHelper("TOBS");
|
|
tstHelper("TOG");
|
|
tstHelper("TOGS");
|
|
tstHelper("TO'I");
|
|
tstHelper("TOL");
|
|
tstHelper("TON");
|
|
tstHelper("TONG");
|
|
tstHelper("TONZAD");
|
|
tstHelper("TOR");
|
|
tstHelper("TPA");
|
|
tstHelper("TP'A");
|
|
tstHelper("TP'U");
|
|
tstHelper("TRA");
|
|
tstHelper("TRAD");
|
|
tstHelper("TRANG");
|
|
tstHelper("TRAS");
|
|
tstHelper("TRE");
|
|
tstHelper("TREE");
|
|
tstHelper("TRE'I");
|
|
tstHelper("TRES");
|
|
tstHelper("TRI");
|
|
tstHelper("TRON");
|
|
tstHelper("TRYA");
|
|
tstHelper("TSA");
|
|
tstHelper("'TSA'");
|
|
tstHelper("TS'A");
|
|
tstHelper("TSA'");
|
|
tstHelper("TSA'AM");
|
|
tstHelper("TSAB");
|
|
tstHelper("TSABS");
|
|
tstHelper("TSAD");
|
|
tstHelper("'TSAD");
|
|
tstHelper("'TSAG");
|
|
tstHelper("TSAGS");
|
|
tstHelper("TSA'I");
|
|
tstHelper("TSAL");
|
|
tstHelper("'TSAL");
|
|
tstHelper("TSAM");
|
|
tstHelper("'TSAM");
|
|
tstHelper("TSAMS");
|
|
tstHelper("'TSAMS");
|
|
tstHelper("TSAN");
|
|
tstHelper("TSANG");
|
|
tstHelper("'TSANG");
|
|
tstHelper("TSANGS");
|
|
tstHelper("'TSANGS");
|
|
tstHelper("TSA'O");
|
|
tstHelper("TSAR");
|
|
tstHelper("'TSAR");
|
|
tstHelper("TSAS");
|
|
tstHelper("TSE");
|
|
tstHelper("'TSE");
|
|
tstHelper("TSE'AM");
|
|
tstHelper("TSE'ANG");
|
|
tstHelper("TSED");
|
|
tstHelper("'TSED");
|
|
tstHelper("TSEG");
|
|
tstHelper("'TSEG");
|
|
tstHelper("TSEGS");
|
|
tstHelper("'TSE'I");
|
|
tstHelper("TSE'I");
|
|
tstHelper("TSEL");
|
|
tstHelper("TSEM");
|
|
tstHelper("'TSEM");
|
|
tstHelper("TSEMS");
|
|
tstHelper("TSEN");
|
|
tstHelper("TSE'O");
|
|
tstHelper("TSER");
|
|
tstHelper("'TSER");
|
|
tstHelper("TSES");
|
|
tstHelper("TSI");
|
|
tstHelper("'TSI");
|
|
tstHelper("TSIBS");
|
|
tstHelper("TSID");
|
|
tstHelper("TSIG");
|
|
tstHelper("'TSIG");
|
|
tstHelper("TSIGS");
|
|
tstHelper("TSIL");
|
|
tstHelper("TSIM");
|
|
tstHelper("TSIN");
|
|
tstHelper("TSING");
|
|
tstHelper("TSIR");
|
|
tstHelper("'TSIR");
|
|
tstHelper("TSIS");
|
|
tstHelper("TSO");
|
|
tstHelper("'TSO");
|
|
tstHelper("'TSO'AM");
|
|
tstHelper("'TSOB");
|
|
tstHelper("TSOBS");
|
|
tstHelper("TSOD");
|
|
tstHelper("'TSOD");
|
|
tstHelper("TSOG");
|
|
tstHelper("'TSOG");
|
|
tstHelper("TSOGS");
|
|
tstHelper("'TSOGS");
|
|
tstHelper("'TSO'I");
|
|
tstHelper("TSO'I");
|
|
tstHelper("TSOL");
|
|
tstHelper("'TSOL");
|
|
tstHelper("TSOM");
|
|
tstHelper("'TSOM");
|
|
tstHelper("TSOMS");
|
|
tstHelper("TSON");
|
|
tstHelper("TSONG");
|
|
tstHelper("'TSONG");
|
|
tstHelper("TSONGS");
|
|
tstHelper("'TSO'O");
|
|
tstHelper("TSOR");
|
|
tstHelper("'TSOR");
|
|
tstHelper("TSOS");
|
|
tstHelper("'TSOS");
|
|
tstHelper("TSRA");
|
|
tstHelper("TSU");
|
|
tstHelper("TSUB");
|
|
tstHelper("TSUD");
|
|
tstHelper("TSUGS");
|
|
tstHelper("TSUL");
|
|
tstHelper("TSUN");
|
|
tstHelper("TSUNG");
|
|
tstHelper("TSUNGS");
|
|
tstHelper("TSUR");
|
|
tstHelper("TSUS");
|
|
tstHelper("TSUUL");
|
|
tstHelper("TSVA");
|
|
tstHelper("TSVA'I");
|
|
tstHelper("TSVA'O");
|
|
tstHelper("TSVAR");
|
|
tstHelper("TSVAS");
|
|
tstHelper("TSWA");
|
|
tstHelper("TSWA'I");
|
|
tstHelper("TTA");
|
|
tstHelper("ttE");
|
|
tstHelper("TTHA");
|
|
tstHelper("tu");
|
|
tstHelper("tU");
|
|
tstHelper("TU");
|
|
tstHelper("TU'ANG");
|
|
tstHelper("TUD");
|
|
tstHelper("TUGS");
|
|
tstHelper("TUM");
|
|
tstHelper("TUN");
|
|
tstHelper("TUNG");
|
|
tstHelper("TU'O");
|
|
tstHelper("TUR");
|
|
tstHelper("TV'A");
|
|
tstHelper("TVAm");
|
|
tstHelper("TWA");
|
|
tstHelper("TYA");
|
|
tstHelper("TY'A");
|
|
tstHelper("TYA'");
|
|
tstHelper("TY'A'I");
|
|
tstHelper("TYA-''I");
|
|
tstHelper("TYA'I");
|
|
tstHelper("TYAm");
|
|
tstHelper("TYA-NTA");
|
|
tstHelper("tYO");
|
|
tstHelper("TZA");
|
|
tstHelper("TZ'A");
|
|
tstHelper("TZAB");
|
|
tstHelper("TZAG");
|
|
tstHelper("TZ'A'I");
|
|
tstHelper("TZA'I");
|
|
tstHelper("'TZAL");
|
|
tstHelper("TZAm");
|
|
tstHelper("TZAM");
|
|
tstHelper("TZAMP");
|
|
tstHelper("TZAMPA");
|
|
tstHelper("TZAM-PA");
|
|
tstHelper("TZAMS");
|
|
tstHelper("TZAN");
|
|
tstHelper("TZA-ndA");
|
|
tstHelper("TZANDA");
|
|
tstHelper("TZANDAN");
|
|
tstHelper("TZAN-DAN");
|
|
tstHelper("TZANDRA");
|
|
tstHelper("TZANDRA'I");
|
|
tstHelper("TZANDRAS");
|
|
tstHelper("TZANG");
|
|
tstHelper("TZANGN");
|
|
tstHelper("TZANGS");
|
|
tstHelper("TZ'AR");
|
|
tstHelper("TZARYA");
|
|
tstHelper("TZ'ARYA");
|
|
tstHelper("TZAS");
|
|
tstHelper("TZ'AS");
|
|
tstHelper("TZATSA");
|
|
tstHelper("TZE");
|
|
tstHelper("TZEG");
|
|
tstHelper("TZE'I");
|
|
tstHelper("TZER");
|
|
tstHelper("TZES");
|
|
tstHelper("TZE-TATE");
|
|
tstHelper("TZI");
|
|
tstHelper("TZI'I");
|
|
tstHelper("TZIN");
|
|
tstHelper("TZI-ttI");
|
|
tstHelper("TZO");
|
|
tstHelper("TZO'AM");
|
|
tstHelper("TZOD");
|
|
tstHelper("TZOG");
|
|
tstHelper("TZO'I");
|
|
tstHelper("TZOL");
|
|
tstHelper("TZOM");
|
|
tstHelper("TZONG");
|
|
tstHelper("TZOR");
|
|
tstHelper("TZTSA");
|
|
tstHelper("TZTS'A");
|
|
tstHelper("TZTSE");
|
|
tstHelper("TZTSED");
|
|
tstHelper("TZU");
|
|
tstHelper("TZUG");
|
|
tstHelper("TZUGS");
|
|
tstHelper("TZUN");
|
|
tstHelper("TZVA");
|
|
tstHelper("TZYU");
|
|
tstHelper("'U");
|
|
tstHelper("'UG");
|
|
tstHelper("'U'I");
|
|
tstHelper("'UR");
|
|
tstHelper("WA");
|
|
tstHelper("W'A");
|
|
tstHelper("WA'");
|
|
tstHelper("WA'AM");
|
|
tstHelper("WA'I");
|
|
tstHelper("WAm");
|
|
tstHelper("WAM");
|
|
tstHelper("WANDRA");
|
|
tstHelper("WANG");
|
|
tstHelper("WAR");
|
|
tstHelper("WARMA");
|
|
tstHelper("WARM'A");
|
|
tstHelper("WARMMA");
|
|
tstHelper("WAS");
|
|
tstHelper("WEN");
|
|
tstHelper("WENDRA");
|
|
tstHelper("WER");
|
|
tstHelper("xNYA");
|
|
tstHelper("YA");
|
|
tstHelper("Y'A");
|
|
tstHelper("YAB");
|
|
tstHelper("YABOD");
|
|
tstHelper("YAD");
|
|
tstHelper("YAG");
|
|
tstHelper("Y'A'I");
|
|
tstHelper("YA'I");
|
|
tstHelper("YAL");
|
|
tstHelper("YAm");
|
|
tstHelper("YAM");
|
|
tstHelper("YAMS");
|
|
tstHelper("YAN");
|
|
tstHelper("YANG");
|
|
tstHelper("YANGH");
|
|
tstHelper("YANGS");
|
|
tstHelper("YAR");
|
|
tstHelper("Y'AR");
|
|
tstHelper("YAS");
|
|
tstHelper("YASTH'A");
|
|
tstHelper("YE");
|
|
tstHelper("YED");
|
|
tstHelper("YEGS");
|
|
tstHelper("YENGS");
|
|
tstHelper("YER");
|
|
tstHelper("YI");
|
|
tstHelper("YIB");
|
|
tstHelper("YID");
|
|
tstHelper("YIG");
|
|
tstHelper("YIN");
|
|
tstHelper("YIND");
|
|
tstHelper("YING");
|
|
tstHelper("YINGS");
|
|
tstHelper("YI'O");
|
|
tstHelper("YIR");
|
|
tstHelper("YIS");
|
|
tstHelper("YISS");
|
|
tstHelper("YO");
|
|
tstHelper("YO'AM");
|
|
tstHelper("YOD");
|
|
tstHelper("YOG");
|
|
tstHelper("YOGS");
|
|
tstHelper("YOL");
|
|
tstHelper("YON");
|
|
tstHelper("YONG");
|
|
tstHelper("YONGS");
|
|
tstHelper("YONG-SU");
|
|
tstHelper("YOR");
|
|
tstHelper("YOS");
|
|
tstHelper("YU");
|
|
tstHelper("YUB");
|
|
tstHelper("YUD");
|
|
tstHelper("YUG");
|
|
tstHelper("YUGS");
|
|
tstHelper("YUKTI");
|
|
tstHelper("YUL");
|
|
tstHelper("YUM");
|
|
tstHelper("YUN");
|
|
tstHelper("YUNG");
|
|
tstHelper("YUNGS");
|
|
tstHelper("YUR");
|
|
tstHelper("YU'U");
|
|
tstHelper("YUYE");
|
|
tstHelper("ZA");
|
|
tstHelper("ZA'AM");
|
|
tstHelper("ZA'ANG");
|
|
tstHelper("ZAB");
|
|
tstHelper("ZABS");
|
|
tstHelper("ZAD");
|
|
tstHelper("ZAG");
|
|
tstHelper("ZAGS");
|
|
tstHelper("ZA'I");
|
|
tstHelper("ZAL");
|
|
tstHelper("ZAM");
|
|
tstHelper("ZAN");
|
|
tstHelper("ZANG");
|
|
tstHelper("ZANGS");
|
|
tstHelper("ZA'O");
|
|
tstHelper("ZAR");
|
|
tstHelper("ZAS");
|
|
tstHelper("ZE");
|
|
tstHelper("ZE'AM");
|
|
tstHelper("ZED");
|
|
tstHelper("ZEGS");
|
|
tstHelper("ZE'I");
|
|
tstHelper("ZEL");
|
|
tstHelper("ZEN");
|
|
tstHelper("ZE'O");
|
|
tstHelper("ZER");
|
|
tstHelper("ZES");
|
|
tstHelper("ZE'U");
|
|
tstHelper("ZHA");
|
|
tstHelper("ZHABS");
|
|
tstHelper("ZHAG");
|
|
tstHelper("ZHAGS");
|
|
tstHelper("ZHA'I");
|
|
tstHelper("ZHAL");
|
|
tstHelper("ZHAM");
|
|
tstHelper("ZHAN");
|
|
tstHelper("ZHANG");
|
|
tstHelper("ZHAR");
|
|
tstHelper("ZHAS");
|
|
tstHelper("ZHE");
|
|
tstHelper("ZHE'AM");
|
|
tstHelper("ZHED");
|
|
tstHelper("ZHEG");
|
|
tstHelper("ZHE'I");
|
|
tstHelper("ZHEN");
|
|
tstHelper("ZHENG");
|
|
tstHelper("ZHE'O");
|
|
tstHelper("ZHER");
|
|
tstHelper("ZHES");
|
|
tstHelper("ZHI");
|
|
tstHelper("ZHIB");
|
|
tstHelper("ZHIG");
|
|
tstHelper("ZHIGN");
|
|
tstHelper("ZHIGS");
|
|
tstHelper("ZHI'I");
|
|
tstHelper("ZHIL");
|
|
tstHelper("ZHIM");
|
|
tstHelper("ZHIN");
|
|
tstHelper("'ZHIN");
|
|
tstHelper("ZHING");
|
|
tstHelper("ZHINGS");
|
|
tstHelper("ZHI'O");
|
|
tstHelper("ZHIR");
|
|
tstHelper("ZHIS");
|
|
tstHelper("ZHO");
|
|
tstHelper("ZHO'AM");
|
|
tstHelper("ZHOG");
|
|
tstHelper("ZHOGS");
|
|
tstHelper("ZHO'I");
|
|
tstHelper("ZHOL");
|
|
tstHelper("ZHOM");
|
|
tstHelper("ZHON");
|
|
tstHelper("ZHOR");
|
|
tstHelper("ZHOS");
|
|
tstHelper("ZHU");
|
|
tstHelper("ZHU'AM");
|
|
tstHelper("ZHUG");
|
|
tstHelper("ZHUGS");
|
|
tstHelper("ZHUM");
|
|
tstHelper("ZHUN");
|
|
tstHelper("ZHU'O");
|
|
tstHelper("ZHUR");
|
|
tstHelper("ZHUS");
|
|
tstHelper("ZHVA");
|
|
tstHelper("ZHVA'I");
|
|
tstHelper("ZHWA");
|
|
tstHelper("ZI");
|
|
tstHelper("ZID");
|
|
tstHelper("ZIL");
|
|
tstHelper("ZIM");
|
|
tstHelper("ZIN");
|
|
tstHelper("ZING");
|
|
tstHelper("ZLA");
|
|
tstHelper("ZLA'ANG");
|
|
tstHelper("ZLAB");
|
|
tstHelper("ZLA'I");
|
|
tstHelper("ZLAR");
|
|
tstHelper("ZLAS");
|
|
tstHelper("ZLI");
|
|
tstHelper("ZLO");
|
|
tstHelper("ZLOG");
|
|
tstHelper("ZLOGS");
|
|
tstHelper("ZLOS");
|
|
tstHelper("ZLUM");
|
|
tstHelper("ZO");
|
|
tstHelper("ZOD");
|
|
tstHelper("ZO'I");
|
|
tstHelper("ZOL");
|
|
tstHelper("ZOM");
|
|
tstHelper("ZONG");
|
|
tstHelper("ZOR");
|
|
tstHelper("ZOS");
|
|
tstHelper("ZU");
|
|
tstHelper("ZUD");
|
|
tstHelper("ZUG");
|
|
tstHelper("ZUGS");
|
|
tstHelper("ZUL");
|
|
tstHelper("ZUM");
|
|
tstHelper("ZUMS");
|
|
tstHelper("ZUN");
|
|
tstHelper("ZUNG");
|
|
tstHelper("'ZUNG");
|
|
tstHelper("ZUNGS");
|
|
tstHelper("ZUR");
|
|
|
|
}
|
|
|
|
private static void shelp(String s, String expectedErrors) {
|
|
shelp(s, expectedErrors, null);
|
|
}
|
|
|
|
private static void shelp(String s, String expectedErrors, String expectedScan) {
|
|
StringBuffer errors = new StringBuffer();
|
|
ArrayList al = ACIPTshegBarScanner.scan(s, errors, -1);
|
|
if (null != expectedScan) {
|
|
if (!al.toString().equals(expectedScan)) {
|
|
System.out.println("Scanning " + s + " into tsheg bars was expected to cause the following scan:");
|
|
System.out.println(expectedScan);
|
|
System.out.println("Instead, it caused the following scan:");
|
|
System.out.println(al);
|
|
assertTrue(false);
|
|
}
|
|
}
|
|
if (null != expectedErrors) {
|
|
if (!expectedErrors.equals(errors.toString())) {
|
|
System.out.println("Scanning " + s + " into tsheg bars was expected to cause the following errors:");
|
|
System.out.print(expectedErrors);
|
|
System.out.println("Instead, it caused the following errors:");
|
|
System.out.print(errors);
|
|
assertTrue(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Tests {@link ACIPTshegBarScanner#scan(String, StringBuffer, int)}. */
|
|
public void testScanner() {
|
|
shelp("LA...SGRUB",
|
|
"",
|
|
"[TIBETAN_NON_PUNCTUATION:{LA}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_NON_PUNCTUATION:{SGRUB}]");
|
|
shelp("PAS... LA",
|
|
"",
|
|
"[TIBETAN_NON_PUNCTUATION:{PAS}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, WARNING:{A non-breaking tsheg, '.', appeared, but not like \"...,\" or \".,\" or \".dA\" or \".DA\".}, TIBETAN_PUNCTUATION:{ }, TIBETAN_NON_PUNCTUATION:{LA}]");
|
|
shelp("^GONG SA,",
|
|
"",
|
|
"[TIBETAN_NON_PUNCTUATION:{^GONG}, TIBETAN_PUNCTUATION:{ }, TIBETAN_NON_PUNCTUATION:{SA}, TIBETAN_PUNCTUATION:{,}]");
|
|
shelp("^ GONG SA,",
|
|
"",
|
|
"[TIBETAN_NON_PUNCTUATION:{^}, TIBETAN_PUNCTUATION:{ }, TIBETAN_NON_PUNCTUATION:{GONG}, TIBETAN_PUNCTUATION:{ }, TIBETAN_NON_PUNCTUATION:{SA}, TIBETAN_PUNCTUATION:{,}]");
|
|
// DLC FIXME: test that ^ and ^GONG are handled correctly on the whole.
|
|
shelp("", "", "[]");
|
|
shelp("[DD]", "");
|
|
shelp("[",
|
|
"Offset 0 or maybe 0: Found an illegal open bracket (in context, this is [). Perhaps there is a [#COMMENT] written incorrectly as [COMMENT], or a [*CORRECTION] written incorrectly as [CORRECTION], or an unmatched open bracket?\nOffset END: Truly unmatched open bracket found.\n");
|
|
shelp("{",
|
|
"Offset 0 or maybe 0: Found an illegal open bracket (in context, this is {). Perhaps there is a [#COMMENT] written incorrectly as [COMMENT], or a [*CORRECTION] written incorrectly as [CORRECTION], or an unmatched open bracket?\nOffset END: Truly unmatched open bracket found.\n");
|
|
shelp("DD", "");
|
|
shelp("DD]",
|
|
"Offset 2 or maybe 2: Found a truly unmatched close bracket, ] or }.\nOffset 2 or maybe 2: Found a closing bracket without a matching open bracket. Perhaps a [#COMMENT] incorrectly written as [COMMENT], or a [*CORRECTION] written incorrectly as [CORRECTION], caused this.\n");
|
|
|
|
shelp("///NYA", "Offset 1 or maybe 1: Found //, which could be legal (the Unicode would be \\u0F3C\\u0F3D), but is likely in an illegal construct like //NYA\\\\.\nOffset END: Slashes are supposed to occur in pairs, but the input had an unmatched '/' character.\n");
|
|
shelp("/NYA/", "");
|
|
shelp("[?][BP][LS][DD1][DD2][DDD][DR][# (<{A COMMENT)}>]", "");
|
|
shelp("[LS][# A [[[[[COMMENT][LS]",
|
|
"Offset 9 or maybe 9: Found an open bracket within a [#COMMENT]-style comment. Brackets may not appear in comments.\n"
|
|
+ "Offset 10 or maybe 10: Found an open bracket within a [#COMMENT]-style comment. Brackets may not appear in comments.\n"
|
|
+ "Offset 11 or maybe 11: Found an open bracket within a [#COMMENT]-style comment. Brackets may not appear in comments.\n"
|
|
+ "Offset 12 or maybe 12: Found an open bracket within a [#COMMENT]-style comment. Brackets may not appear in comments.\n"
|
|
+ "Offset 13 or maybe 13: Found an open bracket within a [#COMMENT]-style comment. Brackets may not appear in comments.\n");
|
|
shelp("[ILLEGAL COMMENT]",
|
|
"Offset 0 or maybe 0: Found an illegal open bracket (in context, this is [ILLEGAL C...). Perhaps there is a [#COMMENT] written incorrectly as [COMMENT], or a [*CORRECTION] written incorrectly as [CORRECTION], or an unmatched open bracket?\nOffset 16 or maybe 16: Found a closing bracket without a matching open bracket. Perhaps a [#COMMENT] incorrectly written as [COMMENT], or a [*CORRECTION] written incorrectly as [CORRECTION], caused this.\n");
|
|
shelp("(BSKYABS GRO)", ""); // DLC WHAT ARE THESE FOR?
|
|
shelp("BSKYABS GRO)", "Offset 11 or maybe 11: Unexpected closing parenthesis, ), found.\n");
|
|
shelp("BSKYABS GRO(", "Offset END: Unmatched open parenthesis, (, found.\n");
|
|
shelp("((NESTAGE))", "Offset 1 or maybe 1: Found an illegal open parenthesis, (. Nesting of parentheses is not allowed.\nOffset 10 or maybe 10: Unexpected closing parenthesis, ), found.\n");
|
|
shelp("(BA)(PA)NYA(CA)", "");
|
|
shelp("NYAx", "");
|
|
shelp("NYA x", "");
|
|
shelp("[# A PARTIAL COM", "Offset END: Unmatched open bracket found. A comment does not terminate.\n");
|
|
shelp("[* BSKYABS ", "Offset END: Unmatched open bracket found. A correction does not terminate.\n");
|
|
shelp("SKYABS [*BSKYABS?] GRO [?]", "");
|
|
shelp(" SKYABS GRO ", "");
|
|
shelp("SKYABS [*BSKYABS] GRO [?]", "", "[TIBETAN_NON_PUNCTUATION:{SKYABS}, TIBETAN_PUNCTUATION:{ }, CORRECTION_START:{[*}, TIBETAN_NON_PUNCTUATION:{BSKYABS}, PROBABLE_CORRECTION:{]}, TIBETAN_PUNCTUATION:{ }, TIBETAN_NON_PUNCTUATION:{GRO}, TIBETAN_PUNCTUATION:{ }, QUESTION:{[?]}]");
|
|
shelp("[*RVA]", "", "[CORRECTION_START:{[*}, TIBETAN_NON_PUNCTUATION:{RVA}, PROBABLE_CORRECTION:{]}]");
|
|
shelp("[*RVA?]", "", "[CORRECTION_START:{[*}, TIBETAN_NON_PUNCTUATION:{RVA}, POSSIBLE_CORRECTION:{?]}]");
|
|
shelp("[* RVA ]", "", "[CORRECTION_START:{[*}, TIBETAN_PUNCTUATION:{ }, TIBETAN_NON_PUNCTUATION:{RVA}, TIBETAN_PUNCTUATION:{ }, PROBABLE_CORRECTION:{]}]");
|
|
shelp("[*RVA ?]", "", "[CORRECTION_START:{[*}, TIBETAN_NON_PUNCTUATION:{RVA}, TIBETAN_PUNCTUATION:{ }, POSSIBLE_CORRECTION:{?]}]");
|
|
shelp("[*RVA? ]", "", "[CORRECTION_START:{[*}, TIBETAN_NON_PUNCTUATION:{RVA}, QUESTION:{?}, TIBETAN_PUNCTUATION:{ }, PROBABLE_CORRECTION:{]}]");
|
|
shelp("[*LINE BREAK]", "", "[CORRECTION_START:{[*}, LATIN:{LINE BREAK}, PROBABLE_CORRECTION:{]}]");
|
|
shelp("[*LINE BREAK?]", "", "[CORRECTION_START:{[*}, LATIN:{LINE BREAK}, POSSIBLE_CORRECTION:{?]}]");
|
|
shelp("[*\n\t\r LINEYO ?]", "", "[CORRECTION_START:{[*}, LATIN:{\n\t\r LINEYO }, POSSIBLE_CORRECTION:{?]}]");
|
|
shelp("[*\n\t\r LINEYO ]", "", "[CORRECTION_START:{[*}, LATIN:{\n\t\r LINEYO }, PROBABLE_CORRECTION:{]}]");
|
|
shelp("[*DATA INCOMPLETE HERE?]", "", "[CORRECTION_START:{[*}, LATIN:{DATA INCOMPLETE HERE}, POSSIBLE_CORRECTION:{?]}]");
|
|
shelp("[*THIS\r\nWAS SUPPOSED TO BE THE SIXTH CATEGORY; THE CATEGORIES MENTIONED\r\nABOVE SEEM TO BE OUT OF ORDER THROUGH THIS SECTION]\r\n", "");
|
|
|
|
// DLC test ACIP files containing just "x", "o", ":", "m" and "%"
|
|
shelp("x o % : m", "");
|
|
shelp("AAx AAo AA% AA: AAm", "");
|
|
|
|
shelp("/NYA ", "Offset END: Slashes are supposed to occur in pairs, but the input had an unmatched '/' character.\n");
|
|
shelp("(NYA ", "Offset END: Unmatched open parenthesis, (, found.\n");
|
|
shelp("[*NYA ", "Offset END: Unmatched open bracket found. A correction does not terminate.\n");
|
|
shelp("?", "", "[QUESTION:{?}]");
|
|
shelp("KHAN~ BAR ", "Offset 4 or maybe 4: Found an illegal character, ~, with ordinal 126.\n");
|
|
shelp("[* Correction with []]",
|
|
"Offset 5 or maybe 5: Found an illegal character, r, with ordinal 114.\nOffset 6 or maybe 6: Found an illegal character, r, with ordinal 114.\nOffset 7 or maybe 7: Found an illegal character, e, with ordinal 101.\nOffset 8 or maybe 8: Found an illegal character, c, with ordinal 99.\nOffset 14 or maybe 14: Found an illegal character, w, with ordinal 119.\nOffset 19 or maybe 19: Found an illegal open bracket (in context, this is []]). Perhaps there is a [#COMMENT] written incorrectly as [COMMENT], or a [*CORRECTION] written incorrectly as [CORRECTION], or an unmatched open bracket?\nOffset 21 or maybe 21: Found a closing bracket without a matching open bracket. Perhaps a [#COMMENT] incorrectly written as [COMMENT], or a [*CORRECTION] written incorrectly as [CORRECTION], caused this.\n");
|
|
|
|
// DLC FIXME: the line SDIG PA'I GROGS PO'I LAG TU SON PAR 'GYUR PA is followed by a blank line. Note that it's "PA", not "PA ", ending it. Autocorrect to the latter.
|
|
|
|
// DLC FIXME: @0B1 isn't handled correctly!
|
|
|
|
shelp(",NGES ? PA", "", "[TIBETAN_PUNCTUATION:{,}, TIBETAN_NON_PUNCTUATION:{NGES}, TIBETAN_PUNCTUATION:{ }, QUESTION:{?}, TIBETAN_PUNCTUATION:{ }, TIBETAN_NON_PUNCTUATION:{PA}]");
|
|
|
|
|
|
|
|
// FIXME: just until we treat viramas correctly:
|
|
if (false) {
|
|
uhelp("1\\", "\u0f21\u0f84");
|
|
uhelp(" 1\\ ", "\u0f0b\u0f21\u0f84\u0f0b");
|
|
}
|
|
shelp("K\\,",
|
|
"Offset 1 or maybe 1: Found a Sanskrit virama, \\, but the converter currently doesn't treat these properly. Sorry! Please do complain to the maintainers.\n",
|
|
"[TIBETAN_NON_PUNCTUATION:{K}, ERROR:{Found a Sanskrit virama, \\, but the converter currently doesn't treat these properly. Sorry! Please do complain to the maintainers.}, TIBETAN_PUNCTUATION:{,}]");
|
|
|
|
|
|
shelp("MTHAR%", "", "[TIBETAN_NON_PUNCTUATION:{MTHAR%}]");
|
|
shelp("PHYIR;", "", "[TIBETAN_NON_PUNCTUATION:{PHYIR}, TIBETAN_PUNCTUATION:{;}]");
|
|
shelp("......,DAM ",
|
|
"",
|
|
"[TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{,}, TIBETAN_NON_PUNCTUATION:{DAM}, TIBETAN_PUNCTUATION:{ }]");
|
|
shelp("NGO.,", "", "[TIBETAN_NON_PUNCTUATION:{NGO}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{,}]");
|
|
|
|
// Test that we handle some known comments that occur in
|
|
// illegal syntax:
|
|
shelp("[text missing]", "", "[COMMENT:{[#text missing]}]");
|
|
shelp("[FIRST][SECOND][MISSING PAGE][MISSING FOLIO]", "");
|
|
shelp("[THE INITIAL PART OF THIS TEXT WAS INPUT BY THE SERA MEY LIBRARY IN\nTIBETAN FONT AND NEEDS TO BE REDONE BY DOUBLE INPUT]\r\n", "", "[COMMENT:{[#THE INITIAL PART OF THIS TEXT WAS INPUT BY THE SERA MEY LIBRARY IN\nTIBETAN FONT AND NEEDS TO BE REDONE BY DOUBLE INPUT]}, TIBETAN_PUNCTUATION:{\r}, TIBETAN_PUNCTUATION:{\n}]");
|
|
shelp("[THE INITIAL PART OF THIS TEXT WAS INPUT BY THE SERA MEY LIBRARY IN\r\nTIBETAN FONT AND NEEDS TO BE REDONE BY DOUBLE INPUT]\r\n", "", "[COMMENT:{[#THE INITIAL PART OF THIS TEXT WAS INPUT BY THE SERA MEY LIBRARY IN\r\nTIBETAN FONT AND NEEDS TO BE REDONE BY DOUBLE INPUT]}, TIBETAN_PUNCTUATION:{\r}, TIBETAN_PUNCTUATION:{\n}]");
|
|
|
|
// Test folio markers:
|
|
shelp("@01A.3 ", "", "[FOLIO_MARKER:{@01A.3}, TIBETAN_PUNCTUATION:{ }]");
|
|
shelp("@001 ", "", "[FOLIO_MARKER:{@001}, TIBETAN_PUNCTUATION:{ }]");
|
|
shelp("@19-20A",
|
|
"Offset 0 or maybe 0: Found an illegal at sign, @ (in context, this is @19-20A). @012B is an example of a legal folio marker.\n",
|
|
"[ERROR:{Found an illegal at sign, @ (in context, this is @19-20A). @012B is an example of a legal folio marker.}, TIBETAN_NON_PUNCTUATION:{19-20A}]"); // DLC FIXME: yes it occurs in the kangyur.
|
|
shelp("@[7B]", "");
|
|
shelp("@012A.3KA",
|
|
"",
|
|
"[FOLIO_MARKER:{@012A.3}, TIBETAN_NON_PUNCTUATION:{KA}]");
|
|
shelp("@012A.34",
|
|
"Offset 0 or maybe 0: Found an illegal at sign, @ (in context, this is @012A.34). This folio marker has a period, '.', at the end of it, which is illegal.\n",
|
|
"[ERROR:{Found an illegal at sign, @ (in context, this is @012A.34). This folio marker has a period, '.', at the end of it, which is illegal.}, TIBETAN_NON_PUNCTUATION:{34}]");
|
|
shelp("@[07B]", "");
|
|
shelp("@[00007B]", "");
|
|
shelp("@7B", "");
|
|
shelp("@07B", "");
|
|
shelp("@00007B", "", "[FOLIO_MARKER:{@00007B}]");
|
|
shelp("@00007 ", "", "[FOLIO_MARKER:{@00007}, TIBETAN_PUNCTUATION:{ }]");
|
|
shelp("@B00007KA", "", "[FOLIO_MARKER:{@B00007}, TIBETAN_NON_PUNCTUATION:{KA}]");
|
|
shelp("@[00007A]KA", "", "[FOLIO_MARKER:{@[00007A]}, TIBETAN_NON_PUNCTUATION:{KA}]");
|
|
|
|
shelp("GA-YENG", "", "[TIBETAN_NON_PUNCTUATION:{GA-YENG}]");
|
|
shelp("N+YA", "", "[TIBETAN_NON_PUNCTUATION:{N+YA}]");
|
|
|
|
shelp("{ DD }", "", "[DD:{{ DD }}]"); // TD3790E2.ACT
|
|
shelp("{ BP }", "", "[BP:{{ BP }}]"); // TD3790E2.ACT
|
|
shelp("//NYA\\\\",
|
|
"Offset 1 or maybe 1: Found //, which could be legal (the Unicode would be \\u0F3C\\u0F3D), but is likely in an illegal construct like //NYA\\\\.\nOffset 5 or maybe 5: Found a Sanskrit virama, \\, but the converter currently doesn't treat these properly. Sorry! Please do complain to the maintainers.\nOffset 6 or maybe 6: Found a Sanskrit virama, \\, but the converter currently doesn't treat these properly. Sorry! Please do complain to the maintainers.\n",
|
|
"[START_SLASH:{/}, ERROR:{Found //, which could be legal (the Unicode would be \\u0F3C\\u0F3D), but is likely in an illegal construct like //NYA\\\\.}, END_SLASH:{/}, TIBETAN_NON_PUNCTUATION:{NYA}, ERROR:{Found a Sanskrit virama, \\, but the converter currently doesn't treat these properly. Sorry! Please do complain to the maintainers.}, ERROR:{Found a Sanskrit virama, \\, but the converter currently doesn't treat these properly. Sorry! Please do complain to the maintainers.}]");
|
|
|
|
}
|
|
private static void uhelp(String acip) {
|
|
uhelp(acip, null);
|
|
}
|
|
private static void uhelp(String acip, String expectedUnicode) {
|
|
StringBuffer errors = new StringBuffer();
|
|
String unicode = ACIPConverter.convertToUnicode(acip, errors, null, true, "Most");
|
|
if (null == unicode) {
|
|
if (null != expectedUnicode && "none" != expectedUnicode) {
|
|
System.out.println("No unicode exists for " + acip + " but you expected " + org.thdl.tib.text.tshegbar.UnicodeUtils.unicodeStringToPrettyString(expectedUnicode));
|
|
assertTrue(false);
|
|
}
|
|
System.out.println("DLC: Unicode for " + acip + " can't be had; errors are " + errors);
|
|
} else {
|
|
if (null != expectedUnicode && !expectedUnicode.equals(unicode)) {
|
|
System.out.println("The unicode for " + acip + " is " + org.thdl.tib.text.tshegbar.UnicodeUtils.unicodeStringToPrettyString(unicode) + ", but you expected " + org.thdl.tib.text.tshegbar.UnicodeUtils.unicodeStringToPrettyString(expectedUnicode));
|
|
assertTrue(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void testACIPConversion() {
|
|
uhelp("G+DHA", "\u0f42\u0fa2");
|
|
uhelp("P'EE", "\u0f54\u0f71\u0f7b");
|
|
|
|
uhelp("KA", "\u0f40");
|
|
uhelp("KI", "\u0f40\u0f72");
|
|
uhelp("KO", "\u0f40\u0f7c");
|
|
uhelp("KE", "\u0f40\u0f7a");
|
|
uhelp("KU", "\u0f40\u0f74");
|
|
uhelp("KOO", "\u0f40\u0f7d");
|
|
uhelp("KEE", "\u0f40\u0f7b");
|
|
uhelp("KEEm", "\u0f40\u0f7b\u0f7e");
|
|
uhelp("KEEm:", "\u0f40\u0f7b\u0f7e\u0f7f");
|
|
uhelp("KEE:", "\u0f40\u0f7b\u0f7f");
|
|
|
|
uhelp("K'I", "\u0f40\u0f71\u0f72");
|
|
uhelp("K'O", "\u0f40\u0f71\u0f7c");
|
|
uhelp("K'E", "\u0f40\u0f71\u0f7a");
|
|
uhelp("K'U", "\u0f40\u0f71\u0f74");
|
|
uhelp("K'OO", "\u0f40\u0f71\u0f7d");
|
|
uhelp("K'EE", "\u0f40\u0f71\u0f7b");
|
|
uhelp("K'EEm", "\u0f40\u0f71\u0f7b\u0f7e");
|
|
tstHelper("K'EEm:", "{K'EEm:}",
|
|
new String[] { "{K'EEm:}" },
|
|
new String[] { },
|
|
"{K'EEm:}");
|
|
uhelp("K'EEm:", "\u0f40\u0f71\u0f7b\u0f7e\u0f7f");
|
|
uhelp("K'EE:", "\u0f40\u0f71\u0f7b\u0f7f");
|
|
|
|
uhelp("K'A:", "\u0f40\u0f71\u0f7f");
|
|
|
|
// DLC FIXME: in ACIP RTF files, (PARENTHESES) seem to make
|
|
// text go from 24-point to 18-point. Thus, ACIP->Unicode.txt
|
|
// is fundamentally flawed, whereas ACIP->Unicode.rtf is OK.
|
|
|
|
uhelp("/NY'EE/", "\u0f3C\u0f49\u0F71\u0F7B\u0f3D");
|
|
uhelp("*#HUm: G+DHOO GRO`;.,", "\u0f04\u0f05\u0f04\u0f05\u0f05\u0f67\u0f74\u0f7e\u0f7f\u0f0b\u0f42\u0fa2\u0f7d\u0f0b\u0f42\u0fb2\u0f7c\u0f08\u0f11\u0f0c\u0f0d");
|
|
uhelp("*#HUm: K+DHA GRO`;.,", "none");
|
|
}
|
|
|
|
/** Tests some more tsheg bars, these from Dr. Lacey's critical
|
|
edition of Mahavyutpatti.
|
|
|
|
<p>These are courtesy Peter E. Hauer, Linguasoft. Taken from
|
|
ACIP's website, but that copy was overridden by one with
|
|
corrections sent to Peter by Robert Chilton. */
|
|
public void testMV() {
|
|
System.out.println("");
|
|
System.out.println("");
|
|
System.out.println("");
|
|
System.out.println("From MV:");
|
|
System.out.println("");
|
|
System.out.println("");
|
|
System.out.println("");
|
|
|
|
tstHelper("'BANGS");
|
|
tstHelper("'BAR");
|
|
tstHelper("'BLTAS");
|
|
tstHelper("'BRA");
|
|
tstHelper("'BRA'I");
|
|
tstHelper("'BRANG");
|
|
tstHelper("'BRAS");
|
|
tstHelper("'BRED");
|
|
tstHelper("'BREG");
|
|
tstHelper("'BREL");
|
|
tstHelper("'BRIM");
|
|
tstHelper("'BRU'I");
|
|
tstHelper("'BUL");
|
|
tstHelper("'BUS");
|
|
tstHelper("'BYAMS");
|
|
tstHelper("'BYED");
|
|
tstHelper("'BYES");
|
|
tstHelper("'BYIN");
|
|
tstHelper("'BYOD");
|
|
tstHelper("'BYOR");
|
|
tstHelper("'BYUNG");
|
|
tstHelper("'CHED");
|
|
tstHelper("'CHI");
|
|
tstHelper("'CHING");
|
|
tstHelper("'CHONGS");
|
|
tstHelper("'CHOS");
|
|
tstHelper("'DAB");
|
|
tstHelper("'DAGS");
|
|
tstHelper("'DAS");
|
|
tstHelper("'DEBS");
|
|
tstHelper("'DI");
|
|
tstHelper("'DOD");
|
|
tstHelper("'DOM");
|
|
tstHelper("'DOMS");
|
|
tstHelper("'DON");
|
|
tstHelper("'DOR");
|
|
tstHelper("'DRA");
|
|
tstHelper("'DRAD");
|
|
tstHelper("'DRAMS");
|
|
tstHelper("'DRANG");
|
|
tstHelper("'DRED");
|
|
tstHelper("'DREL");
|
|
tstHelper("'DRI");
|
|
tstHelper("'DRIM");
|
|
tstHelper("'DROS");
|
|
tstHelper("'DRUB");
|
|
tstHelper("'DRUBS");
|
|
tstHelper("'DU");
|
|
tstHelper("'DUD");
|
|
tstHelper("'DUG");
|
|
tstHelper("'DUGS");
|
|
tstHelper("'DZAM");
|
|
tstHelper("'DZE");
|
|
tstHelper("'DZEM");
|
|
tstHelper("'DZES");
|
|
tstHelper("'DZIN");
|
|
tstHelper("'DZUM");
|
|
tstHelper("'DZUMS");
|
|
tstHelper("'GAG");
|
|
tstHelper("'GED");
|
|
tstHelper("'GI");
|
|
tstHelper("'GOG");
|
|
tstHelper("'GRAMS");
|
|
tstHelper("'GRES");
|
|
tstHelper("'GRIM");
|
|
tstHelper("'GRIMS");
|
|
tstHelper("'GRO");
|
|
tstHelper("'GRO'O");
|
|
tstHelper("'GRON");
|
|
tstHelper("'GRUS");
|
|
tstHelper("'GU");
|
|
tstHelper("'GYED");
|
|
tstHelper("'GYEGS");
|
|
tstHelper("'GYOD");
|
|
tstHelper("'GYUG");
|
|
tstHelper("'GYUR");
|
|
tstHelper("'JAL");
|
|
tstHelper("'JAM");
|
|
tstHelper("'JAS");
|
|
tstHelper("'JIG");
|
|
tstHelper("'JIGS");
|
|
tstHelper("'JOMS");
|
|
tstHelper("'JUG");
|
|
tstHelper("'KHAS");
|
|
tstHelper("'KHOG");
|
|
tstHelper("'KHOGS");
|
|
tstHelper("'KHOR");
|
|
tstHelper("'KHRAMS");
|
|
tstHelper("'KHRANG");
|
|
tstHelper("'KHRAS");
|
|
tstHelper("'KHREN");
|
|
tstHelper("'KHRUG");
|
|
tstHelper("'KHRUMS");
|
|
tstHelper("'KHUMS");
|
|
tstHelper("'KHYAN");
|
|
tstHelper("'KHYIL");
|
|
tstHelper("'KOD");
|
|
tstHelper("'KRAM");
|
|
tstHelper("'KRIGS");
|
|
tstHelper("'LREG");
|
|
tstHelper("'MTHUN");
|
|
tstHelper("'MTSAMS");
|
|
tstHelper("'OD");
|
|
tstHelper("'OG");
|
|
tstHelper("'ONGS");
|
|
tstHelper("'PHAGS");
|
|
tstHelper("'PHEN");
|
|
tstHelper("'PHO");
|
|
tstHelper("'PHOG");
|
|
tstHelper("'PHOGS");
|
|
tstHelper("'PHONGS");
|
|
tstHelper("'PHRED");
|
|
tstHelper("'PHREN");
|
|
tstHelper("'PHROG");
|
|
tstHelper("'PHROGS");
|
|
tstHelper("'PHRUL");
|
|
tstHelper("'PHYAM");
|
|
tstHelper("'PHYES");
|
|
tstHelper("'PHYIS");
|
|
tstHelper("'PRUL");
|
|
tstHelper("'SPONG");
|
|
tstHelper("'THAB");
|
|
tstHelper("'THABS");
|
|
tstHelper("'THAL");
|
|
tstHelper("'THAM");
|
|
tstHelper("'THAMS");
|
|
tstHelper("'THANG");
|
|
tstHelper("'THANGS");
|
|
tstHelper("'THAR");
|
|
tstHelper("'THO");
|
|
tstHelper("'THOB");
|
|
tstHelper("'THOG");
|
|
tstHelper("'THOP");
|
|
tstHelper("'THUL");
|
|
tstHelper("'THUN");
|
|
tstHelper("'THUNG");
|
|
tstHelper("'TSAM");
|
|
tstHelper("'TSAMS");
|
|
tstHelper("'TSE");
|
|
tstHelper("'TSEB");
|
|
tstHelper("'TSED");
|
|
tstHelper("'TSO");
|
|
tstHelper("'TSO'O");
|
|
tstHelper("'TSOL");
|
|
tstHelper("'TSOR");
|
|
tstHelper("'TSOS");
|
|
tstHelper("'TUN");
|
|
tstHelper("'TUNG");
|
|
tstHelper("'UR");
|
|
tstHelper("1");
|
|
tstHelper("A'M");
|
|
tstHelper("AA");
|
|
tstHelper("AAE");
|
|
tstHelper("AAI");
|
|
tstHelper("AAMRA'I");
|
|
tstHelper("AAR");
|
|
tstHelper("AASMA");
|
|
tstHelper("AE");
|
|
tstHelper("AIN");
|
|
tstHelper("AINDA");
|
|
tstHelper("AIndRANYILA");
|
|
tstHelper("AOOL");
|
|
tstHelper("AOOS");
|
|
tstHelper("AOm");
|
|
tstHelper("AU");
|
|
tstHelper("AUDPA");
|
|
tstHelper("AUDPALA");
|
|
tstHelper("AUDPALA'I");
|
|
tstHelper("AUT");
|
|
tstHelper("AUTPALA'I");
|
|
tstHelper("B'I");
|
|
tstHelper("B. (DLC!)");
|
|
tstHelper("BA");
|
|
tstHelper("BA'");
|
|
tstHelper("BA'A");
|
|
tstHelper("BA'AR");
|
|
tstHelper("BA'I");
|
|
tstHelper("BA'O");
|
|
tstHelper("BA'THUNG");
|
|
tstHelper("BAA'");
|
|
tstHelper("BAG");
|
|
tstHelper("BAI");
|
|
tstHelper("BAL");
|
|
tstHelper("BAM");
|
|
tstHelper("BAN");
|
|
tstHelper("BANDU");
|
|
tstHelper("BANG");
|
|
tstHelper("BAR");
|
|
tstHelper("BAR'");
|
|
tstHelper("BAS");
|
|
tstHelper("BAT");
|
|
tstHelper("BCA'");
|
|
tstHelper("BCAD");
|
|
tstHelper("BCAGS");
|
|
tstHelper("BCAS");
|
|
tstHelper("BCDU");
|
|
tstHelper("BCHA");
|
|
tstHelper("BCHU");
|
|
tstHelper("BCO");
|
|
tstHelper("BCOR");
|
|
tstHelper("BCU");
|
|
tstHelper("BCUD");
|
|
tstHelper("BCUG");
|
|
tstHelper("BCUGS");
|
|
tstHelper("BCUR");
|
|
tstHelper("BCUS");
|
|
tstHelper("BDA");
|
|
tstHelper("BDAG");
|
|
tstHelper("BDAR");
|
|
tstHelper("BDE");
|
|
tstHelper("BDEG");
|
|
tstHelper("BDUD");
|
|
tstHelper("BDUN");
|
|
tstHelper("BE'I");
|
|
tstHelper("BE'U");
|
|
tstHelper("BEE");
|
|
tstHelper("BEEdURYA'I");
|
|
tstHelper("BGAG");
|
|
tstHelper("BGANG");
|
|
tstHelper("BGCUD");
|
|
tstHelper("BGE");
|
|
tstHelper("BGO");
|
|
tstHelper("BGOD");
|
|
tstHelper("BGRAD");
|
|
tstHelper("BGRANG");
|
|
tstHelper("BGREL");
|
|
tstHelper("BGRES");
|
|
tstHelper("BHA");
|
|
tstHelper("BHA'I");
|
|
tstHelper("BHI");
|
|
tstHelper("BHINTA");
|
|
tstHelper("BHINY");
|
|
tstHelper("BI");
|
|
tstHelper("BIM");
|
|
tstHelper("BIMBA");
|
|
tstHelper("BIN");
|
|
tstHelper("BING");
|
|
tstHelper("BIsnU");
|
|
tstHelper("BKABS");
|
|
tstHelper("BKHI");
|
|
tstHelper("BKOD");
|
|
tstHelper("BKRAM");
|
|
tstHelper("BKRES");
|
|
tstHelper("BKRI");
|
|
tstHelper("BKRIS");
|
|
tstHelper("BKROL");
|
|
tstHelper("BKRUGS");
|
|
tstHelper("BKYANG");
|
|
tstHelper("BLA");
|
|
tstHelper("BLAS");
|
|
tstHelper("BLO");
|
|
tstHelper("BLTAN");
|
|
tstHelper("BLUGS");
|
|
tstHelper("BNYIS");
|
|
tstHelper("BO");
|
|
tstHelper("BO'I");
|
|
tstHelper("BO'O");
|
|
tstHelper("BON");
|
|
tstHelper("BONG");
|
|
tstHelper("BOR");
|
|
tstHelper("BPAG");
|
|
tstHelper("BRAG");
|
|
tstHelper("BRAL");
|
|
tstHelper("BRAM");
|
|
tstHelper("BRDEG");
|
|
tstHelper("BRDUM");
|
|
tstHelper("BRDUNGS");
|
|
tstHelper("BRDZES");
|
|
tstHelper("BRGOD");
|
|
tstHelper("BRGYA");
|
|
tstHelper("BRGYA'I");
|
|
tstHelper("BRGYAD");
|
|
tstHelper("BRGYAL");
|
|
tstHelper("BRING");
|
|
tstHelper("BRJID");
|
|
tstHelper("BRJOD");
|
|
tstHelper("BRKU");
|
|
tstHelper("BRKUR");
|
|
tstHelper("BRLAD");
|
|
tstHelper("BRLANG");
|
|
tstHelper("BRLANGS");
|
|
tstHelper("BRNGAS");
|
|
tstHelper("BRNGOD");
|
|
tstHelper("BRNGOGS");
|
|
tstHelper("BRNGOS");
|
|
tstHelper("BRNGUBS");
|
|
tstHelper("BRNYAN");
|
|
tstHelper("BRONG");
|
|
tstHelper("BRTAN");
|
|
tstHelper("BRTEG");
|
|
tstHelper("BRTEGS");
|
|
tstHelper("BRTEN");
|
|
tstHelper("BRTON");
|
|
tstHelper("BRTUL");
|
|
tstHelper("BRTZAGS");
|
|
tstHelper("BRTZAN");
|
|
tstHelper("BRTZANG");
|
|
tstHelper("BRTZEGS");
|
|
tstHelper("BRTZENGS");
|
|
tstHelper("BRTZER");
|
|
tstHelper("BRTZI");
|
|
tstHelper("BRTZIBS");
|
|
tstHelper("BRTZIS");
|
|
tstHelper("BRTZOGS");
|
|
tstHelper("BRTZON");
|
|
tstHelper("BRUNGS");
|
|
tstHelper("BSAGS");
|
|
tstHelper("BSAL");
|
|
tstHelper("BSANGS");
|
|
tstHelper("BSBRUGS");
|
|
tstHelper("BSDUNGS");
|
|
tstHelper("BSDUS");
|
|
tstHelper("BSEG");
|
|
tstHelper("BSGRAGS");
|
|
tstHelper("BSGRE");
|
|
tstHelper("BSGRENG");
|
|
tstHelper("BSGRES");
|
|
tstHelper("BSGRUB");
|
|
tstHelper("BSGRUNGS");
|
|
tstHelper("BSGUR");
|
|
tstHelper("BSGYINGS");
|
|
tstHelper("BSGYUR");
|
|
tstHelper("BSHAD");
|
|
tstHelper("BSHAMS");
|
|
tstHelper("BSHES");
|
|
tstHelper("BSHUNG");
|
|
tstHelper("BSIG");
|
|
tstHelper("BSIL");
|
|
tstHelper("BSING");
|
|
tstHelper("BSKHYED");
|
|
tstHelper("BSKOD");
|
|
tstHelper("BSKOR");
|
|
tstHelper("BSKOS");
|
|
tstHelper("BSKRANGS");
|
|
tstHelper("BSKRI");
|
|
tstHelper("BSKRIS");
|
|
tstHelper("BSKROD");
|
|
tstHelper("BSKYANG");
|
|
tstHelper("BSKYED");
|
|
tstHelper("BSKYENG");
|
|
tstHelper("BSKYIMS");
|
|
tstHelper("BSKYIS");
|
|
tstHelper("BSKYOD");
|
|
tstHelper("BSLAS");
|
|
tstHelper("BSNAN");
|
|
tstHelper("BSNGAGS");
|
|
tstHelper("BSNGAL");
|
|
tstHelper("BSNUM");
|
|
tstHelper("BSNUN");
|
|
tstHelper("BSNYAGS");
|
|
tstHelper("BSNYUNG");
|
|
tstHelper("BSREG");
|
|
tstHelper("BSREL");
|
|
tstHelper("BSRUBS");
|
|
tstHelper("BSRUNG");
|
|
tstHelper("BSTAN");
|
|
tstHelper("BSTOBS");
|
|
tstHelper("BSTOD");
|
|
tstHelper("BSTUS");
|
|
tstHelper("BSTZIS");
|
|
tstHelper("BTA'");
|
|
tstHelper("BTAB");
|
|
tstHelper("BTAM");
|
|
tstHelper("BTANG");
|
|
tstHelper("BTER");
|
|
tstHelper("BTUB");
|
|
tstHelper("BTUL");
|
|
tstHelper("BTZAM");
|
|
tstHelper("BTZAN");
|
|
tstHelper("BTZER");
|
|
tstHelper("BTZI");
|
|
tstHelper("BTZUB");
|
|
tstHelper("BTZUGS");
|
|
tstHelper("BTZVA");
|
|
tstHelper("BU");
|
|
tstHelper("BU'I");
|
|
tstHelper("BU'O");
|
|
tstHelper("BUR");
|
|
tstHelper("BYA");
|
|
tstHelper("BYA'A");
|
|
tstHelper("BYA'O");
|
|
tstHelper("BYAL");
|
|
tstHelper("BYAN");
|
|
tstHelper("BYANG");
|
|
tstHelper("BYAS");
|
|
tstHelper("BYE");
|
|
tstHelper("BYE'U");
|
|
tstHelper("BYED");
|
|
tstHelper("BYENG");
|
|
tstHelper("BYIN");
|
|
tstHelper("BYIS");
|
|
tstHelper("BYOD");
|
|
tstHelper("BYOL");
|
|
tstHelper("BYUGS");
|
|
tstHelper("BYUL");
|
|
tstHelper("BYUNG");
|
|
tstHelper("BZA'");
|
|
tstHelper("BZANG");
|
|
tstHelper("BZHAG");
|
|
tstHelper("BZHI");
|
|
tstHelper("BZHIGS");
|
|
tstHelper("BZHIN");
|
|
tstHelper("BZHING");
|
|
tstHelper("BZHUBS");
|
|
tstHelper("BZHUGS");
|
|
tstHelper("BZLOS");
|
|
tstHelper("BZUN");
|
|
tstHelper("BZUNG");
|
|
tstHelper("CA");
|
|
tstHelper("CA'I");
|
|
tstHelper("CAD");
|
|
tstHelper("CAN");
|
|
tstHelper("CANG");
|
|
tstHelper("CAn");
|
|
tstHelper("CE");
|
|
tstHelper("CES");
|
|
tstHelper("CHA");
|
|
tstHelper("CHAD");
|
|
tstHelper("CHAGS");
|
|
tstHelper("CHANG");
|
|
tstHelper("CHAS");
|
|
tstHelper("CHE");
|
|
tstHelper("CHE'I");
|
|
tstHelper("CHEN");
|
|
tstHelper("CHER");
|
|
tstHelper("CHO");
|
|
tstHelper("CHOMS");
|
|
tstHelper("CHOS");
|
|
tstHelper("CHU");
|
|
tstHelper("CHU'I");
|
|
tstHelper("CHUB");
|
|
tstHelper("CHUMS");
|
|
tstHelper("CHUNG");
|
|
tstHelper("CHUNG'U");
|
|
tstHelper("CHUNGS");
|
|
tstHelper("CIG");
|
|
tstHelper("CING");
|
|
tstHelper("CO");
|
|
tstHelper("CONG");
|
|
tstHelper("COR");
|
|
tstHelper("COS");
|
|
tstHelper("CYA");
|
|
tstHelper("D'U");
|
|
tstHelper("DA");
|
|
tstHelper("DA'I");
|
|
tstHelper("DA'URYA");
|
|
tstHelper("DAD");
|
|
tstHelper("DAG");
|
|
tstHelper("DAGS");
|
|
tstHelper("DAM");
|
|
tstHelper("DAMBA");
|
|
tstHelper("DAN");
|
|
tstHelper("DANG");
|
|
tstHelper("DAR");
|
|
tstHelper("DAU");
|
|
tstHelper("DBA'");
|
|
tstHelper("DBA'I");
|
|
tstHelper("DBAG");
|
|
tstHelper("DBANG");
|
|
tstHelper("DBU'I");
|
|
tstHelper("DBUG");
|
|
tstHelper("DBUGS");
|
|
tstHelper("DBYANGS");
|
|
tstHelper("DBYAR");
|
|
tstHelper("DBYE");
|
|
tstHelper("DBYE'I");
|
|
tstHelper("DBYES");
|
|
tstHelper("DBYINS");
|
|
tstHelper("DBYIR");
|
|
tstHelper("DE");
|
|
tstHelper("DE'I");
|
|
tstHelper("DENG");
|
|
tstHelper("DGA");
|
|
tstHelper("DGA'");
|
|
tstHelper("DGAB");
|
|
tstHelper("DGAG");
|
|
tstHelper("DGE");
|
|
tstHelper("DGRA");
|
|
tstHelper("DGRA'I");
|
|
tstHelper("DGU'I");
|
|
tstHelper("DGYE'O");
|
|
tstHelper("DHA");
|
|
tstHelper("DHA'");
|
|
tstHelper("DHA'I");
|
|
tstHelper("DHANU");
|
|
tstHelper("DHU");
|
|
tstHelper("DI");
|
|
tstHelper("DI'I");
|
|
tstHelper("DIG");
|
|
tstHelper("DJOGS");
|
|
tstHelper("DKA'");
|
|
tstHelper("DKAR");
|
|
tstHelper("DKOD");
|
|
tstHelper("DKRI");
|
|
tstHelper("DKRUGS");
|
|
tstHelper("DKU");
|
|
tstHelper("DKUGS");
|
|
tstHelper("DKUS");
|
|
tstHelper("DKYIL");
|
|
tstHelper("DMA");
|
|
tstHelper("DMAN");
|
|
tstHelper("DMAR");
|
|
tstHelper("DMEL");
|
|
tstHelper("DMIGS");
|
|
tstHelper("DMYIGS");
|
|
tstHelper("DNGOS");
|
|
tstHelper("DO");
|
|
tstHelper("DOG");
|
|
tstHelper("DON");
|
|
tstHelper("DONG");
|
|
tstHelper("DOR");
|
|
tstHelper("DPA");
|
|
tstHelper("DPA'");
|
|
tstHelper("DPAG");
|
|
tstHelper("DPAL");
|
|
tstHelper("DPAS");
|
|
tstHelper("DPE");
|
|
tstHelper("DPER");
|
|
tstHelper("DPON");
|
|
tstHelper("DPRAL");
|
|
tstHelper("DPUN");
|
|
tstHelper("DPUNG");
|
|
tstHelper("DPYA'");
|
|
tstHelper("DPYID");
|
|
tstHelper("DPYINGS");
|
|
tstHelper("DPYOD");
|
|
tstHelper("DRA");
|
|
tstHelper("DRAG");
|
|
tstHelper("DRAN");
|
|
tstHelper("DRANG");
|
|
tstHelper("DRE'U");
|
|
tstHelper("DREGS");
|
|
tstHelper("DRI");
|
|
tstHelper("DRID");
|
|
tstHelper("DRIN");
|
|
tstHelper("DRNGUBS");
|
|
tstHelper("DROS");
|
|
tstHelper("DRUG");
|
|
tstHelper("DSPYOD");
|
|
tstHelper("DTAR");
|
|
tstHelper("DU");
|
|
tstHelper("DU'I");
|
|
tstHelper("DUG");
|
|
tstHelper("DUNG");
|
|
tstHelper("DUS");
|
|
tstHelper("DVAGS");
|
|
tstHelper("DW'A");
|
|
tstHelper("DZAM");
|
|
tstHelper("DZAMBU");
|
|
tstHelper("DZAMBU'I");
|
|
tstHelper("DZI");
|
|
tstHelper("DZIN");
|
|
tstHelper("DZOGS");
|
|
tstHelper("G-YAS");
|
|
tstHelper("G-YOR");
|
|
tstHelper("G-YUM");
|
|
tstHelper("G-YUNG");
|
|
tstHelper("GA");
|
|
tstHelper("GA'A");
|
|
tstHelper("GA'I");
|
|
tstHelper("GAL");
|
|
tstHelper("GAM");
|
|
tstHelper("GAMS");
|
|
tstHelper("GAN");
|
|
tstHelper("GANG");
|
|
tstHelper("GAR");
|
|
tstHelper("GAS");
|
|
tstHelper("GAU");
|
|
tstHelper("GAmGA'I");
|
|
tstHelper("GAn");
|
|
tstHelper("GAndI");
|
|
tstHelper("GBA");
|
|
tstHelper("GCIG");
|
|
tstHelper("GCIN");
|
|
tstHelper("GCOL");
|
|
tstHelper("GCONG");
|
|
tstHelper("GDAGS");
|
|
tstHelper("GDEGS");
|
|
tstHelper("GDGAS");
|
|
tstHelper("GDOL");
|
|
tstHelper("GDONGS");
|
|
tstHelper("GDUD");
|
|
tstHelper("GDUG");
|
|
tstHelper("GDUG.PA (DLC!)");
|
|
tstHelper("GDUGS");
|
|
tstHelper("GDUN");
|
|
tstHelper("GE");
|
|
tstHelper("GE'I");
|
|
tstHelper("GENGS");
|
|
tstHelper("GHI");
|
|
tstHelper("GHOM");
|
|
tstHelper("GI");
|
|
tstHelper("GIR");
|
|
tstHelper("GIS");
|
|
tstHelper("GLA");
|
|
tstHelper("GLAB");
|
|
tstHelper("GLAL");
|
|
tstHelper("GLANG");
|
|
tstHelper("GLO");
|
|
tstHelper("GLONGS");
|
|
tstHelper("GLUGS");
|
|
tstHelper("GNA'I");
|
|
tstHelper("GNAD");
|
|
tstHelper("GNAS");
|
|
tstHelper("GNGER");
|
|
tstHelper("GNOD");
|
|
tstHelper("GNON");
|
|
tstHelper("GNYA'");
|
|
tstHelper("GNYAR");
|
|
tstHelper("GNYE'U");
|
|
tstHelper("GNYEN");
|
|
tstHelper("GNYER");
|
|
tstHelper("GNYI");
|
|
tstHelper("GNYIS");
|
|
tstHelper("GO");
|
|
tstHelper("GO'I");
|
|
tstHelper("GONG");
|
|
tstHelper("GOOTAMA");
|
|
tstHelper("GOS");
|
|
tstHelper("GRAG");
|
|
tstHelper("GRAGS");
|
|
tstHelper("GRANGS");
|
|
tstHelper("GRANS");
|
|
tstHelper("GREG");
|
|
tstHelper("GRO");
|
|
tstHelper("GRO'I");
|
|
tstHelper("GROG");
|
|
tstHelper("GROGS");
|
|
tstHelper("GROR");
|
|
tstHelper("GRUNGS");
|
|
tstHelper("GRUR");
|
|
tstHelper("GSAL");
|
|
tstHelper("GSANG");
|
|
tstHelper("GSAR");
|
|
tstHelper("GSDEGS");
|
|
tstHelper("GSEB");
|
|
tstHelper("GSEG");
|
|
tstHelper("GSER");
|
|
tstHelper("GSHE");
|
|
tstHelper("GSHE'");
|
|
tstHelper("GSHEGS");
|
|
tstHelper("GSHING");
|
|
tstHelper("GSIGS");
|
|
tstHelper("GSO");
|
|
tstHelper("GSOL");
|
|
tstHelper("GSOS");
|
|
tstHelper("GSRUNG");
|
|
tstHelper("GSUM");
|
|
tstHelper("GSUNGS");
|
|
tstHelper("GTA'");
|
|
tstHelper("GTAGS");
|
|
tstHelper("GTAM");
|
|
tstHelper("GTAMS");
|
|
tstHelper("GTAN");
|
|
tstHelper("GTEGS");
|
|
tstHelper("GTING");
|
|
tstHelper("GTOGS");
|
|
tstHelper("GTOL");
|
|
tstHelper("GTONG");
|
|
tstHelper("GTUBS");
|
|
tstHelper("GTUM");
|
|
tstHelper("GTZAB");
|
|
tstHelper("GTZAD");
|
|
tstHelper("GTZANG");
|
|
tstHelper("GTZUG");
|
|
tstHelper("GTZUGS");
|
|
tstHelper("GU");
|
|
tstHelper("GU'O");
|
|
tstHelper("GYA");
|
|
tstHelper("GYAN");
|
|
tstHelper("GYAR");
|
|
tstHelper("GYAS");
|
|
tstHelper("GYES");
|
|
tstHelper("GYI");
|
|
tstHelper("GYIR");
|
|
tstHelper("GYIS");
|
|
tstHelper("GYO");
|
|
tstHelper("GYOR");
|
|
tstHelper("GYUL");
|
|
tstHelper("GYUR");
|
|
tstHelper("GZANG");
|
|
tstHelper("GZAR");
|
|
tstHelper("GZENG");
|
|
tstHelper("GZENGS");
|
|
tstHelper("GZES");
|
|
tstHelper("GZHA'I");
|
|
tstHelper("GZHAG");
|
|
tstHelper("GZHAL");
|
|
tstHelper("GZHAN");
|
|
tstHelper("GZHANG");
|
|
tstHelper("GZHEL");
|
|
tstHelper("GZHI");
|
|
tstHelper("GZHIG");
|
|
tstHelper("GZHON");
|
|
tstHelper("GZHUNG");
|
|
tstHelper("GZI");
|
|
tstHelper("GZIL");
|
|
tstHelper("GZUGS");
|
|
tstHelper("GZUNG");
|
|
tstHelper("GZUNGS");
|
|
tstHelper("GZUNGS'I");
|
|
tstHelper("GndA'I");
|
|
tstHelper("GndAA'I");
|
|
tstHelper("H'A");
|
|
tstHelper("HA");
|
|
tstHelper("HAB");
|
|
tstHelper("HAM");
|
|
tstHelper("HANG");
|
|
tstHelper("HETU");
|
|
tstHelper("HETUR");
|
|
tstHelper("HU");
|
|
tstHelper("HUD");
|
|
tstHelper("JA");
|
|
tstHelper("JAA'");
|
|
tstHelper("JI");
|
|
tstHelper("JIGS");
|
|
tstHelper("JO");
|
|
tstHelper("JO'U");
|
|
tstHelper("K'AU");
|
|
tstHelper("KA");
|
|
tstHelper("KA'A");
|
|
tstHelper("KA'ASHI");
|
|
tstHelper("KA'ASHI'I");
|
|
tstHelper("KA'I");
|
|
tstHelper("KA'U");
|
|
tstHelper("KAA'");
|
|
tstHelper("KAL");
|
|
tstHelper("KAM");
|
|
tstHelper("KAR");
|
|
tstHelper("KARAnA");
|
|
tstHelper("KE'U");
|
|
tstHelper("KGRAG");
|
|
tstHelper("KHA");
|
|
tstHelper("KHAMS");
|
|
tstHelper("KHANG");
|
|
tstHelper("KHANS");
|
|
tstHelper("KHE'U");
|
|
tstHelper("KHRA");
|
|
tstHelper("KHRAM");
|
|
tstHelper("KHRI");
|
|
tstHelper("KHRIG");
|
|
tstHelper("KHRIS");
|
|
tstHelper("KHUD");
|
|
tstHelper("KHUG");
|
|
tstHelper("KHYAB");
|
|
tstHelper("KHYAD");
|
|
tstHelper("KHYE'U");
|
|
tstHelper("KHYE'US");
|
|
tstHelper("KHYED");
|
|
tstHelper("KHYIM");
|
|
tstHelper("KHYOD");
|
|
tstHelper("KHYON");
|
|
tstHelper("KI");
|
|
tstHelper("KKU");
|
|
tstHelper("KLU'I");
|
|
tstHelper("KLUG");
|
|
tstHelper("KO");
|
|
tstHelper("KOO");
|
|
tstHelper("KOOSHAMBHI");
|
|
tstHelper("KOS");
|
|
tstHelper("KRIS");
|
|
tstHelper("KROL");
|
|
tstHelper("KROS");
|
|
tstHelper("KTI");
|
|
tstHelper("KU");
|
|
tstHelper("KULA");
|
|
tstHelper("KUM");
|
|
tstHelper("KUN");
|
|
tstHelper("KUR");
|
|
tstHelper("KY");
|
|
tstHelper("KYA");
|
|
tstHelper("KYA'I");
|
|
tstHelper("KYANG");
|
|
tstHelper("KYE");
|
|
tstHelper("KYI");
|
|
tstHelper("KYIS");
|
|
tstHelper("KYOD");
|
|
tstHelper("KsI");
|
|
tstHelper("L'A");
|
|
tstHelper("LA");
|
|
tstHelper("LA$GCAGS");
|
|
tstHelper("LA'A");
|
|
tstHelper("LA'I");
|
|
tstHelper("LAG");
|
|
tstHelper("LAM");
|
|
tstHelper("LAN");
|
|
tstHelper("LANDA");
|
|
tstHelper("LANG");
|
|
tstHelper("LANGGA");
|
|
tstHelper("LANGS");
|
|
tstHelper("LAR");
|
|
tstHelper("LAS");
|
|
tstHelper("LBA");
|
|
tstHelper("LBANG");
|
|
tstHelper("LCAG");
|
|
tstHelper("LCAGS");
|
|
tstHelper("LCAM");
|
|
tstHelper("LCAMS");
|
|
tstHelper("LCE");
|
|
tstHelper("LCE'U");
|
|
tstHelper("LDAN");
|
|
tstHelper("LDIBS");
|
|
tstHelper("LDOB");
|
|
tstHelper("LDOG");
|
|
tstHelper("LDOGS");
|
|
tstHelper("LDONGS");
|
|
tstHelper("LE");
|
|
tstHelper("LE'I");
|
|
tstHelper("LE'U'I");
|
|
tstHelper("LE'UR");
|
|
tstHelper("LEB");
|
|
tstHelper("LED");
|
|
tstHelper("LEGS");
|
|
tstHelper("LEN");
|
|
tstHelper("LENDRA");
|
|
tstHelper("LHA");
|
|
tstHelper("LHAG");
|
|
tstHelper("LHAL");
|
|
tstHelper("LHAN");
|
|
tstHelper("LHONGS");
|
|
tstHelper("LHUN");
|
|
tstHelper("LHUNG");
|
|
tstHelper("LI");
|
|
tstHelper("LI'I");
|
|
tstHelper("LIN");
|
|
tstHelper("LJAB");
|
|
tstHelper("LJANG");
|
|
tstHelper("LJIB");
|
|
tstHelper("LJIBS");
|
|
tstHelper("LKOG");
|
|
tstHelper("LNGA");
|
|
tstHelper("LNGA'I");
|
|
tstHelper("LNGA'I'I");
|
|
tstHelper("LNGOG");
|
|
tstHelper("LO");
|
|
tstHelper("LOBS");
|
|
tstHelper("LOGS");
|
|
tstHelper("LTA");
|
|
tstHelper("LTAR");
|
|
tstHelper("LTU");
|
|
tstHelper("LTUN");
|
|
tstHelper("LTUNG");
|
|
tstHelper("LU");
|
|
tstHelper("LU'I");
|
|
tstHelper("LUGS");
|
|
tstHelper("LUM");
|
|
tstHelper("LUS");
|
|
tstHelper("MA");
|
|
tstHelper("MA'A");
|
|
tstHelper("MA'I");
|
|
tstHelper("MAL");
|
|
tstHelper("MAN");
|
|
tstHelper("MANDA");
|
|
tstHelper("MANG");
|
|
tstHelper("MANYDZU");
|
|
tstHelper("MAR");
|
|
tstHelper("MAS");
|
|
tstHelper("MBI");
|
|
tstHelper("MCHAN");
|
|
tstHelper("MCHED");
|
|
tstHelper("MCHING");
|
|
tstHelper("MCHOD");
|
|
tstHelper("MCHOG");
|
|
tstHelper("MCHU");
|
|
tstHelper("MCHUR");
|
|
tstHelper("MDA'");
|
|
tstHelper("MDANGS");
|
|
tstHelper("MDAS");
|
|
tstHelper("MDO'I");
|
|
tstHelper("MDOG");
|
|
tstHelper("MDON");
|
|
tstHelper("MDUD");
|
|
tstHelper("MDUN");
|
|
tstHelper("MDZAD");
|
|
tstHelper("MDZES");
|
|
tstHelper("MDZOS");
|
|
tstHelper("ME");
|
|
tstHelper("ME'I");
|
|
tstHelper("MED");
|
|
tstHelper("MGA");
|
|
tstHelper("MGO");
|
|
tstHelper("MGO'I");
|
|
tstHelper("MGOS");
|
|
tstHelper("MGRON");
|
|
tstHelper("MI");
|
|
tstHelper("MI'I");
|
|
tstHelper("MID");
|
|
tstHelper("MIG");
|
|
tstHelper("MING");
|
|
tstHelper("MKHA'");
|
|
tstHelper("MKHA'I");
|
|
tstHelper("MKHAH");
|
|
tstHelper("MKHAN");
|
|
tstHelper("MKHAS");
|
|
tstHelper("MKHEN");
|
|
tstHelper("MKHRANG");
|
|
tstHelper("MKHREN");
|
|
tstHelper("MKHYEN");
|
|
tstHelper("MMING");
|
|
tstHelper("MNGAGS");
|
|
tstHelper("MNGAS");
|
|
tstHelper("MNGON");
|
|
tstHelper("MNYA'");
|
|
tstHelper("MNYAM");
|
|
tstHelper("MNYUNG");
|
|
tstHelper("MO");
|
|
tstHelper("MO'I");
|
|
tstHelper("MO'U");
|
|
tstHelper("MON");
|
|
tstHelper("MONGS");
|
|
tstHelper("MONS");
|
|
tstHelper("MOS");
|
|
tstHelper("MTHA'");
|
|
tstHelper("MTHAB");
|
|
tstHelper("MTHAN");
|
|
tstHelper("MTHANGS");
|
|
tstHelper("MTHAR");
|
|
tstHelper("MTHO");
|
|
tstHelper("MTHONG");
|
|
tstHelper("MTHU");
|
|
tstHelper("MTHUM");
|
|
tstHelper("MTHUN");
|
|
tstHelper("MTHUNG");
|
|
tstHelper("MTHUS");
|
|
tstHelper("MTON");
|
|
tstHelper("MTONG");
|
|
tstHelper("MTSA");
|
|
tstHelper("MTSAMS");
|
|
tstHelper("MTSAN");
|
|
tstHelper("MTSANS");
|
|
tstHelper("MTSO'I");
|
|
tstHelper("MTSONG");
|
|
tstHelper("MTSOS");
|
|
tstHelper("MTSUNG");
|
|
tstHelper("MTSUNGS");
|
|
tstHelper("MU");
|
|
tstHelper("MUG");
|
|
tstHelper("MYA");
|
|
tstHelper("MYANG");
|
|
tstHelper("MYAS");
|
|
tstHelper("MYID");
|
|
tstHelper("MYOG");
|
|
tstHelper("MYONG");
|
|
tstHelper("MYOS");
|
|
tstHelper("MYUNG");
|
|
tstHelper("N'I");
|
|
tstHelper("NA");
|
|
tstHelper("NA'I");
|
|
tstHelper("NAD");
|
|
tstHelper("NAG");
|
|
tstHelper("NAM");
|
|
tstHelper("NANG");
|
|
tstHelper("NAS");
|
|
tstHelper("NDA");
|
|
tstHelper("NE");
|
|
tstHelper("NE'U");
|
|
tstHelper("NES");
|
|
tstHelper("NGA");
|
|
tstHelper("NGA'I");
|
|
tstHelper("NGAB");
|
|
tstHelper("NGAG");
|
|
tstHelper("NGAL");
|
|
tstHelper("NGAN");
|
|
tstHelper("NGE");
|
|
tstHelper("NGE'I");
|
|
tstHelper("NGES");
|
|
tstHelper("NGO");
|
|
tstHelper("NGOR");
|
|
tstHelper("NGU'I");
|
|
tstHelper("NI");
|
|
tstHelper("NI'A");
|
|
tstHelper("NIG");
|
|
tstHelper("NIMITTA");
|
|
tstHelper("NIS");
|
|
tstHelper("NO");
|
|
tstHelper("NOG");
|
|
tstHelper("NOGS");
|
|
tstHelper("NONG");
|
|
tstHelper("NU");
|
|
tstHelper("NU'I");
|
|
tstHelper("NUB");
|
|
tstHelper("NYA");
|
|
tstHelper("NYAMS");
|
|
tstHelper("NYAN");
|
|
tstHelper("NYDZU");
|
|
tstHelper("NYE");
|
|
tstHelper("NYE'U");
|
|
tstHelper("NYEN");
|
|
tstHelper("NYES");
|
|
tstHelper("NYI");
|
|
tstHelper("NYID");
|
|
tstHelper("NYING");
|
|
tstHelper("NYON");
|
|
tstHelper("NYUG");
|
|
tstHelper("OD");
|
|
tstHelper("PA");
|
|
tstHelper("PA'A");
|
|
tstHelper("PA'I");
|
|
tstHelper("PA'LA");
|
|
tstHelper("PA'O");
|
|
tstHelper("PAD");
|
|
tstHelper("PADMA");
|
|
tstHelper("PADMA'I");
|
|
tstHelper("PAG");
|
|
tstHelper("PALA");
|
|
tstHelper("PANG");
|
|
tstHelper("PAR");
|
|
tstHelper("PARU");
|
|
tstHelper("PAS");
|
|
tstHelper("PA");
|
|
tstHelper("PHA");
|
|
tstHelper("PHAN");
|
|
tstHelper("PHEG");
|
|
tstHelper("PHI");
|
|
tstHelper("PHIN");
|
|
tstHelper("PHIR");
|
|
tstHelper("PHOD");
|
|
tstHelper("PHOG");
|
|
tstHelper("PHRA");
|
|
tstHelper("PHRAG");
|
|
tstHelper("PHRAN");
|
|
tstHelper("PHREN");
|
|
tstHelper("PHRENG");
|
|
tstHelper("PHROGS");
|
|
tstHelper("PHRUG");
|
|
tstHelper("PHUDG");
|
|
tstHelper("PHUN");
|
|
tstHelper("PHUNG");
|
|
tstHelper("PHUR");
|
|
tstHelper("PHYAG");
|
|
tstHelper("PHYE");
|
|
tstHelper("PHYI");
|
|
tstHelper("PHYIN");
|
|
tstHelper("PHYIR");
|
|
tstHelper("PHYIS");
|
|
tstHelper("PHYOGS");
|
|
tstHelper("PHYUN");
|
|
tstHelper("PHYUNG");
|
|
tstHelper("PHYUNGS");
|
|
tstHelper("PI");
|
|
tstHelper("PINGKA");
|
|
tstHelper("PO");
|
|
tstHelper("PO'I");
|
|
tstHelper("PO'i");
|
|
tstHelper("POR");
|
|
tstHelper("POS");
|
|
tstHelper("PRA");
|
|
tstHelper("PRAKshVA");
|
|
tstHelper("PRAL");
|
|
tstHelper("PRASIDDHA");
|
|
tstHelper("PRI");
|
|
tstHelper("PRONG");
|
|
tstHelper("PUN");
|
|
tstHelper("PUNANA'A");
|
|
tstHelper("PUS");
|
|
tstHelper("PYE");
|
|
tstHelper("R'AGA");
|
|
tstHelper("RA");
|
|
tstHelper("RA'");
|
|
tstHelper("RA'A");
|
|
tstHelper("RA'I");
|
|
tstHelper("RAA'");
|
|
tstHelper("RAB");
|
|
tstHelper("RABS");
|
|
tstHelper("RAG");
|
|
tstHelper("RAL");
|
|
tstHelper("RAN");
|
|
tstHelper("RANG");
|
|
tstHelper("RAS");
|
|
tstHelper("RAndABA");
|
|
tstHelper("RBOD");
|
|
tstHelper("RBYAR");
|
|
tstHelper("RDAS");
|
|
tstHelper("RDE'U");
|
|
tstHelper("RDEG");
|
|
tstHelper("RDO");
|
|
tstHelper("RDOB");
|
|
tstHelper("RDOBS");
|
|
tstHelper("RDUM");
|
|
tstHelper("RDZAS");
|
|
tstHelper("RDZI");
|
|
tstHelper("RDZOGS");
|
|
tstHelper("RDZU");
|
|
tstHelper("RDZUL");
|
|
tstHelper("RENGS");
|
|
tstHelper("RGOD");
|
|
tstHelper("RGOG");
|
|
tstHelper("RGOS");
|
|
tstHelper("RGYA");
|
|
tstHelper("RGYAL");
|
|
tstHelper("RGYAN");
|
|
tstHelper("RGYANG");
|
|
tstHelper("RGYAS");
|
|
tstHelper("RGYES");
|
|
tstHelper("RGYU");
|
|
tstHelper("RGYUD");
|
|
tstHelper("RGYUN");
|
|
tstHelper("RGYUS");
|
|
tstHelper("RI");
|
|
tstHelper("RI'I");
|
|
tstHelper("RIGS");
|
|
tstHelper("RIL");
|
|
tstHelper("RIM");
|
|
tstHelper("RIN");
|
|
tstHelper("RING");
|
|
tstHelper("RIS");
|
|
tstHelper("RJE");
|
|
tstHelper("RJE'U");
|
|
tstHelper("RJES");
|
|
tstHelper("RJO");
|
|
tstHelper("RKA'I");
|
|
tstHelper("RKANG");
|
|
tstHelper("RKO");
|
|
tstHelper("RKU");
|
|
tstHelper("RKUN");
|
|
tstHelper("RKYEN");
|
|
tstHelper("RLABS");
|
|
tstHelper("RLE'O");
|
|
tstHelper("RLING");
|
|
tstHelper("RMAL");
|
|
tstHelper("RMEL");
|
|
tstHelper("RMONG");
|
|
tstHelper("RMONGS");
|
|
tstHelper("RMUS");
|
|
tstHelper("RMYANGS");
|
|
tstHelper("RNA");
|
|
tstHelper("RNABS");
|
|
tstHelper("RNAM");
|
|
tstHelper("RNAMS");
|
|
tstHelper("RNGA'U");
|
|
tstHelper("RNGAB");
|
|
tstHelper("RNGANGS");
|
|
tstHelper("RNGE");
|
|
tstHelper("RNGOG");
|
|
tstHelper("RNGU");
|
|
tstHelper("RNGUS");
|
|
tstHelper("RNOGS");
|
|
tstHelper("RO");
|
|
tstHelper("RO.STOD (DLC!)");
|
|
tstHelper("ROL");
|
|
tstHelper("RSBOD");
|
|
tstHelper("RTAG");
|
|
tstHelper("RTE'");
|
|
tstHelper("RTEN");
|
|
tstHelper("RTOL");
|
|
tstHelper("RTUL");
|
|
tstHelper("RTYAM");
|
|
tstHelper("RTZA");
|
|
tstHelper("RTZAL");
|
|
tstHelper("RTZE");
|
|
tstHelper("RTZENGS");
|
|
tstHelper("RTZI");
|
|
tstHelper("RTZIBS");
|
|
tstHelper("RTZIS");
|
|
tstHelper("RTZUB");
|
|
tstHelper("RTZUBS");
|
|
tstHelper("RU");
|
|
tstHelper("RUL");
|
|
tstHelper("RUNG");
|
|
tstHelper("RUNGS");
|
|
tstHelper("RYA");
|
|
tstHelper("RYA'I");
|
|
tstHelper("RYAL");
|
|
tstHelper("SA");
|
|
tstHelper("SA'");
|
|
tstHelper("SA'A");
|
|
tstHelper("SA'I");
|
|
tstHelper("SA'O");
|
|
tstHelper("SAG");
|
|
tstHelper("SANG");
|
|
tstHelper("SANGS");
|
|
tstHelper("SBANG");
|
|
tstHelper("SBNYEN");
|
|
tstHelper("SBRANG");
|
|
tstHelper("SBRAS");
|
|
tstHelper("SBREL");
|
|
tstHelper("SBRING");
|
|
tstHelper("SBRIS");
|
|
tstHelper("SBROS");
|
|
tstHelper("SBRUGS");
|
|
tstHelper("SBRUL");
|
|
tstHelper("SBRUNG");
|
|
tstHelper("SBU");
|
|
tstHelper("SBUNGS");
|
|
tstHelper("SBUR");
|
|
tstHelper("SBYAN");
|
|
tstHelper("SBYANGS");
|
|
tstHelper("SBYANS");
|
|
tstHelper("SBYAR");
|
|
tstHelper("SBYER");
|
|
tstHelper("SBYI");
|
|
tstHelper("SBYIN");
|
|
tstHelper("SBYIR");
|
|
tstHelper("SBYO");
|
|
tstHelper("SBYOR");
|
|
tstHelper("SBYU");
|
|
tstHelper("SBYUG");
|
|
tstHelper("SBYUGS");
|
|
tstHelper("SDAGS");
|
|
tstHelper("SDAN");
|
|
tstHelper("SDBUGS");
|
|
tstHelper("SDE");
|
|
tstHelper("SDE'U");
|
|
tstHelper("SDIG");
|
|
tstHelper("SDOD");
|
|
tstHelper("SDON");
|
|
tstHelper("SDONG");
|
|
tstHelper("SDUG");
|
|
tstHelper("SE'I");
|
|
tstHelper("SEMS");
|
|
tstHelper("SENG");
|
|
tstHelper("SER");
|
|
tstHelper("SGA");
|
|
tstHelper("SGO'U");
|
|
tstHelper("SGOGS");
|
|
tstHelper("SGRA");
|
|
tstHelper("SGRAR");
|
|
tstHelper("SGRE'U");
|
|
tstHelper("SGREL");
|
|
tstHelper("SGRON");
|
|
tstHelper("SGRUB");
|
|
tstHelper("SGRUP");
|
|
tstHelper("SGUB");
|
|
tstHelper("SGUG");
|
|
tstHelper("SGUN");
|
|
tstHelper("SGYE'O");
|
|
tstHelper("SGYES");
|
|
tstHelper("SGYOD");
|
|
tstHelper("SGYUNG");
|
|
tstHelper("SH'A");
|
|
tstHelper("SH'AKYA");
|
|
tstHelper("SHA");
|
|
tstHelper("SHA'");
|
|
tstHelper("SHA'A");
|
|
tstHelper("SHAA'");
|
|
tstHelper("SHAA'RI'I");
|
|
tstHelper("SHAL");
|
|
tstHelper("SHAM");
|
|
tstHelper("SHAN");
|
|
tstHelper("SHANG");
|
|
tstHelper("SHAR");
|
|
tstHelper("SHEG");
|
|
tstHelper("SHES");
|
|
tstHelper("SHI");
|
|
tstHelper("SHI'A");
|
|
tstHelper("SHIG");
|
|
tstHelper("SHIN");
|
|
tstHelper("SHING");
|
|
tstHelper("SHOG");
|
|
tstHelper("SHRU");
|
|
tstHelper("SHRUT");
|
|
tstHelper("SHVA");
|
|
tstHelper("SI");
|
|
tstHelper("SI'I");
|
|
tstHelper("SING");
|
|
tstHelper("SKA");
|
|
tstHelper("SKABS");
|
|
tstHelper("SKAD");
|
|
tstHelper("SKAM");
|
|
tstHelper("SKANG");
|
|
tstHelper("SKAR");
|
|
tstHelper("SKARI");
|
|
tstHelper("SKE");
|
|
tstHelper("SKEGS");
|
|
tstHelper("SKEL");
|
|
tstHelper("SKHANG");
|
|
tstHelper("SKO");
|
|
tstHelper("SKONG");
|
|
tstHelper("SKOR");
|
|
tstHelper("SKRA'I");
|
|
tstHelper("SKRED");
|
|
tstHelper("SKUD");
|
|
tstHelper("SKYAN");
|
|
tstHelper("SKYANG");
|
|
tstHelper("SKYE");
|
|
tstHelper("SKYE'O");
|
|
tstHelper("SKYE'U");
|
|
tstHelper("SKYED");
|
|
tstHelper("SKYEGS");
|
|
tstHelper("SKYEN");
|
|
tstHelper("SKYES");
|
|
tstHelper("SKYIMS");
|
|
tstHelper("SKYO");
|
|
tstHelper("SKYOB");
|
|
tstHelper("SKYONG");
|
|
tstHelper("SKYONGS");
|
|
tstHelper("SLABS");
|
|
tstHelper("SLAR");
|
|
tstHelper("SLE'O");
|
|
tstHelper("SLO");
|
|
tstHelper("SLOB");
|
|
tstHelper("SLONG");
|
|
tstHelper("SLOP");
|
|
tstHelper("SMA");
|
|
tstHelper("SMAD");
|
|
tstHelper("SMAM");
|
|
tstHelper("SMAN");
|
|
tstHelper("SMEL");
|
|
tstHelper("SMOD");
|
|
tstHelper("SMON");
|
|
tstHelper("SMONGS");
|
|
tstHelper("SMRA");
|
|
tstHelper("SMRA'I");
|
|
tstHelper("SMRA'O");
|
|
tstHelper("SMUNG");
|
|
tstHelper("SMYANGS");
|
|
tstHelper("SMYUG");
|
|
tstHelper("SMYUNG");
|
|
tstHelper("SNA");
|
|
tstHelper("SNABS");
|
|
tstHelper("SNAMG");
|
|
tstHelper("SNAR");
|
|
tstHelper("SNGAGS");
|
|
tstHelper("SNGANG");
|
|
tstHelper("SNGANGS");
|
|
tstHelper("SNGO");
|
|
tstHelper("SNGO'I");
|
|
tstHelper("SNGOGS");
|
|
tstHelper("SNGON");
|
|
tstHelper("SNOD");
|
|
tstHelper("SNRA");
|
|
tstHelper("SNREL");
|
|
tstHelper("SNRON");
|
|
tstHelper("SNUM");
|
|
tstHelper("SNYA");
|
|
tstHelper("SNYAM");
|
|
tstHelper("SNYEG");
|
|
tstHelper("SNYEGS");
|
|
tstHelper("SNYER");
|
|
tstHelper("SNYIL");
|
|
tstHelper("SNYING");
|
|
tstHelper("SNYOD");
|
|
tstHelper("SNYOMS");
|
|
tstHelper("SO");
|
|
tstHelper("SO'I");
|
|
tstHelper("SOGS");
|
|
tstHelper("SONG");
|
|
tstHelper("SOR");
|
|
tstHelper("SPANG");
|
|
tstHelper("SPANGS");
|
|
tstHelper("SPOBS");
|
|
tstHelper("SPRAS");
|
|
tstHelper("SPRE'U'I");
|
|
tstHelper("SPRIN");
|
|
tstHelper("SPRO");
|
|
tstHelper("SPRUGS");
|
|
tstHelper("SPU");
|
|
tstHelper("SPUNGS");
|
|
tstHelper("SPYAD");
|
|
tstHelper("SPYAN");
|
|
tstHelper("SPYANG");
|
|
tstHelper("SPYI");
|
|
tstHelper("SPYI'I");
|
|
tstHelper("SPYI'U");
|
|
tstHelper("SPYIR");
|
|
tstHelper("SPYIS");
|
|
tstHelper("SPYOD");
|
|
tstHelper("SPYON");
|
|
tstHelper("SPYONG");
|
|
tstHelper("SPYOOD");
|
|
tstHelper("SPYOR");
|
|
tstHelper("SPYUGS");
|
|
tstHelper("SRAL");
|
|
tstHelper("SRAN");
|
|
tstHelper("SRAS");
|
|
tstHelper("SREG");
|
|
tstHelper("SRI");
|
|
tstHelper("SRID");
|
|
tstHelper("SRIN");
|
|
tstHelper("SRJOD");
|
|
tstHelper("SRO");
|
|
tstHelper("SROG");
|
|
tstHelper("SROL");
|
|
tstHelper("SRONG");
|
|
tstHelper("SRUNG");
|
|
tstHelper("SRUNGS");
|
|
tstHelper("STE");
|
|
tstHelper("STED");
|
|
tstHelper("STENG");
|
|
tstHelper("STENGS");
|
|
tstHelper("STHA");
|
|
tstHelper("STOB");
|
|
tstHelper("STOBS");
|
|
tstHelper("STOD");
|
|
tstHelper("STON");
|
|
tstHelper("STONG");
|
|
tstHelper("STUG");
|
|
tstHelper("STUGS");
|
|
tstHelper("STZAGS");
|
|
tstHelper("SU");
|
|
tstHelper("SUM");
|
|
tstHelper("SZHON");
|
|
tstHelper("Si");
|
|
tstHelper("T'A");
|
|
tstHelper("T'A'I");
|
|
tstHelper("TA");
|
|
tstHelper("TA'A");
|
|
tstHelper("TAA'I");
|
|
tstHelper("TAMBA");
|
|
tstHelper("TE");
|
|
tstHelper("TE'U");
|
|
tstHelper("TE'U'I");
|
|
tstHelper("THA");
|
|
tstHelper("THABS");
|
|
tstHelper("THAD");
|
|
tstHelper("THAG");
|
|
tstHelper("THAL");
|
|
tstHelper("THAMS");
|
|
tstHelper("THE");
|
|
tstHelper("THE'U");
|
|
tstHelper("THED");
|
|
tstHelper("THEG");
|
|
tstHelper("THI");
|
|
tstHelper("THIB");
|
|
tstHelper("THIM");
|
|
tstHelper("THIMS");
|
|
tstHelper("THIN");
|
|
tstHelper("THING");
|
|
tstHelper("THOB");
|
|
tstHelper("THOD");
|
|
tstHelper("THOGS");
|
|
tstHelper("THOS");
|
|
tstHelper("THUB");
|
|
tstHelper("THUG");
|
|
tstHelper("THUGS");
|
|
tstHelper("THUNG");
|
|
tstHelper("THUR");
|
|
tstHelper("TI");
|
|
tstHelper("TI'");
|
|
tstHelper("TI'A");
|
|
tstHelper("TI'I");
|
|
tstHelper("TIG");
|
|
tstHelper("TING");
|
|
tstHelper("TKA'A");
|
|
tstHelper("TOG");
|
|
tstHelper("TOR");
|
|
tstHelper("TPA");
|
|
tstHelper("TRA'AI");
|
|
tstHelper("TRE");
|
|
tstHelper("TRYAM");
|
|
tstHelper("TSAD");
|
|
tstHelper("TSAL");
|
|
tstHelper("TSANG");
|
|
tstHelper("TSANGS");
|
|
tstHelper("TSE");
|
|
tstHelper("TSE'U");
|
|
tstHelper("TSEGS");
|
|
tstHelper("TSER");
|
|
tstHelper("TSIG");
|
|
tstHelper("TSIGS");
|
|
tstHelper("TSOD");
|
|
tstHelper("TSOGS");
|
|
tstHelper("TSOM");
|
|
tstHelper("TSON");
|
|
tstHelper("TSONG");
|
|
tstHelper("TSOR");
|
|
tstHelper("TSOS");
|
|
tstHelper("TSUGS");
|
|
tstHelper("TSUL");
|
|
tstHelper("TSUR");
|
|
tstHelper("TU");
|
|
tstHelper("TUB");
|
|
tstHelper("TUD");
|
|
tstHelper("TUS");
|
|
tstHelper("TYA'I");
|
|
tstHelper("TZ'A");
|
|
tstHelper("TZA");
|
|
tstHelper("TZAM");
|
|
tstHelper("TZAMMI");
|
|
tstHelper("TZAMPAKA");
|
|
tstHelper("TZAN");
|
|
tstHelper("TZANDA");
|
|
tstHelper("TZANDAN");
|
|
tstHelper("TZE'U");
|
|
tstHelper("TZER");
|
|
tstHelper("TZI");
|
|
tstHelper("TZIB");
|
|
tstHelper("WA");
|
|
tstHelper("WA'A");
|
|
tstHelper("WAM");
|
|
tstHelper("WANG");
|
|
tstHelper("X");
|
|
tstHelper("YA");
|
|
tstHelper("YA'A");
|
|
tstHelper("YA'AnA");
|
|
tstHelper("YA'I");
|
|
tstHelper("YAN");
|
|
tstHelper("YANG");
|
|
tstHelper("YANGS");
|
|
tstHelper("YAS");
|
|
tstHelper("YAmGU");
|
|
tstHelper("YE");
|
|
tstHelper("YI");
|
|
tstHelper("YID");
|
|
tstHelper("YIN");
|
|
tstHelper("YOL");
|
|
tstHelper("YONGS");
|
|
tstHelper("YU");
|
|
tstHelper("YUG");
|
|
tstHelper("YUL");
|
|
tstHelper("ZAD");
|
|
tstHelper("ZAG");
|
|
tstHelper("ZAN");
|
|
tstHelper("ZAR");
|
|
tstHelper("ZDOG");
|
|
tstHelper("ZE'I");
|
|
tstHelper("ZER");
|
|
tstHelper("ZHA'I");
|
|
tstHelper("ZHABS");
|
|
tstHelper("ZHAL");
|
|
tstHelper("ZHE");
|
|
tstHelper("ZHEN");
|
|
tstHelper("ZHENG");
|
|
tstHelper("ZHER");
|
|
tstHelper("ZHES");
|
|
tstHelper("ZHES'O");
|
|
tstHelper("ZHI");
|
|
tstHelper("ZHI'I");
|
|
tstHelper("ZHIG");
|
|
tstHelper("ZHIGS");
|
|
tstHelper("ZHIN");
|
|
tstHelper("ZHING");
|
|
tstHelper("ZHON");
|
|
tstHelper("ZHUGS");
|
|
tstHelper("ZHUS");
|
|
tstHelper("ZI'I");
|
|
tstHelper("ZIL");
|
|
tstHelper("ZING");
|
|
tstHelper("ZLA");
|
|
tstHelper("ZLOG");
|
|
tstHelper("ZLOS");
|
|
tstHelper("ZLUM");
|
|
tstHelper("ZUG");
|
|
tstHelper("ZUL");
|
|
tstHelper("ZUNG");
|
|
tstHelper("d'U");
|
|
tstHelper("dA");
|
|
tstHelper("dALA");
|
|
tstHelper("dI");
|
|
tstHelper("dU");
|
|
tstHelper("nA");
|
|
tstHelper("nA'I");
|
|
tstHelper("nDA'A");
|
|
tstHelper("nE");
|
|
tstHelper("nI");
|
|
tstHelper("nYAGRO");
|
|
tstHelper("ndI");
|
|
tstHelper("shKA");
|
|
|
|
}
|
|
}
|
|
/* DLC FIXME: add test cases: from R0021F.ACE: ambiguous Tibetan/Sanskrit:
|
|
|
|
BDA'
|
|
B+DA
|
|
DBANG
|
|
D+BA
|
|
DGA'
|
|
D+GA
|
|
DGRA
|
|
D+GRA
|
|
DGYES
|
|
D+GYA
|
|
DMAR
|
|
D+MA
|
|
GDA'
|
|
G+DA
|
|
GNAD
|
|
G+NA
|
|
MNA'
|
|
M+NA
|
|
*/
|