245aac4911
b, c, d, e, ... do not belong in ACIP, so the scanner rejects them. This should make it even easier to distinguish automatically between Tibetan and English texts.
8670 lines
205 KiB
Java
8670 lines
205 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(false, l, acip) != null) {
|
||
System.out.println(pt.getWarning(false, l, acip));
|
||
} else if (pt.getWarning(true, l, acip) != null)
|
||
if (sdebug || debug) System.out.println("Paranoiac warning is this: " + pt.getWarning(true, 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();
|
||
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 " + expectedLegalParses[i]);
|
||
assertTrue(okay);
|
||
}
|
||
if (!goodness2)
|
||
System.out.println("You expected " + expectedLegalParses.length + " legal parses, but there were instead " + legalParses.size() + " legal parses.");
|
||
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("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("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) {
|
||
shelp(s, expectedErrors, false, expectedScan);
|
||
}
|
||
|
||
private static void shelp(String s, String expectedErrors, boolean lenientPeriods, String expectedScan) {
|
||
StringBuffer errors = new StringBuffer();
|
||
ArrayList al = ACIPTshegBarScanner.scan(s, errors, lenientPeriods, -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, boolean, int)}. */
|
||
public void testScanner() {
|
||
shelp("LA...SGRUB",
|
||
"",
|
||
"[TIBETAN_NON_PUNCTUATION:{LA}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_NON_PUNCTUATION:{SGRUB}]"); // DLC FIXME
|
||
shelp("PAS... LA",
|
||
"Offset 5: A non-breaking tsheg, '.', appeared, but not like \"...,\" or \".,\" or \".dA\" or \".DA\".\n",
|
||
"[TIBETAN_NON_PUNCTUATION:{PAS}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, ERROR:{.}, TIBETAN_PUNCTUATION:{ }, TIBETAN_NON_PUNCTUATION:{LA}]");
|
||
shelp("PAS... LA",
|
||
"",
|
||
true,
|
||
"[TIBETAN_NON_PUNCTUATION:{PAS}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, TIBETAN_PUNCTUATION:{.}, 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: 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: 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: Found a truly unmatched close bracket, ] or }.\nOffset 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 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: Found an open bracket within a [#COMMENT]-style comment. Brackets may not appear in comments.\n"
|
||
+ "Offset 10: Found an open bracket within a [#COMMENT]-style comment. Brackets may not appear in comments.\n"
|
||
+ "Offset 11: Found an open bracket within a [#COMMENT]-style comment. Brackets may not appear in comments.\n"
|
||
+ "Offset 12: Found an open bracket within a [#COMMENT]-style comment. Brackets may not appear in comments.\n"
|
||
+ "Offset 13: Found an open bracket within a [#COMMENT]-style comment. Brackets may not appear in comments.\n");
|
||
shelp("[ILLEGAL COMMENT]",
|
||
"Offset 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: 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: Unexpected closing parenthesis, ), found.\n");
|
||
shelp("BSKYABS GRO(", "Offset END: Unmatched open parenthesis, (, found.\n");
|
||
shelp("((NESTAGE))", "Offset 1: Found an illegal open parenthesis, (. Nesting of parentheses is not allowed.\nOffset 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: Found an illegal character, ~, with ordinal 126.\n");
|
||
shelp("[* Correction with []]",
|
||
"Offset 5: Found an illegal character, r, with ordinal 114.\nOffset 6: Found an illegal character, r, with ordinal 114.\nOffset 7: Found an illegal character, e, with ordinal 101.\nOffset 8: Found an illegal character, c, with ordinal 99.\nOffset 14: Found an illegal character, w, with ordinal 119.\nOffset 15: Found an illegal character, i, with ordinal 105.\nOffset 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: 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}]");
|
||
shelp("K\\,", "", "[TIBETAN_NON_PUNCTUATION:{K\\}, 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: Found an illegal at sign, @ (in context, this is @19-20A). @012B is an example of a legal folio marker.\n",
|
||
"[ERROR:{@}, 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: 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:{@012A.}, 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
|
||
|
||
}
|
||
|
||
/** 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' <20><><EFBFBD><EFBFBD>
|
||
B+DA <20><><EFBFBD>
|
||
DBANG <20><><EFBFBD>
|
||
D+BA <20><><EFBFBD>
|
||
DGA' <20><><EFBFBD><EFBFBD>
|
||
D+GA <20><><EFBFBD>
|
||
DGRA <20><><EFBFBD>
|
||
D+GRA <20><><EFBFBD>
|
||
DGYES<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
D+GYA <20><><EFBFBD>
|
||
DMAR <20><><EFBFBD><EFBFBD>
|
||
D+MA <20><><EFBFBD>
|
||
GDA' <20><><EFBFBD><EFBFBD>
|
||
G+DA <20><><EFBFBD>
|
||
GNAD <20><><EFBFBD><EFBFBD>
|
||
G+NA <20><><EFBFBD>
|
||
MNA' <20><><EFBFBD><EFBFBD>
|
||
M+NA <20><><EFBFBD>
|
||
*/
|