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

These are courtesy Peter E. Hauer, Linguasoft. Taken from ACIP's website, but that copy was overridden by one with corrections sent to Peter by Robert Chilton. */ public void testMV() { System.out.println(""); System.out.println(""); System.out.println(""); System.out.println("From MV:"); System.out.println(""); System.out.println(""); System.out.println(""); tstHelper("'BANGS"); tstHelper("'BAR"); tstHelper("'BLTAS"); tstHelper("'BRA"); tstHelper("'BRA'I"); tstHelper("'BRANG"); tstHelper("'BRAS"); tstHelper("'BRED"); tstHelper("'BREG"); tstHelper("'BREL"); tstHelper("'BRIM"); tstHelper("'BRU'I"); tstHelper("'BUL"); tstHelper("'BUS"); tstHelper("'BYAMS"); tstHelper("'BYED"); tstHelper("'BYES"); tstHelper("'BYIN"); tstHelper("'BYOD"); tstHelper("'BYOR"); tstHelper("'BYUNG"); tstHelper("'CHED"); tstHelper("'CHI"); tstHelper("'CHING"); tstHelper("'CHONGS"); tstHelper("'CHOS"); tstHelper("'DAB"); tstHelper("'DAGS"); tstHelper("'DAS"); tstHelper("'DEBS"); tstHelper("'DI"); tstHelper("'DOD"); tstHelper("'DOM"); tstHelper("'DOMS"); tstHelper("'DON"); tstHelper("'DOR"); tstHelper("'DRA"); tstHelper("'DRAD"); tstHelper("'DRAMS"); tstHelper("'DRANG"); tstHelper("'DRED"); tstHelper("'DREL"); tstHelper("'DRI"); tstHelper("'DRIM"); tstHelper("'DROS"); tstHelper("'DRUB"); tstHelper("'DRUBS"); tstHelper("'DU"); tstHelper("'DUD"); tstHelper("'DUG"); tstHelper("'DUGS"); tstHelper("'DZAM"); tstHelper("'DZE"); tstHelper("'DZEM"); tstHelper("'DZES"); tstHelper("'DZIN"); tstHelper("'DZUM"); tstHelper("'DZUMS"); tstHelper("'GAG"); tstHelper("'GED"); tstHelper("'GI"); tstHelper("'GOG"); tstHelper("'GRAMS"); tstHelper("'GRES"); tstHelper("'GRIM"); tstHelper("'GRIMS"); tstHelper("'GRO"); tstHelper("'GRO'O"); tstHelper("'GRON"); tstHelper("'GRUS"); tstHelper("'GU"); tstHelper("'GYED"); tstHelper("'GYEGS"); tstHelper("'GYOD"); tstHelper("'GYUG"); tstHelper("'GYUR"); tstHelper("'JAL"); tstHelper("'JAM"); tstHelper("'JAS"); tstHelper("'JIG"); tstHelper("'JIGS"); tstHelper("'JOMS"); tstHelper("'JUG"); tstHelper("'KHAS"); tstHelper("'KHOG"); tstHelper("'KHOGS"); tstHelper("'KHOR"); tstHelper("'KHRAMS"); tstHelper("'KHRANG"); tstHelper("'KHRAS"); tstHelper("'KHREN"); tstHelper("'KHRUG"); tstHelper("'KHRUMS"); tstHelper("'KHUMS"); tstHelper("'KHYAN"); tstHelper("'KHYIL"); tstHelper("'KOD"); tstHelper("'KRAM"); tstHelper("'KRIGS"); tstHelper("'LREG"); tstHelper("'MTHUN"); tstHelper("'MTSAMS"); tstHelper("'OD"); tstHelper("'OG"); tstHelper("'ONGS"); tstHelper("'PHAGS"); tstHelper("'PHEN"); tstHelper("'PHO"); tstHelper("'PHOG"); tstHelper("'PHOGS"); tstHelper("'PHONGS"); tstHelper("'PHRED"); tstHelper("'PHREN"); tstHelper("'PHROG"); tstHelper("'PHROGS"); tstHelper("'PHRUL"); tstHelper("'PHYAM"); tstHelper("'PHYES"); tstHelper("'PHYIS"); tstHelper("'PRUL"); tstHelper("'SPONG"); tstHelper("'THAB"); tstHelper("'THABS"); tstHelper("'THAL"); tstHelper("'THAM"); tstHelper("'THAMS"); tstHelper("'THANG"); tstHelper("'THANGS"); tstHelper("'THAR"); tstHelper("'THO"); tstHelper("'THOB"); tstHelper("'THOG"); tstHelper("'THOP"); tstHelper("'THUL"); tstHelper("'THUN"); tstHelper("'THUNG"); tstHelper("'TSAM"); tstHelper("'TSAMS"); tstHelper("'TSE"); tstHelper("'TSEB"); tstHelper("'TSED"); tstHelper("'TSO"); tstHelper("'TSO'O"); tstHelper("'TSOL"); tstHelper("'TSOR"); tstHelper("'TSOS"); tstHelper("'TUN"); tstHelper("'TUNG"); tstHelper("'UR"); tstHelper("1"); tstHelper("A'M"); tstHelper("AA"); tstHelper("AAE"); tstHelper("AAI"); tstHelper("AAMRA'I"); tstHelper("AAR"); tstHelper("AASMA"); tstHelper("AE"); tstHelper("AIN"); tstHelper("AINDA"); tstHelper("AIndRANYILA"); tstHelper("AOOL"); tstHelper("AOOS"); tstHelper("AOm"); tstHelper("AU"); tstHelper("AUDPA"); tstHelper("AUDPALA"); tstHelper("AUDPALA'I"); tstHelper("AUT"); tstHelper("AUTPALA'I"); tstHelper("B'I"); tstHelper("B. (DLC!)"); tstHelper("BA"); tstHelper("BA'"); tstHelper("BA'A"); tstHelper("BA'AR"); tstHelper("BA'I"); tstHelper("BA'O"); tstHelper("BA'THUNG"); tstHelper("BAA'"); tstHelper("BAG"); tstHelper("BAI"); tstHelper("BAL"); tstHelper("BAM"); tstHelper("BAN"); tstHelper("BANDU"); tstHelper("BANG"); tstHelper("BAR"); tstHelper("BAR'"); tstHelper("BAS"); tstHelper("BAT"); tstHelper("BCA'"); tstHelper("BCAD"); tstHelper("BCAGS"); tstHelper("BCAS"); tstHelper("BCDU"); tstHelper("BCHA"); tstHelper("BCHU"); tstHelper("BCO"); tstHelper("BCOR"); tstHelper("BCU"); tstHelper("BCUD"); tstHelper("BCUG"); tstHelper("BCUGS"); tstHelper("BCUR"); tstHelper("BCUS"); tstHelper("BDA"); tstHelper("BDAG"); tstHelper("BDAR"); tstHelper("BDE"); tstHelper("BDEG"); tstHelper("BDUD"); tstHelper("BDUN"); tstHelper("BE'I"); tstHelper("BE'U"); tstHelper("BEE"); tstHelper("BEEdURYA'I"); tstHelper("BGAG"); tstHelper("BGANG"); tstHelper("BGCUD"); tstHelper("BGE"); tstHelper("BGO"); tstHelper("BGOD"); tstHelper("BGRAD"); tstHelper("BGRANG"); tstHelper("BGREL"); tstHelper("BGRES"); tstHelper("BHA"); tstHelper("BHA'I"); tstHelper("BHI"); tstHelper("BHINTA"); tstHelper("BHINY"); tstHelper("BI"); tstHelper("BIM"); tstHelper("BIMBA"); tstHelper("BIN"); tstHelper("BING"); tstHelper("BIsnU"); tstHelper("BKABS"); tstHelper("BKHI"); tstHelper("BKOD"); tstHelper("BKRAM"); tstHelper("BKRES"); tstHelper("BKRI"); tstHelper("BKRIS"); tstHelper("BKROL"); tstHelper("BKRUGS"); tstHelper("BKYANG"); tstHelper("BLA"); tstHelper("BLAS"); tstHelper("BLO"); tstHelper("BLTAN"); tstHelper("BLUGS"); tstHelper("BNYIS"); tstHelper("BO"); tstHelper("BO'I"); tstHelper("BO'O"); tstHelper("BON"); tstHelper("BONG"); tstHelper("BOR"); tstHelper("BPAG"); tstHelper("BRAG"); tstHelper("BRAL"); tstHelper("BRAM"); tstHelper("BRDEG"); tstHelper("BRDUM"); tstHelper("BRDUNGS"); tstHelper("BRDZES"); tstHelper("BRGOD"); tstHelper("BRGYA"); tstHelper("BRGYA'I"); tstHelper("BRGYAD"); tstHelper("BRGYAL"); tstHelper("BRING"); tstHelper("BRJID"); tstHelper("BRJOD"); tstHelper("BRKU"); tstHelper("BRKUR"); tstHelper("BRLAD"); tstHelper("BRLANG"); tstHelper("BRLANGS"); tstHelper("BRNGAS"); tstHelper("BRNGOD"); tstHelper("BRNGOGS"); tstHelper("BRNGOS"); tstHelper("BRNGUBS"); tstHelper("BRNYAN"); tstHelper("BRONG"); tstHelper("BRTAN"); tstHelper("BRTEG"); tstHelper("BRTEGS"); tstHelper("BRTEN"); tstHelper("BRTON"); tstHelper("BRTUL"); tstHelper("BRTZAGS"); tstHelper("BRTZAN"); tstHelper("BRTZANG"); tstHelper("BRTZEGS"); tstHelper("BRTZENGS"); tstHelper("BRTZER"); tstHelper("BRTZI"); tstHelper("BRTZIBS"); tstHelper("BRTZIS"); tstHelper("BRTZOGS"); tstHelper("BRTZON"); tstHelper("BRUNGS"); tstHelper("BSAGS"); tstHelper("BSAL"); tstHelper("BSANGS"); tstHelper("BSBRUGS"); tstHelper("BSDUNGS"); tstHelper("BSDUS"); tstHelper("BSEG"); tstHelper("BSGRAGS"); tstHelper("BSGRE"); tstHelper("BSGRENG"); tstHelper("BSGRES"); tstHelper("BSGRUB"); tstHelper("BSGRUNGS"); tstHelper("BSGUR"); tstHelper("BSGYINGS"); tstHelper("BSGYUR"); tstHelper("BSHAD"); tstHelper("BSHAMS"); tstHelper("BSHES"); tstHelper("BSHUNG"); tstHelper("BSIG"); tstHelper("BSIL"); tstHelper("BSING"); tstHelper("BSKHYED"); tstHelper("BSKOD"); tstHelper("BSKOR"); tstHelper("BSKOS"); tstHelper("BSKRANGS"); tstHelper("BSKRI"); tstHelper("BSKRIS"); tstHelper("BSKROD"); tstHelper("BSKYANG"); tstHelper("BSKYED"); tstHelper("BSKYENG"); tstHelper("BSKYIMS"); tstHelper("BSKYIS"); tstHelper("BSKYOD"); tstHelper("BSLAS"); tstHelper("BSNAN"); tstHelper("BSNGAGS"); tstHelper("BSNGAL"); tstHelper("BSNUM"); tstHelper("BSNUN"); tstHelper("BSNYAGS"); tstHelper("BSNYUNG"); tstHelper("BSREG"); tstHelper("BSREL"); tstHelper("BSRUBS"); tstHelper("BSRUNG"); tstHelper("BSTAN"); tstHelper("BSTOBS"); tstHelper("BSTOD"); tstHelper("BSTUS"); tstHelper("BSTZIS"); tstHelper("BTA'"); tstHelper("BTAB"); tstHelper("BTAM"); tstHelper("BTANG"); tstHelper("BTER"); tstHelper("BTUB"); tstHelper("BTUL"); tstHelper("BTZAM"); tstHelper("BTZAN"); tstHelper("BTZER"); tstHelper("BTZI"); tstHelper("BTZUB"); tstHelper("BTZUGS"); tstHelper("BTZVA"); tstHelper("BU"); tstHelper("BU'I"); tstHelper("BU'O"); tstHelper("BUR"); tstHelper("BYA"); tstHelper("BYA'A"); tstHelper("BYA'O"); tstHelper("BYAL"); tstHelper("BYAN"); tstHelper("BYANG"); tstHelper("BYAS"); tstHelper("BYE"); tstHelper("BYE'U"); tstHelper("BYED"); tstHelper("BYENG"); tstHelper("BYIN"); tstHelper("BYIS"); tstHelper("BYOD"); tstHelper("BYOL"); tstHelper("BYUGS"); tstHelper("BYUL"); tstHelper("BYUNG"); tstHelper("BZA'"); tstHelper("BZANG"); tstHelper("BZHAG"); tstHelper("BZHI"); tstHelper("BZHIGS"); tstHelper("BZHIN"); tstHelper("BZHING"); tstHelper("BZHUBS"); tstHelper("BZHUGS"); tstHelper("BZLOS"); tstHelper("BZUN"); tstHelper("BZUNG"); tstHelper("CA"); tstHelper("CA'I"); tstHelper("CAD"); tstHelper("CAN"); tstHelper("CANG"); tstHelper("CAn"); tstHelper("CE"); tstHelper("CES"); tstHelper("CHA"); tstHelper("CHAD"); tstHelper("CHAGS"); tstHelper("CHANG"); tstHelper("CHAS"); tstHelper("CHE"); tstHelper("CHE'I"); tstHelper("CHEN"); tstHelper("CHER"); tstHelper("CHO"); tstHelper("CHOMS"); tstHelper("CHOS"); tstHelper("CHU"); tstHelper("CHU'I"); tstHelper("CHUB"); tstHelper("CHUMS"); tstHelper("CHUNG"); tstHelper("CHUNG'U"); tstHelper("CHUNGS"); tstHelper("CIG"); tstHelper("CING"); tstHelper("CO"); tstHelper("CONG"); tstHelper("COR"); tstHelper("COS"); tstHelper("CYA"); tstHelper("D'U"); tstHelper("DA"); tstHelper("DA'I"); tstHelper("DA'URYA"); tstHelper("DAD"); tstHelper("DAG"); tstHelper("DAGS"); tstHelper("DAM"); tstHelper("DAMBA"); tstHelper("DAN"); tstHelper("DANG"); tstHelper("DAR"); tstHelper("DAU"); tstHelper("DBA'"); tstHelper("DBA'I"); tstHelper("DBAG"); tstHelper("DBANG"); tstHelper("DBU'I"); tstHelper("DBUG"); tstHelper("DBUGS"); tstHelper("DBYANGS"); tstHelper("DBYAR"); tstHelper("DBYE"); tstHelper("DBYE'I"); tstHelper("DBYES"); tstHelper("DBYINS"); tstHelper("DBYIR"); tstHelper("DE"); tstHelper("DE'I"); tstHelper("DENG"); tstHelper("DGA"); tstHelper("DGA'"); tstHelper("DGAB"); tstHelper("DGAG"); tstHelper("DGE"); tstHelper("DGRA"); tstHelper("DGRA'I"); tstHelper("DGU'I"); tstHelper("DGYE'O"); tstHelper("DHA"); tstHelper("DHA'"); tstHelper("DHA'I"); tstHelper("DHANU"); tstHelper("DHU"); tstHelper("DI"); tstHelper("DI'I"); tstHelper("DIG"); tstHelper("DJOGS"); tstHelper("DKA'"); tstHelper("DKAR"); tstHelper("DKOD"); tstHelper("DKRI"); tstHelper("DKRUGS"); tstHelper("DKU"); tstHelper("DKUGS"); tstHelper("DKUS"); tstHelper("DKYIL"); tstHelper("DMA"); tstHelper("DMAN"); tstHelper("DMAR"); tstHelper("DMEL"); tstHelper("DMIGS"); tstHelper("DMYIGS"); tstHelper("DNGOS"); tstHelper("DO"); tstHelper("DOG"); tstHelper("DON"); tstHelper("DONG"); tstHelper("DOR"); tstHelper("DPA"); tstHelper("DPA'"); tstHelper("DPAG"); tstHelper("DPAL"); tstHelper("DPAS"); tstHelper("DPE"); tstHelper("DPER"); tstHelper("DPON"); tstHelper("DPRAL"); tstHelper("DPUN"); tstHelper("DPUNG"); tstHelper("DPYA'"); tstHelper("DPYID"); tstHelper("DPYINGS"); tstHelper("DPYOD"); tstHelper("DRA"); tstHelper("DRAG"); tstHelper("DRAN"); tstHelper("DRANG"); tstHelper("DRE'U"); tstHelper("DREGS"); tstHelper("DRI"); tstHelper("DRID"); tstHelper("DRIN"); tstHelper("DRNGUBS"); tstHelper("DROS"); tstHelper("DRUG"); tstHelper("DSPYOD"); tstHelper("DTAR"); tstHelper("DU"); tstHelper("DU'I"); tstHelper("DUG"); tstHelper("DUNG"); tstHelper("DUS"); tstHelper("DVAGS"); tstHelper("DW'A"); tstHelper("DZAM"); tstHelper("DZAMBU"); tstHelper("DZAMBU'I"); tstHelper("DZI"); tstHelper("DZIN"); tstHelper("DZOGS"); tstHelper("G-YAS"); tstHelper("G-YOR"); tstHelper("G-YUM"); tstHelper("G-YUNG"); tstHelper("GA"); tstHelper("GA'A"); tstHelper("GA'I"); tstHelper("GAL"); tstHelper("GAM"); tstHelper("GAMS"); tstHelper("GAN"); tstHelper("GANG"); tstHelper("GAR"); tstHelper("GAS"); tstHelper("GAU"); tstHelper("GAmGA'I"); tstHelper("GAn"); tstHelper("GAndI"); tstHelper("GBA"); tstHelper("GCIG"); tstHelper("GCIN"); tstHelper("GCOL"); tstHelper("GCONG"); tstHelper("GDAGS"); tstHelper("GDEGS"); tstHelper("GDGAS"); tstHelper("GDOL"); tstHelper("GDONGS"); tstHelper("GDUD"); tstHelper("GDUG"); tstHelper("GDUG.PA (DLC!)"); tstHelper("GDUGS"); tstHelper("GDUN"); tstHelper("GE"); tstHelper("GE'I"); tstHelper("GENGS"); tstHelper("GHI"); tstHelper("GHOM"); tstHelper("GI"); tstHelper("GIR"); tstHelper("GIS"); tstHelper("GLA"); tstHelper("GLAB"); tstHelper("GLAL"); tstHelper("GLANG"); tstHelper("GLO"); tstHelper("GLONGS"); tstHelper("GLUGS"); tstHelper("GNA'I"); tstHelper("GNAD"); tstHelper("GNAS"); tstHelper("GNGER"); tstHelper("GNOD"); tstHelper("GNON"); tstHelper("GNYA'"); tstHelper("GNYAR"); tstHelper("GNYE'U"); tstHelper("GNYEN"); tstHelper("GNYER"); tstHelper("GNYI"); tstHelper("GNYIS"); tstHelper("GO"); tstHelper("GO'I"); tstHelper("GONG"); tstHelper("GOOTAMA"); tstHelper("GOS"); tstHelper("GRAG"); tstHelper("GRAGS"); tstHelper("GRANGS"); tstHelper("GRANS"); tstHelper("GREG"); tstHelper("GRO"); tstHelper("GRO'I"); tstHelper("GROG"); tstHelper("GROGS"); tstHelper("GROR"); tstHelper("GRUNGS"); tstHelper("GRUR"); tstHelper("GSAL"); tstHelper("GSANG"); tstHelper("GSAR"); tstHelper("GSDEGS"); tstHelper("GSEB"); tstHelper("GSEG"); tstHelper("GSER"); tstHelper("GSHE"); tstHelper("GSHE'"); tstHelper("GSHEGS"); tstHelper("GSHING"); tstHelper("GSIGS"); tstHelper("GSO"); tstHelper("GSOL"); tstHelper("GSOS"); tstHelper("GSRUNG"); tstHelper("GSUM"); tstHelper("GSUNGS"); tstHelper("GTA'"); tstHelper("GTAGS"); tstHelper("GTAM"); tstHelper("GTAMS"); tstHelper("GTAN"); tstHelper("GTEGS"); tstHelper("GTING"); tstHelper("GTOGS"); tstHelper("GTOL"); tstHelper("GTONG"); tstHelper("GTUBS"); tstHelper("GTUM"); tstHelper("GTZAB"); tstHelper("GTZAD"); tstHelper("GTZANG"); tstHelper("GTZUG"); tstHelper("GTZUGS"); tstHelper("GU"); tstHelper("GU'O"); tstHelper("GYA"); tstHelper("GYAN"); tstHelper("GYAR"); tstHelper("GYAS"); tstHelper("GYES"); tstHelper("GYI"); tstHelper("GYIR"); tstHelper("GYIS"); tstHelper("GYO"); tstHelper("GYOR"); tstHelper("GYUL"); tstHelper("GYUR"); tstHelper("GZANG"); tstHelper("GZAR"); tstHelper("GZENG"); tstHelper("GZENGS"); tstHelper("GZES"); tstHelper("GZHA'I"); tstHelper("GZHAG"); tstHelper("GZHAL"); tstHelper("GZHAN"); tstHelper("GZHANG"); tstHelper("GZHEL"); tstHelper("GZHI"); tstHelper("GZHIG"); tstHelper("GZHON"); tstHelper("GZHUNG"); tstHelper("GZI"); tstHelper("GZIL"); tstHelper("GZUGS"); tstHelper("GZUNG"); tstHelper("GZUNGS"); tstHelper("GZUNGS'I"); tstHelper("GndA'I"); tstHelper("GndAA'I"); tstHelper("H'A"); tstHelper("HA"); tstHelper("HAB"); tstHelper("HAM"); tstHelper("HANG"); tstHelper("HETU"); tstHelper("HETUR"); tstHelper("HU"); tstHelper("HUD"); tstHelper("JA"); tstHelper("JAA'"); tstHelper("JI"); tstHelper("JIGS"); tstHelper("JO"); tstHelper("JO'U"); tstHelper("K'AU"); tstHelper("KA"); tstHelper("KA'A"); tstHelper("KA'ASHI"); tstHelper("KA'ASHI'I"); tstHelper("KA'I"); tstHelper("KA'U"); tstHelper("KAA'"); tstHelper("KAL"); tstHelper("KAM"); tstHelper("KAR"); tstHelper("KARAnA"); tstHelper("KE'U"); tstHelper("KGRAG"); tstHelper("KHA"); tstHelper("KHAMS"); tstHelper("KHANG"); tstHelper("KHANS"); tstHelper("KHE'U"); tstHelper("KHRA"); tstHelper("KHRAM"); tstHelper("KHRI"); tstHelper("KHRIG"); tstHelper("KHRIS"); tstHelper("KHUD"); tstHelper("KHUG"); tstHelper("KHYAB"); tstHelper("KHYAD"); tstHelper("KHYE'U"); tstHelper("KHYE'US"); tstHelper("KHYED"); tstHelper("KHYIM"); tstHelper("KHYOD"); tstHelper("KHYON"); tstHelper("KI"); tstHelper("KKU"); tstHelper("KLU'I"); tstHelper("KLUG"); tstHelper("KO"); tstHelper("KOO"); tstHelper("KOOSHAMBHI"); tstHelper("KOS"); tstHelper("KRIS"); tstHelper("KROL"); tstHelper("KROS"); tstHelper("KTI"); tstHelper("KU"); tstHelper("KULA"); tstHelper("KUM"); tstHelper("KUN"); tstHelper("KUR"); tstHelper("KY"); tstHelper("KYA"); tstHelper("KYA'I"); tstHelper("KYANG"); tstHelper("KYE"); tstHelper("KYI"); tstHelper("KYIS"); tstHelper("KYOD"); tstHelper("KsI"); tstHelper("L'A"); tstHelper("LA"); tstHelper("LA$GCAGS"); tstHelper("LA'A"); tstHelper("LA'I"); tstHelper("LAG"); tstHelper("LAM"); tstHelper("LAN"); tstHelper("LANDA"); tstHelper("LANG"); tstHelper("LANGGA"); tstHelper("LANGS"); tstHelper("LAR"); tstHelper("LAS"); tstHelper("LBA"); tstHelper("LBANG"); tstHelper("LCAG"); tstHelper("LCAGS"); tstHelper("LCAM"); tstHelper("LCAMS"); tstHelper("LCE"); tstHelper("LCE'U"); tstHelper("LDAN"); tstHelper("LDIBS"); tstHelper("LDOB"); tstHelper("LDOG"); tstHelper("LDOGS"); tstHelper("LDONGS"); tstHelper("LE"); tstHelper("LE'I"); tstHelper("LE'U'I"); tstHelper("LE'UR"); tstHelper("LEB"); tstHelper("LED"); tstHelper("LEGS"); tstHelper("LEN"); tstHelper("LENDRA"); tstHelper("LHA"); tstHelper("LHAG"); tstHelper("LHAL"); tstHelper("LHAN"); tstHelper("LHONGS"); tstHelper("LHUN"); tstHelper("LHUNG"); tstHelper("LI"); tstHelper("LI'I"); tstHelper("LIN"); tstHelper("LJAB"); tstHelper("LJANG"); tstHelper("LJIB"); tstHelper("LJIBS"); tstHelper("LKOG"); tstHelper("LNGA"); tstHelper("LNGA'I"); tstHelper("LNGA'I'I"); tstHelper("LNGOG"); tstHelper("LO"); tstHelper("LOBS"); tstHelper("LOGS"); tstHelper("LTA"); tstHelper("LTAR"); tstHelper("LTU"); tstHelper("LTUN"); tstHelper("LTUNG"); tstHelper("LU"); tstHelper("LU'I"); tstHelper("LUGS"); tstHelper("LUM"); tstHelper("LUS"); tstHelper("MA"); tstHelper("MA'A"); tstHelper("MA'I"); tstHelper("MAL"); tstHelper("MAN"); tstHelper("MANDA"); tstHelper("MANG"); tstHelper("MANYDZU"); tstHelper("MAR"); tstHelper("MAS"); tstHelper("MBI"); tstHelper("MCHAN"); tstHelper("MCHED"); tstHelper("MCHING"); tstHelper("MCHOD"); tstHelper("MCHOG"); tstHelper("MCHU"); tstHelper("MCHUR"); tstHelper("MDA'"); tstHelper("MDANGS"); tstHelper("MDAS"); tstHelper("MDO'I"); tstHelper("MDOG"); tstHelper("MDON"); tstHelper("MDUD"); tstHelper("MDUN"); tstHelper("MDZAD"); tstHelper("MDZES"); tstHelper("MDZOS"); tstHelper("ME"); tstHelper("ME'I"); tstHelper("MED"); tstHelper("MGA"); tstHelper("MGO"); tstHelper("MGO'I"); tstHelper("MGOS"); tstHelper("MGRON"); tstHelper("MI"); tstHelper("MI'I"); tstHelper("MID"); tstHelper("MIG"); tstHelper("MING"); tstHelper("MKHA'"); tstHelper("MKHA'I"); tstHelper("MKHAH"); tstHelper("MKHAN"); tstHelper("MKHAS"); tstHelper("MKHEN"); tstHelper("MKHRANG"); tstHelper("MKHREN"); tstHelper("MKHYEN"); tstHelper("MMING"); tstHelper("MNGAGS"); tstHelper("MNGAS"); tstHelper("MNGON"); tstHelper("MNYA'"); tstHelper("MNYAM"); tstHelper("MNYUNG"); tstHelper("MO"); tstHelper("MO'I"); tstHelper("MO'U"); tstHelper("MON"); tstHelper("MONGS"); tstHelper("MONS"); tstHelper("MOS"); tstHelper("MTHA'"); tstHelper("MTHAB"); tstHelper("MTHAN"); tstHelper("MTHANGS"); tstHelper("MTHAR"); tstHelper("MTHO"); tstHelper("MTHONG"); tstHelper("MTHU"); tstHelper("MTHUM"); tstHelper("MTHUN"); tstHelper("MTHUNG"); tstHelper("MTHUS"); tstHelper("MTON"); tstHelper("MTONG"); tstHelper("MTSA"); tstHelper("MTSAMS"); tstHelper("MTSAN"); tstHelper("MTSANS"); tstHelper("MTSO'I"); tstHelper("MTSONG"); tstHelper("MTSOS"); tstHelper("MTSUNG"); tstHelper("MTSUNGS"); tstHelper("MU"); tstHelper("MUG"); tstHelper("MYA"); tstHelper("MYANG"); tstHelper("MYAS"); tstHelper("MYID"); tstHelper("MYOG"); tstHelper("MYONG"); tstHelper("MYOS"); tstHelper("MYUNG"); tstHelper("N'I"); tstHelper("NA"); tstHelper("NA'I"); tstHelper("NAD"); tstHelper("NAG"); tstHelper("NAM"); tstHelper("NANG"); tstHelper("NAS"); tstHelper("NDA"); tstHelper("NE"); tstHelper("NE'U"); tstHelper("NES"); tstHelper("NGA"); tstHelper("NGA'I"); tstHelper("NGAB"); tstHelper("NGAG"); tstHelper("NGAL"); tstHelper("NGAN"); tstHelper("NGE"); tstHelper("NGE'I"); tstHelper("NGES"); tstHelper("NGO"); tstHelper("NGOR"); tstHelper("NGU'I"); tstHelper("NI"); tstHelper("NI'A"); tstHelper("NIG"); tstHelper("NIMITTA"); tstHelper("NIS"); tstHelper("NO"); tstHelper("NOG"); tstHelper("NOGS"); tstHelper("NONG"); tstHelper("NU"); tstHelper("NU'I"); tstHelper("NUB"); tstHelper("NYA"); tstHelper("NYAMS"); tstHelper("NYAN"); tstHelper("NYDZU"); tstHelper("NYE"); tstHelper("NYE'U"); tstHelper("NYEN"); tstHelper("NYES"); tstHelper("NYI"); tstHelper("NYID"); tstHelper("NYING"); tstHelper("NYON"); tstHelper("NYUG"); tstHelper("OD"); tstHelper("PA"); tstHelper("PA'A"); tstHelper("PA'I"); tstHelper("PA'LA"); tstHelper("PA'O"); tstHelper("PAD"); tstHelper("PADMA"); tstHelper("PADMA'I"); tstHelper("PAG"); tstHelper("PALA"); tstHelper("PANG"); tstHelper("PAR"); tstHelper("PARU"); tstHelper("PAS"); tstHelper("PA"); tstHelper("PHA"); tstHelper("PHAN"); tstHelper("PHEG"); tstHelper("PHI"); tstHelper("PHIN"); tstHelper("PHIR"); tstHelper("PHOD"); tstHelper("PHOG"); tstHelper("PHRA"); tstHelper("PHRAG"); tstHelper("PHRAN"); tstHelper("PHREN"); tstHelper("PHRENG"); tstHelper("PHROGS"); tstHelper("PHRUG"); tstHelper("PHUDG"); tstHelper("PHUN"); tstHelper("PHUNG"); tstHelper("PHUR"); tstHelper("PHYAG"); tstHelper("PHYE"); tstHelper("PHYI"); tstHelper("PHYIN"); tstHelper("PHYIR"); tstHelper("PHYIS"); tstHelper("PHYOGS"); tstHelper("PHYUN"); tstHelper("PHYUNG"); tstHelper("PHYUNGS"); tstHelper("PI"); tstHelper("PINGKA"); tstHelper("PO"); tstHelper("PO'I"); tstHelper("PO'i"); tstHelper("POR"); tstHelper("POS"); tstHelper("PRA"); tstHelper("PRAKshVA"); tstHelper("PRAL"); tstHelper("PRASIDDHA"); tstHelper("PRI"); tstHelper("PRONG"); tstHelper("PUN"); tstHelper("PUNANA'A"); tstHelper("PUS"); tstHelper("PYE"); tstHelper("R'AGA"); tstHelper("RA"); tstHelper("RA'"); tstHelper("RA'A"); tstHelper("RA'I"); tstHelper("RAA'"); tstHelper("RAB"); tstHelper("RABS"); tstHelper("RAG"); tstHelper("RAL"); tstHelper("RAN"); tstHelper("RANG"); tstHelper("RAS"); tstHelper("RAndABA"); tstHelper("RBOD"); tstHelper("RBYAR"); tstHelper("RDAS"); tstHelper("RDE'U"); tstHelper("RDEG"); tstHelper("RDO"); tstHelper("RDOB"); tstHelper("RDOBS"); tstHelper("RDUM"); tstHelper("RDZAS"); tstHelper("RDZI"); tstHelper("RDZOGS"); tstHelper("RDZU"); tstHelper("RDZUL"); tstHelper("RENGS"); tstHelper("RGOD"); tstHelper("RGOG"); tstHelper("RGOS"); tstHelper("RGYA"); tstHelper("RGYAL"); tstHelper("RGYAN"); tstHelper("RGYANG"); tstHelper("RGYAS"); tstHelper("RGYES"); tstHelper("RGYU"); tstHelper("RGYUD"); tstHelper("RGYUN"); tstHelper("RGYUS"); tstHelper("RI"); tstHelper("RI'I"); tstHelper("RIGS"); tstHelper("RIL"); tstHelper("RIM"); tstHelper("RIN"); tstHelper("RING"); tstHelper("RIS"); tstHelper("RJE"); tstHelper("RJE'U"); tstHelper("RJES"); tstHelper("RJO"); tstHelper("RKA'I"); tstHelper("RKANG"); tstHelper("RKO"); tstHelper("RKU"); tstHelper("RKUN"); tstHelper("RKYEN"); tstHelper("RLABS"); tstHelper("RLE'O"); tstHelper("RLING"); tstHelper("RMAL"); tstHelper("RMEL"); tstHelper("RMONG"); tstHelper("RMONGS"); tstHelper("RMUS"); tstHelper("RMYANGS"); tstHelper("RNA"); tstHelper("RNABS"); tstHelper("RNAM"); tstHelper("RNAMS"); tstHelper("RNGA'U"); tstHelper("RNGAB"); tstHelper("RNGANGS"); tstHelper("RNGE"); tstHelper("RNGOG"); tstHelper("RNGU"); tstHelper("RNGUS"); tstHelper("RNOGS"); tstHelper("RO"); tstHelper("RO.STOD (DLC!)"); tstHelper("ROL"); tstHelper("RSBOD"); tstHelper("RTAG"); tstHelper("RTE'"); tstHelper("RTEN"); tstHelper("RTOL"); tstHelper("RTUL"); tstHelper("RTYAM"); tstHelper("RTZA"); tstHelper("RTZAL"); tstHelper("RTZE"); tstHelper("RTZENGS"); tstHelper("RTZI"); tstHelper("RTZIBS"); tstHelper("RTZIS"); tstHelper("RTZUB"); tstHelper("RTZUBS"); tstHelper("RU"); tstHelper("RUL"); tstHelper("RUNG"); tstHelper("RUNGS"); tstHelper("RYA"); tstHelper("RYA'I"); tstHelper("RYAL"); tstHelper("SA"); tstHelper("SA'"); tstHelper("SA'A"); tstHelper("SA'I"); tstHelper("SA'O"); tstHelper("SAG"); tstHelper("SANG"); tstHelper("SANGS"); tstHelper("SBANG"); tstHelper("SBNYEN"); tstHelper("SBRANG"); tstHelper("SBRAS"); tstHelper("SBREL"); tstHelper("SBRING"); tstHelper("SBRIS"); tstHelper("SBROS"); tstHelper("SBRUGS"); tstHelper("SBRUL"); tstHelper("SBRUNG"); tstHelper("SBU"); tstHelper("SBUNGS"); tstHelper("SBUR"); tstHelper("SBYAN"); tstHelper("SBYANGS"); tstHelper("SBYANS"); tstHelper("SBYAR"); tstHelper("SBYER"); tstHelper("SBYI"); tstHelper("SBYIN"); tstHelper("SBYIR"); tstHelper("SBYO"); tstHelper("SBYOR"); tstHelper("SBYU"); tstHelper("SBYUG"); tstHelper("SBYUGS"); tstHelper("SDAGS"); tstHelper("SDAN"); tstHelper("SDBUGS"); tstHelper("SDE"); tstHelper("SDE'U"); tstHelper("SDIG"); tstHelper("SDOD"); tstHelper("SDON"); tstHelper("SDONG"); tstHelper("SDUG"); tstHelper("SE'I"); tstHelper("SEMS"); tstHelper("SENG"); tstHelper("SER"); tstHelper("SGA"); tstHelper("SGO'U"); tstHelper("SGOGS"); tstHelper("SGRA"); tstHelper("SGRAR"); tstHelper("SGRE'U"); tstHelper("SGREL"); tstHelper("SGRON"); tstHelper("SGRUB"); tstHelper("SGRUP"); tstHelper("SGUB"); tstHelper("SGUG"); tstHelper("SGUN"); tstHelper("SGYE'O"); tstHelper("SGYES"); tstHelper("SGYOD"); tstHelper("SGYUNG"); tstHelper("SH'A"); tstHelper("SH'AKYA"); tstHelper("SHA"); tstHelper("SHA'"); tstHelper("SHA'A"); tstHelper("SHAA'"); tstHelper("SHAA'RI'I"); tstHelper("SHAL"); tstHelper("SHAM"); tstHelper("SHAN"); tstHelper("SHANG"); tstHelper("SHAR"); tstHelper("SHEG"); tstHelper("SHES"); tstHelper("SHI"); tstHelper("SHI'A"); tstHelper("SHIG"); tstHelper("SHIN"); tstHelper("SHING"); tstHelper("SHOG"); tstHelper("SHRU"); tstHelper("SHRUT"); tstHelper("SHVA"); tstHelper("SI"); tstHelper("SI'I"); tstHelper("SING"); tstHelper("SKA"); tstHelper("SKABS"); tstHelper("SKAD"); tstHelper("SKAM"); tstHelper("SKANG"); tstHelper("SKAR"); tstHelper("SKARI"); tstHelper("SKE"); tstHelper("SKEGS"); tstHelper("SKEL"); tstHelper("SKHANG"); tstHelper("SKO"); tstHelper("SKONG"); tstHelper("SKOR"); tstHelper("SKRA'I"); tstHelper("SKRED"); tstHelper("SKUD"); tstHelper("SKYAN"); tstHelper("SKYANG"); tstHelper("SKYE"); tstHelper("SKYE'O"); tstHelper("SKYE'U"); tstHelper("SKYED"); tstHelper("SKYEGS"); tstHelper("SKYEN"); tstHelper("SKYES"); tstHelper("SKYIMS"); tstHelper("SKYO"); tstHelper("SKYOB"); tstHelper("SKYONG"); tstHelper("SKYONGS"); tstHelper("SLABS"); tstHelper("SLAR"); tstHelper("SLE'O"); tstHelper("SLO"); tstHelper("SLOB"); tstHelper("SLONG"); tstHelper("SLOP"); tstHelper("SMA"); tstHelper("SMAD"); tstHelper("SMAM"); tstHelper("SMAN"); tstHelper("SMEL"); tstHelper("SMOD"); tstHelper("SMON"); tstHelper("SMONGS"); tstHelper("SMRA"); tstHelper("SMRA'I"); tstHelper("SMRA'O"); tstHelper("SMUNG"); tstHelper("SMYANGS"); tstHelper("SMYUG"); tstHelper("SMYUNG"); tstHelper("SNA"); tstHelper("SNABS"); tstHelper("SNAMG"); tstHelper("SNAR"); tstHelper("SNGAGS"); tstHelper("SNGANG"); tstHelper("SNGANGS"); tstHelper("SNGO"); tstHelper("SNGO'I"); tstHelper("SNGOGS"); tstHelper("SNGON"); tstHelper("SNOD"); tstHelper("SNRA"); tstHelper("SNREL"); tstHelper("SNRON"); tstHelper("SNUM"); tstHelper("SNYA"); tstHelper("SNYAM"); tstHelper("SNYEG"); tstHelper("SNYEGS"); tstHelper("SNYER"); tstHelper("SNYIL"); tstHelper("SNYING"); tstHelper("SNYOD"); tstHelper("SNYOMS"); tstHelper("SO"); tstHelper("SO'I"); tstHelper("SOGS"); tstHelper("SONG"); tstHelper("SOR"); tstHelper("SPANG"); tstHelper("SPANGS"); tstHelper("SPOBS"); tstHelper("SPRAS"); tstHelper("SPRE'U'I"); tstHelper("SPRIN"); tstHelper("SPRO"); tstHelper("SPRUGS"); tstHelper("SPU"); tstHelper("SPUNGS"); tstHelper("SPYAD"); tstHelper("SPYAN"); tstHelper("SPYANG"); tstHelper("SPYI"); tstHelper("SPYI'I"); tstHelper("SPYI'U"); tstHelper("SPYIR"); tstHelper("SPYIS"); tstHelper("SPYOD"); tstHelper("SPYON"); tstHelper("SPYONG"); tstHelper("SPYOOD"); tstHelper("SPYOR"); tstHelper("SPYUGS"); tstHelper("SRAL"); tstHelper("SRAN"); tstHelper("SRAS"); tstHelper("SREG"); tstHelper("SRI"); tstHelper("SRID"); tstHelper("SRIN"); tstHelper("SRJOD"); tstHelper("SRO"); tstHelper("SROG"); tstHelper("SROL"); tstHelper("SRONG"); tstHelper("SRUNG"); tstHelper("SRUNGS"); tstHelper("STE"); tstHelper("STED"); tstHelper("STENG"); tstHelper("STENGS"); tstHelper("STHA"); tstHelper("STOB"); tstHelper("STOBS"); tstHelper("STOD"); tstHelper("STON"); tstHelper("STONG"); tstHelper("STUG"); tstHelper("STUGS"); tstHelper("STZAGS"); tstHelper("SU"); tstHelper("SUM"); tstHelper("SZHON"); tstHelper("Si"); tstHelper("T'A"); tstHelper("T'A'I"); tstHelper("TA"); tstHelper("TA'A"); tstHelper("TAA'I"); tstHelper("TAMBA"); tstHelper("TE"); tstHelper("TE'U"); tstHelper("TE'U'I"); tstHelper("THA"); tstHelper("THABS"); tstHelper("THAD"); tstHelper("THAG"); tstHelper("THAL"); tstHelper("THAMS"); tstHelper("THE"); tstHelper("THE'U"); tstHelper("THED"); tstHelper("THEG"); tstHelper("THI"); tstHelper("THIB"); tstHelper("THIM"); tstHelper("THIMS"); tstHelper("THIN"); tstHelper("THING"); tstHelper("THOB"); tstHelper("THOD"); tstHelper("THOGS"); tstHelper("THOS"); tstHelper("THUB"); tstHelper("THUG"); tstHelper("THUGS"); tstHelper("THUNG"); tstHelper("THUR"); tstHelper("TI"); tstHelper("TI'"); tstHelper("TI'A"); tstHelper("TI'I"); tstHelper("TIG"); tstHelper("TING"); tstHelper("TKA'A"); tstHelper("TOG"); tstHelper("TOR"); tstHelper("TPA"); tstHelper("TRA'AI"); tstHelper("TRE"); tstHelper("TRYAM"); tstHelper("TSAD"); tstHelper("TSAL"); tstHelper("TSANG"); tstHelper("TSANGS"); tstHelper("TSE"); tstHelper("TSE'U"); tstHelper("TSEGS"); tstHelper("TSER"); tstHelper("TSIG"); tstHelper("TSIGS"); tstHelper("TSOD"); tstHelper("TSOGS"); tstHelper("TSOM"); tstHelper("TSON"); tstHelper("TSONG"); tstHelper("TSOR"); tstHelper("TSOS"); tstHelper("TSUGS"); tstHelper("TSUL"); tstHelper("TSUR"); tstHelper("TU"); tstHelper("TUB"); tstHelper("TUD"); tstHelper("TUS"); tstHelper("TYA'I"); tstHelper("TZ'A"); tstHelper("TZA"); tstHelper("TZAM"); tstHelper("TZAMMI"); tstHelper("TZAMPAKA"); tstHelper("TZAN"); tstHelper("TZANDA"); tstHelper("TZANDAN"); tstHelper("TZE'U"); tstHelper("TZER"); tstHelper("TZI"); tstHelper("TZIB"); tstHelper("WA"); tstHelper("WA'A"); tstHelper("WAM"); tstHelper("WANG"); tstHelper("X"); tstHelper("YA"); tstHelper("YA'A"); tstHelper("YA'AnA"); tstHelper("YA'I"); tstHelper("YAN"); tstHelper("YANG"); tstHelper("YANGS"); tstHelper("YAS"); tstHelper("YAmGU"); tstHelper("YE"); tstHelper("YI"); tstHelper("YID"); tstHelper("YIN"); tstHelper("YOL"); tstHelper("YONGS"); tstHelper("YU"); tstHelper("YUG"); tstHelper("YUL"); tstHelper("ZAD"); tstHelper("ZAG"); tstHelper("ZAN"); tstHelper("ZAR"); tstHelper("ZDOG"); tstHelper("ZE'I"); tstHelper("ZER"); tstHelper("ZHA'I"); tstHelper("ZHABS"); tstHelper("ZHAL"); tstHelper("ZHE"); tstHelper("ZHEN"); tstHelper("ZHENG"); tstHelper("ZHER"); tstHelper("ZHES"); tstHelper("ZHES'O"); tstHelper("ZHI"); tstHelper("ZHI'I"); tstHelper("ZHIG"); tstHelper("ZHIGS"); tstHelper("ZHIN"); tstHelper("ZHING"); tstHelper("ZHON"); tstHelper("ZHUGS"); tstHelper("ZHUS"); tstHelper("ZI'I"); tstHelper("ZIL"); tstHelper("ZING"); tstHelper("ZLA"); tstHelper("ZLOG"); tstHelper("ZLOS"); tstHelper("ZLUM"); tstHelper("ZUG"); tstHelper("ZUL"); tstHelper("ZUNG"); tstHelper("d'U"); tstHelper("dA"); tstHelper("dALA"); tstHelper("dI"); tstHelper("dU"); tstHelper("nA"); tstHelper("nA'I"); tstHelper("nDA'A"); tstHelper("nE"); tstHelper("nI"); tstHelper("nYAGRO"); tstHelper("ndI"); tstHelper("shKA"); } } /* DLC FIXME: add test cases: from R0021F.ACE: ambiguous Tibetan/Sanskrit: BDA' B+DA DBANG D+BA DGA' D+GA DGRA D+GRA DGYES D+GYA DMAR D+MA GDA' G+DA GNAD G+NA MNA' M+NA */