diff --git a/build.xml b/build.xml index 974ea65..5da41fb 100644 --- a/build.xml +++ b/build.xml @@ -1,3 +1,22 @@ + + + + + + + + + + + + + - - - - - - @@ -426,10 +450,6 @@ - - - - + + - diff --git a/source/org/thdl/tib/text/package.html b/source/org/thdl/tib/text/package.html index a14ce46..553fc2c 100644 --- a/source/org/thdl/tib/text/package.html +++ b/source/org/thdl/tib/text/package.html @@ -5,7 +5,7 @@ @(#)package.html - Copyright 2001-2002 Tibetan and Himalayan Digital Library + Copyright 2001-2003 Tibetan and Himalayan Digital Library This software is the confidential and proprietary information of the Tibetan and Himalayan Digital Library. You shall use such @@ -18,12 +18,14 @@ Provides classes and methods for dealing with Tibetan text.

-Designed for use with the Tibetan Computer -Company's free cross-platform TibetanMachineWeb fonts, this package -contains methods for getting the Extended Wylie -correspondences for each TibetanMachineWeb glyph, and for -convert back and forth between Extended -Wylie and TibetanMachineWeb. +Designed for use with the Tibetan Computer Company's free +cross-platform TibetanMachineWeb fonts, this package contains methods +for getting the Extended Wylie correspondences for each +TibetanMachineWeb glyph, and for convert back and forth between +Extended Wylie and TibetanMachineWeb. The TMW to Wylie conversion is +perfect, but the Wylie to TMW is flawed, so use the code in package +org.thdl.tib.text.ttt instead for serious work. The Wylie to TMW here +is more like a keyboard than a real Wylie to TMW conversion.

This package provides a variety of ways to store TibetanMachineWeb data, and includes methods to aid programmers who want to convert from @@ -34,5 +36,6 @@ keyboards. Four keyboards have been provided in this release, but users may also create their own keyboards.

Related Documentation

@see org.thdl.tib.input +@see org.thdl.tib.text.ttt diff --git a/source/org/thdl/tib/text/ttt/ACIPRules.java b/source/org/thdl/tib/text/ttt/ACIPRules.java new file mode 100644 index 0000000..2d1db42 --- /dev/null +++ b/source/org/thdl/tib/text/ttt/ACIPRules.java @@ -0,0 +1,207 @@ +/* +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 java.util.HashSet; +import java.util.HashMap; + +/** Canonizes some facts regarding the ACIP transcription system. + * @author David Chandler */ +class ACIPRules { + /** {Ksh}, the longest consonant, has 3 characters, so this is + * three. */ + public static int MAX_CONSONANT_LENGTH = 3; + + /** {'im:}, the longest "vowel", has 4 characters, so this is + * four. */ + public static int MAX_VOWEL_LENGTH = 4; + + /** For O(1) {@link #isVowel(String)} calls. */ + private static HashSet acipVowels = null; + + private static String[][] baseVowels = new String[][] { + // { ACIP, EWTS }: + { "A", "a" }, + { "I", "i" }, + { "U", "u" }, + { "E", "e" }, + { "O", "o" }, + { "'I", "I" }, + { "'U", "U" }, + { "EE", "ai" }, + { "OO", "au" }, + { "i", "-i" }, + { "'i", "-I" }, + { "'A", "A" }, + { "'O", "Ao" }, + { "'E", "Ae" } + // DLC I'm on my own with 'O and 'E, but GANG'O appears + // and I wonder... so here are 'O and 'E. It's + // consistent with 'I and 'A and 'U, at least. + }; + + /** Returns true if and only if s is an ACIP "vowel". You can't + * just call this any time -- A is a consonant and a vowel in + * ACIP, so you have to call this in the right context. */ + public static boolean isVowel(String s) { + if (null == acipVowels) { + acipVowels = new HashSet(); + for (int i = 0; i < baseVowels.length; i++) { + acipVowels.add(baseVowels[i][0]); + acipVowels.add(baseVowels[i][0] + 'm'); + acipVowels.add(baseVowels[i][0] + ':'); + acipVowels.add(baseVowels[i][0] + "m:"); + // DLC '\' for visarga? how shall we do \ the visarga? like a vowel or not? + + } + } + return (acipVowels.contains(s)); + } + + /** For O(1) {@link #isConsonant(String)} calls. */ + private static HashSet consonants = null; + + /** Returns true if and only if acip is an ACIP consonant (without + * a vowel). For example, returns true for "K", but not for + * "KA" or "X". */ + public static boolean isConsonant(String acip) { + if (consonants == null) { + consonants = new HashSet(); + consonants.add("V"); + consonants.add("K"); + consonants.add("KH"); + consonants.add("G"); + consonants.add("NG"); + consonants.add("C"); + consonants.add("CH"); + consonants.add("J"); + consonants.add("NY"); + consonants.add("T"); + consonants.add("TH"); + consonants.add("D"); + consonants.add("N"); + consonants.add("P"); + consonants.add("PH"); + consonants.add("B"); + consonants.add("M"); + consonants.add("TZ"); + consonants.add("TS"); + consonants.add("DZ"); + consonants.add("W"); + consonants.add("ZH"); + consonants.add("Z"); + consonants.add("Y"); + consonants.add("R"); + consonants.add("L"); + consonants.add("SH"); + consonants.add("S"); + consonants.add("H"); + consonants.add("t"); + consonants.add("th"); + consonants.add("d"); + consonants.add("n"); + consonants.add("sh"); + consonants.add("dH"); + consonants.add("DH"); + consonants.add("BH"); + consonants.add("DZH"); // longest, MAX_CONSONANT_LENGTH characters + consonants.add("Ksh"); // longest, MAX_CONSONANT_LENGTH characters + consonants.add("GH"); + consonants.add("'"); + consonants.add("A"); + } + return consonants.contains(acip); + } + + private static HashMap acipConsonant2wylie = null; + /** Returns the EWTS corresponding to the given ACIP consonant + * (without the "A" vowel). Returns null if there is no such + * EWTS. */ + static final String getWylieForACIPConsonant(String acip) { + if (acipConsonant2wylie == null) { + acipConsonant2wylie = new HashMap(37); + + // oddball: + acipConsonant2wylie.put("V", "w"); + + // more oddballs: + acipConsonant2wylie.put("DH", "d+h"); + acipConsonant2wylie.put("BH", "b+h"); + acipConsonant2wylie.put("dH", "D+h"); + acipConsonant2wylie.put("DZH", "dz+h"); + acipConsonant2wylie.put("Ksh", "k+Sh"); + acipConsonant2wylie.put("GH", "g+h"); + + + acipConsonant2wylie.put("K", "k"); + acipConsonant2wylie.put("KH", "kh"); + acipConsonant2wylie.put("G", "g"); + acipConsonant2wylie.put("NG", "ng"); + acipConsonant2wylie.put("C", "c"); + acipConsonant2wylie.put("CH", "ch"); + acipConsonant2wylie.put("J", "j"); + acipConsonant2wylie.put("NY", "ny"); + acipConsonant2wylie.put("T", "t"); + acipConsonant2wylie.put("TH", "th"); + acipConsonant2wylie.put("D", "d"); + acipConsonant2wylie.put("N", "n"); + acipConsonant2wylie.put("P", "p"); + acipConsonant2wylie.put("PH", "ph"); + acipConsonant2wylie.put("B", "b"); + acipConsonant2wylie.put("M", "m"); + acipConsonant2wylie.put("TZ", "ts"); + acipConsonant2wylie.put("TS", "tsh"); + acipConsonant2wylie.put("DZ", "dz"); + acipConsonant2wylie.put("W", "w"); + acipConsonant2wylie.put("ZH", "zh"); + acipConsonant2wylie.put("Z", "z"); + acipConsonant2wylie.put("'", "'"); + acipConsonant2wylie.put("Y", "y"); + acipConsonant2wylie.put("R", "r"); + acipConsonant2wylie.put("L", "l"); + acipConsonant2wylie.put("SH", "sh"); + acipConsonant2wylie.put("S", "s"); + acipConsonant2wylie.put("H", "h"); + acipConsonant2wylie.put("A", "a"); + acipConsonant2wylie.put("t", "T"); + acipConsonant2wylie.put("th", "Th"); + acipConsonant2wylie.put("d", "D"); + acipConsonant2wylie.put("n", "N"); + acipConsonant2wylie.put("sh", "Sh"); + } + return (String)acipConsonant2wylie.get(acip); + } + + private static HashMap acipVowel2wylie = null; + /** Returns the EWTS corresponding to the given ACIP "vowel". + * Returns null if there is no such EWTS. */ + static final String getWylieForACIPVowel(String acip) { + if (acipVowel2wylie == null) { + acipVowel2wylie = new HashMap(baseVowels.length * 4); + + for (int i = 0; i < baseVowels.length; i++) { + acipVowel2wylie.put(baseVowels[i][0], baseVowels[i][1]); + acipVowel2wylie.put(baseVowels[i][0] + 'm', baseVowels[i][1] + 'M'); + acipVowel2wylie.put(baseVowels[i][0] + ':', baseVowels[i][1] + 'H'); + acipVowel2wylie.put(baseVowels[i][0] + "m:", baseVowels[i][1] + "MH"); + } + } + return (String)acipVowel2wylie.get(acip); + } +} diff --git a/source/org/thdl/tib/text/ttt/PackageTest.java b/source/org/thdl/tib/text/ttt/PackageTest.java new file mode 100644 index 0000000..3521c5f --- /dev/null +++ b/source/org/thdl/tib/text/ttt/PackageTest.java @@ -0,0 +1,6885 @@ +// -*- 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 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); + } + private static void tstHelper(String acip, String expectedPairs) { + tstHelper2(acip, expectedPairs, false, null, null); + } + private static void tstHelper(String acip, String[] expectedParses) { + tstHelper2(acip, null, false, expectedParses, null); + } + private static void tstHelper(String acip, String expectedPairs, String[] expectedParses) { + tstHelper2(acip, expectedPairs, false, expectedParses, null); + } + private static void tstHelper(String acip, String expectedPairs, String[] expectedParses, String[] legalParses) { + tstHelper2(acip, expectedPairs, false, expectedParses, legalParses); + } + private static void tstHelper2(String acip) { + tstHelper2(acip, null); + } + private static void tstHelper2(String acip, String expectedPairs) { + tstHelper2(acip, expectedPairs, true, null, null); + } + + private static final boolean sdebug = false; + private static void tstHelper2(String acip, + String expectedPairs, + boolean debug, + String[] expectedParses, + String[] expectedLegalParses) { + 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; + } + int np = pt.numberOfParses(); + boolean goodness = expectedParses == null || expectedParses.length == np; + if (sdebug || debug || !goodness) + System.out.println("ACIP=" + acip + " and parse tree=" + pt + " /size " + pt.size() + "; /pairs " + pt.numberOfPairs() + "; /numParses " + np); + assertTrue(goodness); + + { + ParseIterator pi = pt.getParseIterator(); + for (int i = 0 ; i < np; i++) { + TStackList n = pi.next(); + if (sdebug || debug) + System.out.println("Parse " + (i + 1) + " is " + n + " which has " + n.size() + " glyphs."); + boolean okay = (null == expectedParses || n.equals(expectedParses[i])); + if (!okay) + System.out.println("Parse " + (i) + " (from zero) is " + n + " (toString2=" + n.toString2() + ") and expected is " + expectedParses[i]); + assertTrue(okay); + } + assertTrue(!pi.hasNext()); + } + + { + TStackListList legalParses = pt.getUniqueParse(); + boolean goodness2 = (expectedLegalParses == null + || expectedLegalParses.length == legalParses.size()); + for (int i = 0 ; i < legalParses.size(); i++) { + TStackList n = legalParses.get(i); + if (sdebug || debug) + System.out.println("Legal parse " + (i + 1) + " is " + n + " which has " + n.size() + " glyphs."); + boolean okay = (null == expectedLegalParses + || expectedLegalParses.length < i+1 + || n.equals(expectedLegalParses[i])); + if (!okay || !goodness2) + System.out.println("Legal parse " + (i) + " (from zero) is " + n + " (toString2=" + n.toString2() + ") and expected is " + expectedLegalParses[i]); + assertTrue(okay); + } + if (!goodness2) + System.out.println("You expected " + expectedLegalParses.length + " legal parses, but there were instead " + legalParses.size() + " legal parses."); + assertTrue(goodness2); + TStackListList allLegalParses = pt.getLegalParses(); + TStackListList decentParses = pt.getNonIllegalParses(); + if (legalParses.size() != 1 && true && pt.getBestParse() == null) { + if (legalParses.size() == 0) { + if (pt.getBestParse() != null) { + System.out.print("There is a best parse for the slightly rocky ACIP {" + acip + "}; "); + } else { + 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 { + 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())); + } + } + 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("901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678"); + } + + /** Tests {@link TPairListFactory#breakACIPIntoChunks(String)}, + * {@link TPairList#getACIPError()}, and {@link + * TPairList#recoverACIP()}. */ + public void testBreakACIPIntoChunks() { + tstHelper("GRVA'I", "{G}{R}{VA}{'I}", + new String[] { "{G}{R+VA}{'I}", "{G+R+VA}{'I}" }, + new String[] { "{G+R+VA}{'I}" }); + tstHelper("G-RVA'I", "{G-}{R}{VA}{'I}", + new String[] { "{G}{R+VA}{'I}" }, + new String[] { "{G}{R+VA}{'I}" }); + tstHelper("RVA", "{R}{VA}", + new String[] { "{R+VA}" }, + new String[] { "{R+VA}" }); + tstHelper("K+0", "{K+}{0}", new String[] { }, new String[] { }); + tstHelper("0+K", "{0-}{+-}{K}", new String[] { }, new String[] { }); + tstHelper("0+0", "{0-}{+-}{0}", new String[] { }, new String[] { }); + + // DLC add tests for BRTAN, BLTA, BLAG, BRAG, B-LAG, B-RAG + + // MARK for searching + tstHelper("0", "{0}", new String[] { "{0}" }, + new String[] { "{0}" }); + tstHelper("0123", "{0-}{1-}{2-}{3}", new String[] { "{0}{1}{2}{3}" }, + new String[] { "{0}{1}{2}{3}" }); + tstHelper("0-123", "{0-}{-}{1-}{2-}{3}", new String[] { "{0}{1}{2}{3}" }, + new String[] { "{0}{1}{2}{3}" }); + tstHelper("0123KA", "{0-}{1-}{2-}{3-}{KA}", new String[] { "{0}{1}{2}{3}{KA}" }, + new String[] { }); + tstHelper("G0123KA", "{G}{0-}{1-}{2-}{3-}{KA}", new String[] { "{G}{0}{1}{2}{3}{KA}" }, + new String[] { }); + tstHelper("BHA"); + tstHelper("BHE"); + tstHelper("BH'I"); + tstHelper("BH'Im"); + tstHelper("BH'Im:"); // DLC FIXME: make TibetanMachineWeb see EWTS {H} as an adornment. + tstHelper("D-VA"); + tstHelper("DVA"); + tstHelper("SRAS", "{S}{RA}{S}", + new String[] { "{S}{RA}{S}", "{S+RA}{S}" }, + new String[] { "{S+RA}{S}" }); + tstHelper("SARS", "{SA}{R}{S}", + new String[] { "{SA}{R}{S}", "{SA}{R+S}" }, + new String[] { "{SA}{R}{S}" }); + tstHelper("SARAS", "{SA}{RA}{S}", + new String[] { "{SA}{RA}{S}" }, + new String[] { "{SA}{RA}{S}" }); + + tstHelper("SHLO", + "{SH}{LO}", + new String[] { "{SH}{LO}", "{SH+LO}" }, + new String[] { "{SH+LO}" }); + tstHelper("ZLUM", "{Z}{LU}{M}", new String[] { "{Z}{LU}{M}", "{Z+LU}{M}" }, new String[] { "{Z+LU}{M}" }); + tstHelper("B+DDZ", "{B+}{D}{DZ}", + new String[] { "{B+D}{DZ}", + "{B+D+DZ}" }); // we're conservative. + // A heuristic is to + // say that B+DDZ must + // be {B+D}{DZ} + // because the + // keyboardist surely + // would've typed two + // plusses if {B+D+DZ} + // were desired, given + // that we know the + // keyboardist was + // aware of the plus + // operator. + + tstHelper("BRTN--GA", + "{B}{R}{T}{N-}{-}{GA}", + new String[] { + "{B}{R}{T}{N}{GA}", + "{B}{R}{T+N}{GA}", + "{B}{R+T}{N}{GA}", + "{B+R}{T}{N}{GA}", + "{B+R}{T+N}{GA}", + }); + tstHelper("BR-TN"); // DLC: no legal parses, and 2 decent ones, eh? + tstHelper("BRTN", + "{B}{R}{T}{N}", + new String[] { + "{B}{R}{T}{N}", + "{B}{R}{T+N}", + "{B}{R+T}{N}", + "{B+R}{T}{N}", + "{B+R}{T+N}", + }, + new String[] { + "{B}{R+T}{N}" // prefix-root-suffix + }); + tstHelper("BRTN-BRTN", + "{B}{R}{T}{N-}{B}{R}{T}{N}", + new String[] { + "{B}{R}{T}{N}{B}{R}{T}{N}", + "{B}{R}{T}{N}{B}{R}{T+N}", + "{B}{R}{T}{N}{B}{R+T}{N}", + "{B}{R}{T}{N}{B+R}{T}{N}", + "{B}{R}{T}{N}{B+R}{T+N}", + "{B}{R}{T+N}{B}{R}{T}{N}", + "{B}{R}{T+N}{B}{R}{T+N}", + "{B}{R}{T+N}{B}{R+T}{N}", + "{B}{R}{T+N}{B+R}{T}{N}", + "{B}{R}{T+N}{B+R}{T+N}", + "{B}{R+T}{N}{B}{R}{T}{N}", + "{B}{R+T}{N}{B}{R}{T+N}", + "{B}{R+T}{N}{B}{R+T}{N}", + "{B}{R+T}{N}{B+R}{T}{N}", + "{B}{R+T}{N}{B+R}{T+N}", + "{B+R}{T}{N}{B}{R}{T}{N}", + "{B+R}{T}{N}{B}{R}{T+N}", + "{B+R}{T}{N}{B}{R+T}{N}", + "{B+R}{T}{N}{B+R}{T}{N}", + "{B+R}{T}{N}{B+R}{T+N}", + "{B+R}{T+N}{B}{R}{T}{N}", + "{B+R}{T+N}{B}{R}{T+N}", + "{B+R}{T+N}{B}{R+T}{N}", + "{B+R}{T+N}{B+R}{T}{N}", + "{B+R}{T+N}{B+R}{T+N}", + }); // has 25 parses + tstHelper("B+R-T-N-B-R-T+N", + new String[] { "{B+R}{T}{N}{B}{R}{T+N}" }); // has 1 parse + tstHelper("B+G+K", "{B+}{G+}{K}", new String[] { }); // no parses. + tstHelper("G-YA", + new String[] { "{G}{YA}" }); // has 1 parse + tstHelper("G+YA", + new String[] { "{G+YA}" }); // has 1 parse + tstHelper("G+YAm:", + new String[] { "{G+YAm:}" }); // has 1 parse + tstHelper("BRTN-BLTA", "{B}{R}{T}{N-}{B}{L}{TA}", + new String[] { + "{B}{R}{T}{N}{B}{L}{TA}", + "{B}{R}{T}{N}{B}{L+TA}", + "{B}{R}{T}{N}{B+L}{TA}", + "{B}{R}{T+N}{B}{L}{TA}", + "{B}{R}{T+N}{B}{L+TA}", + "{B}{R}{T+N}{B+L}{TA}", + "{B}{R+T}{N}{B}{L}{TA}", + "{B}{R+T}{N}{B}{L+TA}", + "{B}{R+T}{N}{B+L}{TA}", + "{B+R}{T}{N}{B}{L}{TA}", + "{B+R}{T}{N}{B}{L+TA}", + "{B+R}{T}{N}{B+L}{TA}", + "{B+R}{T+N}{B}{L}{TA}", + "{B+R}{T+N}{B}{L+TA}", + "{B+R}{T+N}{B+L}{TA}", + }); // has 15 parses + tstHelper("BSABS", new String[] { "{B}{SA}{B}{S}" }); + tstHelper("ZUNGS"); + tstHelper("BRTIB", + "{B}{R}{TI}{B}", + new String[] { + "{B}{R}{TI}{B}", + "{B}{R+TI}{B}", + "{B+R}{TI}{B}", + }); + tstHelper("PRiTZTSVA", + "{P}{Ri}{TZ}{TS}{VA}", + new String[] { + "{P}{Ri}{TZ}{TS+VA}", + "{P}{Ri}{TZ+TS+VA}", + "{P+Ri}{TZ}{TS+VA}", + "{P+Ri}{TZ+TS+VA}" + }); + tstHelper("SPYOMS", "{S}{P}{YO}{M}{S}", + new String[] { + "{S}{P}{YO}{M}{S}", + "{S}{P}{YO}{M+S}", + "{S}{P+YO}{M}{S}", + "{S}{P+YO}{M+S}", + "{S+P}{YO}{M}{S}", + "{S+P}{YO}{M+S}", + "{S+P+YO}{M}{S}", + "{S+P+YO}{M+S}", + }); + tstHelper(":'AO", "[(: . -), (' . ), (A . O)]"); + tstHelper("AA:", "[(A . A:)]", new String[] { "{AA:}" }); + tstHelper("KE:", "[(K . E:)]"); + tstHelper("K:", "[(K . ), (: . )]", + new String[] { /* No parses exist. "K:" is illegal. */ }); + tstHelper("'AO", "[(' . ), (A . O)]"); + tstHelper("'AOM", "[(' . ), (A . O), (M . )]"); + // DLC CHECK: S6814M6.ACT for BA'I and 'AO + + tstHelper("BTZVA", "[(B . ), (TZ . ), (V . A)]"); + + tstHelper("G--YA", new String[] { "{G}{YA}" }); + tstHelper("-", "[( . -)]"); + tstHelper("+", "[(+ . )]"); + tstHelper("G-Y", "[(G . -), (Y . )]"); + tstHelper("GA-Y", "[(G . A), ( . -), (Y . )]"); + + tstHelper("SKU'I", "[(S . ), (K . U), (' . I)]"); + tstHelper("'BU", "[(' . ), (B . U)]"); + tstHelper("BSKYANGS", "[(B . ), (S . ), (K . ), (Y . A), (NG . ), (S . )]"); + tstHelper("SKYABS", "[(S . ), (K . ), (Y . A), (B . ), (S . )]"); + tstHelper("SKYAB", "[(S . ), (K . ), (Y . A), (B . )]"); + + tstHelper("NA+YADAA", "[(N . +), (Y . A), (D . ), (A . A)]"); + tstHelper("AA-KshA", "[(A . A), ( . -), (Ksh . A)]"); + + tstHelper("AAS", "[(A . A), (S . )]"); + tstHelper("AA-ttA", "[(A . A), ( . -), (t . ), (t . A)]"); + tstHelper("'AD", "[(' . A), (D . )]"); + tstHelper("AE", "[(A . E)]"); + tstHelper("AEE", "[(A . EE)]"); + tstHelper("AER", "[(A . E), (R . )]"); + tstHelper("AG"); + + + tstHelper("H'Um:", "[(H . 'Um:)]"); + tstHelper("H'U", "[(H . 'U)]"); + tstHelper("Hi", "[(H . i)]"); + tstHelper("Him", "[(H . im)]"); + tstHelper("Him:", "[(H . im:)]"); + tstHelper("H'Um", "[(H . 'Um)]"); + + tstHelper("AA", "[(A . A)]"); + tstHelper("AAm", "[(A . Am)]"); + tstHelper("AAm:", "[(A . Am:)]"); + tstHelper("A'im:", "[(A . 'im:)]"); + tstHelper("DEAI", "[(D . E), (A . I)]"); + tstHelper("G'A'I", "[(G . 'A), (' . I)]"); + tstHelper("G'I'I", "[(G . 'I), (' . I)]"); + tstHelper("G'Im:'I", "[(G . 'Im:), (' . I)]"); + tstHelper("G'Im:'ANG'AM'I", "[(G . 'Im:), (' . A), (NG . 'A), (M . 'I)]"); // DLC FIXME: 'ANG'A is what? 'ANG-'A or 'A-NG'A? + + tstHelper("BA'AM", "[(B . A), (' . A), (M . )]"); + tstHelper("B'AM", "[(B . 'A), (M . )]"); + tstHelper("'AM'E", "[(' . A), (M . 'E)]"); + tstHelper("BA'AM'E", "[(B . A), (' . A), (M . 'E)]"); + tstHelper("BA'AM-'E", "[(B . A), (' . A), (M . -), (' . E)]"); + + tstHelper("TAA", "[(T . ), (A . A)]"); + tstHelper("DAA", "[(D . ), (A . A)]"); + tstHelper("DAAm", "[(D . ), (A . Am)]"); + tstHelper("DAAm:", "[(D . ), (A . Am:)]"); + tstHelper("DA'im:", "[(D . A), (' . im:)]"); + + tstHelper("NA+YA", "[(N . +), (Y . A)]"); + + tstHelper("'A", "[(' . A)]"); + tstHelper("'Am", "[(' . Am)]"); + tstHelper("'Am:", "[(' . Am:)]"); + tstHelper("''im:", "[(' . 'im:)]"); + tstHelper("D-'A", "[(D . -), (' . A)]"); + tstHelper("D-'Am", "[(D . -), (' . Am)]"); + tstHelper("D-'Am:", "[(D . -), (' . Am:)]"); + + // AMBIGUOUS really, but grepping for "[GDBM']'[AIEUO]" makes + // me think it's [(D . 'A)], which you'd hope it would be + // since A'A is an example in the ACIP docs. + // + // tstHelper("D'A", "[(D . 'A)]"); + // tstHelper("D'A", "[(D . ), (' . A)]"); + tstHelper("D'A", "[(D . 'A)]"); + tstHelper("D'Am", "[(D . 'Am)]"); + tstHelper("D'Am:", "[(D . 'Am:)]"); + + tstHelper("BA'I", "[(B . A), (' . I)]"); + tstHelper("DAVA", "[(D . A), (V . A)]"); + tstHelper("D-VA", "[(D . -), (V . A)]"); + tstHelper("DVA", "[(D . ), (V . A)]"); + tstHelper("BA'AM", "[(B . A), (' . A), (M . )]"); + + + + tstHelper("AAA"); + + tstHelper("A+YA", "[(A . +), (Y . A)]"); // achen over ya + + tstHelper("D''im:", "[(D . ), (' . 'im:)]"); + + + + tstHelper("ssh"); + tstHelper("ssshsstqm"); + tstHelper("sh"); + tstHelper("D----Z"); + tstHelper("D++++Z"); + tstHelper("shA"); + tstHelper("SHA", "[(SH . A)]"); + tstHelper("TSHA", "[(TS . ), (H . A)]"); + tstHelper("TS-HA", "[(TS . -), (H . A)]"); + tstHelper("TSE-HA", "[(TS . E), ( . -), (H . A)]"); + tstHelper("TSEHA", "[(TS . E), (H . A)]"); + tstHelper("s"); + tstHelper("T+ZA", "[(T . +), (Z . A)]"); + tstHelper("shTZNGN", "[(sh . ), (TZ . ), (NG . ), (N . )]"); + tstHelper("shTZNAGN", "[(sh . ), (TZ . ), (N . A), (G . ), (N . )]"); + tstHelper("KAm", "[(K . Am)]"); + tstHelper("shT-ZNAGN", "[(sh . ), (T . -), (Z . ), (N . A), (G . ), (N . )]"); + tstHelper("shT+ZNAGN", "[(sh . ), (T . +), (Z . ), (N . A), (G . ), (N . )]"); + + tstHelper("TYA-''I"); // from KD0095M.ACT + tstHelper("A-DZU"); + tstHelper("MNYA-DZU"); + + System.out.println("\n\n\ntsting a bunch of tsheg bars I yanked from the kangyur:\n\n"); +tstHelper("'"); +tstHelper("A"); +tstHelper("'A"); +tstHelper("A'"); +tstHelper("AA"); +tstHelper("A'A"); +tstHelper("AAD"); +tstHelper("AAG"); +tstHelper("AA'I"); +tstHelper("AA-KshA"); +tstHelper("AA-Ksh'A"); +tstHelper("AA-KshI"); +tstHelper("AAm"); +tstHelper("AAN"); +tstHelper("AANG"); +tstHelper("AANG-GA'I"); +tstHelper("AAR"); +tstHelper("AARDZA"); +tstHelper("AARDZU"); +tstHelper("AARTHA"); +tstHelper("AARYA"); +tstHelper("A'ARYA"); +tstHelper("A'A-RYA"); +tstHelper("AAS"); +tstHelper("AA-ttA"); +tstHelper("'AD"); +tstHelper("AE"); +tstHelper("AEE"); +tstHelper("AER"); +tstHelper("AG"); +tstHelper("Ai"); +tstHelper("AI"); +tstHelper("'A'I"); +tstHelper("A'I"); +tstHelper("AINDRA"); +tstHelper("AIN-DRA"); +tstHelper("AI-ttI"); +tstHelper("Am"); +tstHelper("'AM"); +tstHelper("ANDA"); +tstHelper("ANG"); +tstHelper("'ANG"); +tstHelper("'ANGS"); +tstHelper("AO"); +tstHelper("AOm"); +tstHelper("AOM"); +tstHelper("AOO"); +tstHelper("A'RYA"); +tstHelper("AshtA"); +tstHelper("AU"); +tstHelper("A'U"); +tstHelper("AUD"); +tstHelper("AUG"); +tstHelper("AU-KKE"); +tstHelper("AUshnI"); +tstHelper("AU-TAP"); +tstHelper("AUTAPA"); +tstHelper("AUT-KA"); +tstHelper("AU-TKU"); +tstHelper("AUTP"); +tstHelper("AUTPA"); +tstHelper("AU-TPA"); +tstHelper("AUT-PA"); +tstHelper("AUTPAL"); +tstHelper("AUT-PAL"); +tstHelper("AUTPALA"); +tstHelper("'B"); +tstHelper("Ba"); +tstHelper("BA"); +tstHelper("'BA"); +tstHelper("'BA'"); +tstHelper("B'A"); +tstHelper("BA'"); +tstHelper("BA'AM"); +tstHelper("BA'ANG"); +tstHelper("BAB"); +tstHelper("'BAB"); +tstHelper("BABS"); +tstHelper("'BABS"); +tstHelper("BAD"); +tstHelper("'BAD"); +tstHelper("BADG"); +tstHelper("BADZRA"); +tstHelper("BADZRA'I"); +tstHelper("BADZRAS"); +tstHelper("BADZRO"); +tstHelper("BAG"); +tstHelper("BAGS"); +tstHelper("'BAGS"); +tstHelper("'BA'I"); +tstHelper("B'AI"); +tstHelper("B'A'I"); +tstHelper("BA'I"); +tstHelper("BA'I'O"); +tstHelper("BA'ISKYE"); +tstHelper("BAKKU"); +tstHelper("BAL"); +tstHelper("'BAL"); +tstHelper("BAm"); +tstHelper("BAM"); +tstHelper("'BAM"); +tstHelper("BAN"); +tstHelper("BAndE"); +tstHelper("BANDE"); +tstHelper("BANDHE"); +tstHelper("BAndI"); +tstHelper("BANDI"); +tstHelper("BANDRA"); +tstHelper("BANDRE"); +tstHelper("BANG"); +tstHelper("'BANG"); +tstHelper("B'ANG"); +tstHelper("BANGS"); +tstHelper("'BANGS"); +tstHelper("BA'O"); +tstHelper("BA'OBLO"); +tstHelper("BAOM"); +tstHelper("BAR"); +tstHelper("'BAR"); +tstHelper("BARMA"); +tstHelper("BARnA'I"); +tstHelper("BARSHA"); +tstHelper("BAR-SHI"); +tstHelper("BAS"); +tstHelper("BASD"); +tstHelper("BASM"); +tstHelper("BATA+SA'I"); +tstHelper("BAUNG"); +tstHelper("BBANG"); +tstHelper("BBAS"); +tstHelper("BBLAN"); +tstHelper("BBYID"); +tstHelper("BCA"); +tstHelper("BCA'"); +tstHelper("BCAB"); +tstHelper("BCABS"); +tstHelper("BCAD"); +tstHelper("BCAG"); +tstHelper("BCAGS"); +tstHelper("BCAL"); +tstHelper("BCAN"); +tstHelper("BCANG"); +tstHelper("BCANGS"); +tstHelper("BCA'O"); +tstHelper("BCAR"); +tstHelper("BCAS"); +tstHelper("BCCO"); +tstHelper("BCED"); +tstHelper("BCER"); +tstHelper("BCES"); +tstHelper("BCHAD"); +tstHelper("BCHANG"); +tstHelper("BCHES"); +tstHelper("BCHI"); +tstHelper("BCHIS"); +tstHelper("BCHOD"); +tstHelper("BCI"); +tstHelper("BCIBS"); +tstHelper("BCIL"); +tstHelper("BCING"); +tstHelper("BCINGS"); +tstHelper("BCIR"); +tstHelper("BCIS"); +tstHelper("BCO"); +tstHelper("BCOD"); +tstHelper("BCOL"); +tstHelper("BCOM"); +tstHelper("BCOMN"); +tstHelper("BCON"); +tstHelper("BCONGS"); +tstHelper("BCOS"); +tstHelper("BCU"); +tstHelper("BCU'AM"); +tstHelper("BCU'ANG"); +tstHelper("BCUD"); +tstHelper("BCUG"); +tstHelper("BCUGS"); +tstHelper("BCU'I"); +tstHelper("BCUM"); +tstHelper("BCUN"); +tstHelper("BCUNG"); +tstHelper("BCU'O"); +tstHelper("BCUR"); +tstHelper("BCUS"); +tstHelper("BCVA"); +tstHelper("BCVO"); +tstHelper("BCWA"); +tstHelper("BCWO"); +tstHelper("BDA"); +tstHelper("BDA'"); +tstHelper("BDAG"); +tstHelper("BDAGS"); +tstHelper("BDAL"); +tstHelper("BDAM"); +tstHelper("BDAMS"); +tstHelper("BDAN"); +tstHelper("BDA'O"); +tstHelper("BDAR"); +tstHelper("BDAS"); +tstHelper("BDE"); +tstHelper("BDE'AM"); +tstHelper("BDEB"); +tstHelper("BDEGS"); +tstHelper("BDE'I"); +tstHelper("BDEN"); +tstHelper("BDE'O"); +tstHelper("BDER"); +tstHelper("BDES"); +tstHelper("BDO"); +tstHelper("BDOG"); +tstHelper("BDO'I"); +tstHelper("BDON"); +tstHelper("BDRAL"); +tstHelper("BDROL"); +tstHelper("BDRUG"); +tstHelper("BDU"); +tstHelper("BDUD"); +tstHelper("BDUG"); +tstHelper("BDUGS"); +tstHelper("BDUN"); +tstHelper("BDUNG"); +tstHelper("BDUNGS"); +tstHelper("BDUS"); +tstHelper("BDZAG"); +tstHelper("BDZAM"); +tstHelper("BDZES"); +tstHelper("Be"); +tstHelper("BE"); +tstHelper("'BEB"); +tstHelper("'BEBS"); +tstHelper("BED"); +tstHelper("BEE"); +tstHelper("BEE-d'U"); +tstHelper("BEED'U"); +tstHelper("BEE-d'U-RYA"); +tstHelper("BEEd'URYA"); +tstHelper("BEED'URYA"); +tstHelper("BEEd'URYA'I"); +tstHelper("BEED'URYA'I"); +tstHelper("BEEK'U"); +tstHelper("BEGS"); +tstHelper("BE'I"); +tstHelper("'BEL"); +tstHelper("BEM"); +tstHelper("BEMS"); +tstHelper("'BEN"); +tstHelper("BENDE"); +tstHelper("BENDHA"); +tstHelper("BER"); +tstHelper("BE'U"); +tstHelper("BE'US"); +tstHelper("BGA"); +tstHelper("BGAD"); +tstHelper("BGAG"); +tstHelper("BGAGS"); +tstHelper("BGAM"); +tstHelper("BGAS"); +tstHelper("BGED"); +tstHelper("BGEGS"); +tstHelper("BGO"); +tstHelper("BGOD"); +tstHelper("BGOMS"); +tstHelper("BGONG"); +tstHelper("BGO'O"); +tstHelper("BGOR"); +tstHelper("BGOS"); +tstHelper("BGRA"); +tstHelper("BGRAD"); +tstHelper("BGRANG"); +tstHelper("BGRANGS"); +tstHelper("BGRES"); +tstHelper("BGRO"); +tstHelper("BGROD"); +tstHelper("BGROGS"); +tstHelper("BGROL"); +tstHelper("BGRONG"); +tstHelper("BGRONGS"); +tstHelper("BGROS"); +tstHelper("BGSAS"); +tstHelper("BGU"); +tstHelper("BGYA"); +tstHelper("BGYAD"); +tstHelper("BGYA'O"); +tstHelper("BGYAS"); +tstHelper("BGYED"); +tstHelper("BGYEN"); +tstHelper("BGYI"); +tstHelper("BGYI'AM"); +tstHelper("BGYI'ANG"); +tstHelper("BGYIB"); +tstHelper("BGYID"); +tstHelper("BGYI'I"); +tstHelper("BGYIN"); +tstHelper("BGYING"); +tstHelper("BGYINGS"); +tstHelper("BGYI'O"); +tstHelper("BGYIR"); +tstHelper("BGYIS"); +tstHelper("BGYUR"); +tstHelper("BHA"); +tstHelper("BH'A"); +tstHelper("BHADRA"); +tstHelper("BHADRE"); +tstHelper("BHAN"); +tstHelper("BHANG"); +tstHelper("BHAR"); +tstHelper("BHE"); +tstHelper("BHEN"); +tstHelper("BHI"); +tstHelper("BHIN"); +tstHelper("BHING"); +tstHelper("BHO"); +tstHelper("BHOD"); +tstHelper("BHOtA'I"); +tstHelper("BHRiNG"); +tstHelper("BHRING"); +tstHelper("BHU"); +tstHelper("BH'U"); +tstHelper("BHYA-NTA"); +tstHelper("BHYU"); +tstHelper("BI"); +tstHelper("B'I"); +tstHelper("BID"); +tstHelper("BIDYA"); +tstHelper("BIDY'A"); +tstHelper("'BIGS"); +tstHelper("B'I'I"); +tstHelper("BI'I"); +tstHelper("BIL"); +tstHelper("BIM"); +tstHelper("BI-MBA"); +tstHelper("BIM-PA"); +tstHelper("BIM-PA"); +tstHelper("BIM-PA'I"); +tstHelper("BIN"); +tstHelper("BINGSHA"); +tstHelper("BIR"); +tstHelper("B'IR"); +tstHelper("BIR'A"); +tstHelper("BIS"); +tstHelper("BI-shtE"); +tstHelper("BI-ttI"); +tstHelper("BKA'"); +tstHelper("BKAB"); +tstHelper("BKAD"); +tstHelper("BKAG"); +tstHelper("BKA'I"); +tstHelper("BKAL"); +tstHelper("BKALG"); +tstHelper("BKANG"); +tstHelper("BKANGS"); +tstHelper("BKA'O"); +tstHelper("BKAR"); +tstHelper("BKAS"); +tstHelper("BKED"); +tstHelper("BKHYU"); +tstHelper("BKLAG"); +tstHelper("BKLAGS"); +tstHelper("BKLOG"); +tstHelper("BKLUBS"); +tstHelper("BKOD"); +tstHelper("BKOGS"); +tstHelper("BKOL"); +tstHelper("BKONG"); +tstHelper("BKRA"); +tstHelper("BKRA'AM"); +tstHelper("BKRABS"); +tstHelper("BKRAL"); +tstHelper("BKRAM"); +tstHelper("BKRE"); +tstHelper("BKREN"); +tstHelper("BKRENG"); +tstHelper("BKRES"); +tstHelper("BKRI"); +tstHelper("BKRI'I"); +tstHelper("BKRI'O"); +tstHelper("BKRIR"); +tstHelper("BKRIS"); +tstHelper("BKROL"); +tstHelper("BKRONGS"); +tstHelper("BKRU"); +tstHelper("BKRU'O"); +tstHelper("BKRUR"); +tstHelper("BKRUS"); +tstHelper("BKU"); +tstHelper("BKUG"); +tstHelper("BKUM"); +tstHelper("BKUR"); +tstHelper("BKUS"); +tstHelper("BKYE"); +tstHelper("BKYED"); +tstHelper("BKYE'O"); +tstHelper("BKYI"); +tstHelper("BKYID"); +tstHelper("BKYON"); +tstHelper("BLA"); +tstHelper("BLAB"); +tstHelper("BLAD"); +tstHelper("BLAG"); +tstHelper("BLAGS"); +tstHelper("BLA'I"); +tstHelper("BLAM"); +tstHelper("BLAN"); +tstHelper("BLANG"); +tstHelper("BLANGS"); +tstHelper("BLA'O"); +tstHelper("BLAS"); +tstHelper("BLCAG"); +tstHelper("BLDAG"); +tstHelper("BLDAGS"); +tstHelper("BLINGS"); +tstHelper("BLNGA"); +tstHelper("BLO"); +tstHelper("BLO'ANG"); +tstHelper("BLO'I"); +tstHelper("BLON"); +tstHelper("BLONG"); +tstHelper("BLO'O"); +tstHelper("BLOR"); +tstHelper("BLOS"); +tstHelper("BLTA"); +tstHelper("BLTA'AM"); +tstHelper("BLTAB"); +tstHelper("BLTAM"); +tstHelper("BLTAMS"); +tstHelper("BLTAN"); +tstHelper("BLTA'O"); +tstHelper("BLTAR"); +tstHelper("BLTAS"); +tstHelper("BLTOS"); +tstHelper("BLTUNG"); +tstHelper("BLUD"); +tstHelper("BLUGS"); +tstHelper("BLUN"); +tstHelper("BLUNG"); +tstHelper("BLUS"); +tstHelper("BNA"); +tstHelper("BNGAN"); +tstHelper("BNGAS"); +tstHelper("BNGO'O"); +tstHelper("BNYAMS"); +tstHelper("BNYEN"); +tstHelper("BNYID"); +tstHelper("BO"); +tstHelper("'BO"); +tstHelper("BO"); +tstHelper("BO'AM"); +tstHelper("BO'ANG"); +tstHelper("BOBS"); +tstHelper("BOCM"); +tstHelper("BOD"); +tstHelper("'BOD"); +tstHelper("BODE"); +tstHelper("BODHI"); +tstHelper("BOG"); +tstHelper("'BOG"); +tstHelper("'BOGS"); +tstHelper("BO'I"); +tstHelper("BOL"); +tstHelper("BOM"); +tstHelper("BON"); +tstHelper("BONG"); +tstHelper("'BONG"); +tstHelper("BO'O"); +tstHelper("BOR"); +tstHelper("'BOR"); +tstHelper("BOS"); +tstHelper("BP"); +tstHelper("BPA"); +tstHelper("BRA"); +tstHelper("'BRA"); +tstHelper("BRAD"); +tstHelper("'BRAD"); +tstHelper("BRAG"); +tstHelper("BRAGS"); +tstHelper("BRAL"); +tstHelper("'BRAL"); +tstHelper("BRAM"); +tstHelper("'BRAM"); +tstHelper("BRAN"); +tstHelper("BRANG"); +tstHelper("'BRANG"); +tstHelper("'BRANGS"); +tstHelper("'BRAS"); +tstHelper("BRDA"); +tstHelper("BRDAB"); +tstHelper("BRDABS"); +tstHelper("BRDAG"); +tstHelper("BRDA'I"); +tstHelper("BRDAL"); +tstHelper("BRDAR"); +tstHelper("BRDAS"); +tstHelper("BRDEG"); +tstHelper("BRDEGS"); +tstHelper("BRDOD"); +tstHelper("BRDOL"); +tstHelper("BRDOS"); +tstHelper("BRDUB"); +tstHelper("BRDUBS"); +tstHelper("BRDUNG"); +tstHelper("BRDUNGS"); +tstHelper("BRDZAGS"); +tstHelper("BRDZANG"); +tstHelper("BRDZANGS"); +tstHelper("BRDZEN"); +tstHelper("BRDZES"); +tstHelper("BRDZI"); +tstHelper("BRDZIN"); +tstHelper("BRDZIS"); +tstHelper("BRDZOD"); +tstHelper("BRDZOGS"); +tstHelper("BRDZON"); +tstHelper("BRDZUN"); +tstHelper("BRDZUS"); +tstHelper("BRE"); +tstHelper("'BRE"); +tstHelper("BRED"); +tstHelper("'BRED"); +tstHelper("BREG"); +tstHelper("'BREG"); +tstHelper("BREGS"); +tstHelper("'BREGS"); +tstHelper("BRE'I"); +tstHelper("BREL"); +tstHelper("'BREL"); +tstHelper("BRENG"); +tstHelper("'BRENG"); +tstHelper("'BRENGS"); +tstHelper("BRER"); +tstHelper("BRES"); +tstHelper("'BRES"); +tstHelper("BRE'U"); +tstHelper("BRGA"); +tstHelper("BRGAL"); +tstHelper("BRGAN"); +tstHelper("BRGYA"); +tstHelper("BRGYA'"); +tstHelper("BRGYA'AM"); +tstHelper("BRGYA'ANG"); +tstHelper("BRGYAB"); +tstHelper("BRGYAD"); +tstHelper("BRGYAGS"); +tstHelper("BRGYA'I"); +tstHelper("BRGYAL"); +tstHelper("BRGYAN"); +tstHelper("BRGYANG"); +tstHelper("BRGYANGS"); +tstHelper("BRGYA'O"); +tstHelper("BRGYAR"); +tstHelper("BRGYAS"); +tstHelper("BRGYI"); +tstHelper("BRGYU"); +tstHelper("BRGYUD"); +tstHelper("BRGYUG"); +tstHelper("BRGYUGS"); +tstHelper("BRGYUR"); +tstHelper("BRGYUS"); +tstHelper("BRi"); +tstHelper("BRI"); +tstHelper("'BRI"); +tstHelper("BRIB"); +tstHelper("BRID"); +tstHelper("'BRID"); +tstHelper("BRIL"); +tstHelper("BRIM"); +tstHelper("'BRIM"); +tstHelper("BRIMS"); +tstHelper("'BRIN"); +tstHelper("BRING"); +tstHelper("'BRING"); +tstHelper("'BRI'O"); +tstHelper("BRIR"); +tstHelper("'BRIR"); +tstHelper("BRIS"); +tstHelper("BRiTTA"); +tstHelper("BRJE"); +tstHelper("BRJED"); +tstHelper("BRJES"); +tstHelper("BRJID"); +tstHelper("BRJING"); +tstHelper("BRJOD"); +tstHelper("BRJOS"); +tstHelper("BRKAM"); +tstHelper("BRKO"); +tstHelper("BRKOR"); +tstHelper("BRKOS"); +tstHelper("BRKU"); +tstHelper("BRKUS"); +tstHelper("BRKYAL"); +tstHelper("BRKYANG"); +tstHelper("BRKYANGS"); +tstHelper("BRLA"); +tstHelper("BRLAB"); +tstHelper("BRLABS"); +tstHelper("BRLAG"); +tstHelper("BRLAGS"); +tstHelper("BRLA'I"); +tstHelper("BRLAM"); +tstHelper("BRLAN"); +tstHelper("BRLANG"); +tstHelper("BRLANGS"); +tstHelper("BRLAR"); +tstHelper("BRLAS"); +tstHelper("BRNAB"); +tstHelper("BRNAG"); +tstHelper("BRNAGS"); +tstHelper("BRNAL"); +tstHelper("BRNAMS"); +tstHelper("BRNAN"); +tstHelper("BRNANGS"); +tstHelper("BRNGA"); +tstHelper("BRNGABS"); +tstHelper("BRNGAM"); +tstHelper("BRNGAR"); +tstHelper("BRNGAS"); +tstHelper("BRNGOD"); +tstHelper("BRNYA"); +tstHelper("BRNYAN"); +tstHelper("BRNYAS"); +tstHelper("BRNYED"); +tstHelper("BRNYEN"); +tstHelper("BRNYES"); +tstHelper("BRNYIL"); +tstHelper("BRNYIS"); +tstHelper("BRNYOGS"); +tstHelper("BRO"); +tstHelper("'BRO"); +tstHelper("BROD"); +tstHelper("'BROD"); +tstHelper("'BROG"); +tstHelper("'BROM"); +tstHelper("BRONGS"); +tstHelper("'BRONGS"); +tstHelper("BROR"); +tstHelper("BROS"); +tstHelper("'BROS"); +tstHelper("BRTA"); +tstHelper("BRTABS"); +tstHelper("BRTAD"); +tstHelper("BRTAG"); +tstHelper("BRTAGS"); +tstHelper("BRTAN"); +tstHelper("BRTAR"); +tstHelper("BRTAS"); +tstHelper("BRTEG"); +tstHelper("BRTEN"); +tstHelper("BRTIB"); +tstHelper("BRTN"); +tstHelper("BRTOD"); +tstHelper("BRTOG"); +tstHelper("BRTOL"); +tstHelper("BRTON"); +tstHelper("BRTUL"); +tstHelper("BRTUN"); +tstHelper("BRTZA"); +tstHelper("BRTZAD"); +tstHelper("BRTZAL"); +tstHelper("BRTZAM"); +tstHelper("BRTZAMS"); +tstHelper("BRTZAN"); +tstHelper("BRTZE"); +tstHelper("BRTZEG"); +tstHelper("BRTZEGS"); +tstHelper("BRTZE'I"); +tstHelper("BRTZEN"); +tstHelper("BRTZER"); +tstHelper("BRTZES"); +tstHelper("BRTZI"); +tstHelper("BRTZIG"); +tstHelper("BRTZIGS"); +tstHelper("BRTZI'O"); +tstHelper("BRTZIR"); +tstHelper("BRTZIS"); +tstHelper("BRTZNL"); +tstHelper("BRTZOD"); +tstHelper("BRTZOM"); +tstHelper("BRTZON"); +tstHelper("BRTZONG"); +tstHelper("BRTZONGS"); +tstHelper("BRTZUB"); +tstHelper("BRTZUGS"); +tstHelper("BRTZUN"); +tstHelper("BRTZWA"); +tstHelper("BRU"); +tstHelper("'BRU"); +tstHelper("'BRU'AM"); +tstHelper("BRUBS"); +tstHelper("BRUD"); +tstHelper("BRUG"); +tstHelper("'BRUG"); +tstHelper("'BRU'I"); +tstHelper("BRUL"); +tstHelper("'BRUL"); +tstHelper("'BRUM"); +tstHelper("BRUN"); +tstHelper("BRUNG"); +tstHelper("BRUNGS"); +tstHelper("BRU'O"); +tstHelper("'BRUR"); +tstHelper("BRUS"); +tstHelper("'BRUS"); +tstHelper("BSA"); +tstHelper("BSAB"); +tstHelper("BSABS"); +tstHelper("BSAD"); +tstHelper("BSAG"); +tstHelper("BSAGS"); +tstHelper("BSAL"); +tstHelper("BSAM"); +tstHelper("BSAMS"); +tstHelper("BSAN"); +tstHelper("BSANG"); +tstHelper("BSANGS"); +tstHelper("BSAR"); +tstHelper("BSBU"); +tstHelper("BSDAD"); +tstHelper("BSDAGS"); +tstHelper("BSDAL"); +tstHelper("BSDAM"); +tstHelper("BSDAMS"); +tstHelper("BSDEB"); +tstHelper("BSDEBS"); +tstHelper("BSDIG"); +tstHelper("BSDIGS"); +tstHelper("BSDO"); +tstHelper("BSDOD"); +tstHelper("BSDOGS"); +tstHelper("BSDOMS"); +tstHelper("BSDON"); +tstHelper("BSDONG"); +tstHelper("BSDONGS"); +tstHelper("BSDO'O"); +tstHelper("BSDOS"); +tstHelper("BSDU"); +tstHelper("BSDUG"); +tstHelper("BSDUM"); +tstHelper("BSDUMS"); +tstHelper("BSDUN"); +tstHelper("BSDUS"); +tstHelper("BSE"); +tstHelper("BSEGS"); +tstHelper("BSEL"); +tstHelper("BSENG"); +tstHelper("BSER"); +tstHelper("BSGAL"); +tstHelper("BSGEGS"); +tstHelper("BSGO"); +tstHelper("BSGO'AM"); +tstHelper("BSGOM"); +tstHelper("BSGOMS"); +tstHelper("BSGONGS"); +tstHelper("BSGO'O"); +tstHelper("BSGOS"); +tstHelper("BSGRAB"); +tstHelper("BSGRAG"); +tstHelper("BSGRAGS"); +tstHelper("BSGRAL"); +tstHelper("BSGRE"); +tstHelper("BSGRENG"); +tstHelper("BSGRENGS"); +tstHelper("BSGRES"); +tstHelper("BSGRIB"); +tstHelper("BSGRIBS"); +tstHelper("BSGRIGS"); +tstHelper("BSGRIM"); +tstHelper("BSGRIMS"); +tstHelper("BSGRIN"); +tstHelper("BSGROM"); +tstHelper("BSGRON"); +tstHelper("BSGRUB"); +tstHelper("BSGRUBS"); +tstHelper("BSGRUL"); +tstHelper("BSGRUN"); +tstHelper("BSGRUNGS"); +tstHelper("BSGRUR"); +tstHelper("BSGUB"); +tstHelper("BSGUGS"); +tstHelper("BSGUL"); +tstHelper("BSGYANG"); +tstHelper("BSGYANGS"); +tstHelper("BSGYEL"); +tstHelper("BSGYING"); +tstHelper("BSGYINGS"); +tstHelper("BSGYU"); +tstHelper("BSGYUBS"); +tstHelper("BSGYUR"); +tstHelper("BSHA"); +tstHelper("BSHA'"); +tstHelper("BSHAD"); +tstHelper("BSHAGS"); +tstHelper("BSHAL"); +tstHelper("BSHAM"); +tstHelper("BSHAMS"); +tstHelper("BSHAN"); +tstHelper("BSHANG"); +tstHelper("BSHAR"); +tstHelper("BSHAS"); +tstHelper("BSHEGS"); +tstHelper("BSHEN"); +tstHelper("BSHES"); +tstHelper("BSHIG"); +tstHelper("BSHIN"); +tstHelper("BSHOL"); +tstHelper("BSHOR"); +tstHelper("BSHOS"); +tstHelper("BSHUL"); +tstHelper("BSHUM"); +tstHelper("BSHUMS"); +tstHelper("BSHUNG"); +tstHelper("BSHUS"); +tstHelper("BSIL"); +tstHelper("BSKA"); +tstHelper("BSKA'"); +tstHelper("BSKAB"); +tstHelper("BSKAL"); +tstHelper("BSKAM"); +tstHelper("BSKAMS"); +tstHelper("BSKANG"); +tstHelper("BSKANGS"); +tstHelper("BSKAR"); +tstHelper("BSKED"); +tstHelper("BSKO"); +tstHelper("BSKOD"); +tstHelper("BSKOL"); +tstHelper("BSKOMS"); +tstHelper("BSKON"); +tstHelper("BSKONGS"); +tstHelper("BSKO'O"); +tstHelper("BSKOR"); +tstHelper("BSKOS"); +tstHelper("BSKRAD"); +tstHelper("BSKRAG"); +tstHelper("BSKRAL"); +tstHelper("BSKRANG"); +tstHelper("BSKRIN"); +tstHelper("BSKROGS"); +tstHelper("BSKRU"); +tstHelper("BSKRUL"); +tstHelper("BSKRUN"); +tstHelper("BSKU"); +tstHelper("BSKUL"); +tstHelper("BSKUM"); +tstHelper("BSKUMS"); +tstHelper("BSKU'O"); +tstHelper("BSKUR"); +tstHelper("BSKUS"); +tstHelper("BSKYAB"); +tstHelper("BSKYABS"); +tstHelper("BSKYAD"); +tstHelper("BSKYAL"); +tstHelper("BSKYANG"); +tstHelper("BSKYAS"); +tstHelper("BSKYE"); +tstHelper("BSKYED"); +tstHelper("BSKYEL"); +tstHelper("BSKYENG"); +tstHelper("BSKYES"); +tstHelper("BSKYID"); +tstHelper("BSKYIL"); +tstHelper("BSKYOD"); +tstHelper("BSKYOM"); +tstHelper("BSKYON"); +tstHelper("BSKYONG"); +tstHelper("BSKYUD"); +tstHelper("BSKYUG"); +tstHelper("BSKYUNG"); +tstHelper("BSKYUNGS"); +tstHelper("BSKYUR"); +tstHelper("BSLA"); +tstHelper("BSLAB"); +tstHelper("BSLABS"); +tstHelper("BSLAD"); +tstHelper("BSLANG"); +tstHelper("BSLANGS"); +tstHelper("BSLAR"); +tstHelper("BSLENGS"); +tstHelper("BSLONG"); +tstHelper("BSLONGS"); +tstHelper("BSLU"); +tstHelper("BSLU'O"); +tstHelper("BSLUS"); +tstHelper("BSMAS"); +tstHelper("BSMRA"); +tstHelper("BSNAM"); +tstHelper("BSNAMS"); +tstHelper("BSNAN"); +tstHelper("BSNANG"); +tstHelper("BSNGA"); +tstHelper("BSNGAD"); +tstHelper("BSNGAGS"); +tstHelper("BSNGAL"); +tstHelper("BSNGAM"); +tstHelper("BSNGAMS"); +tstHelper("BSNGAS"); +tstHelper("BSNGO"); +tstHelper("BSNGO'AM"); +tstHelper("BSNGO'ANG"); +tstHelper("BSNGOD"); +tstHelper("BSNGOGS"); +tstHelper("BSNGOMS"); +tstHelper("BSNGON"); +tstHelper("BSNGO'O"); +tstHelper("BSNGOR"); +tstHelper("BSNGOS"); +tstHelper("BSNOL"); +tstHelper("BSNOR"); +tstHelper("BSNUN"); +tstHelper("BSNUR"); +tstHelper("BSNYAD"); +tstHelper("BSNYAGS"); +tstHelper("BSNYAL"); +tstHelper("BSNYAMS"); +tstHelper("BSNYAN"); +tstHelper("BSNYED"); +tstHelper("BSNYEG"); +tstHelper("BSNYEGS"); +tstHelper("BSNYEL"); +tstHelper("BSNYEMS"); +tstHelper("BSNYEN"); +tstHelper("BSNYENGS"); +tstHelper("BSNYER"); +tstHelper("BSNYES"); +tstHelper("BSNYIL"); +tstHelper("BSNYINGS"); +tstHelper("BSNYOD"); +tstHelper("BSNYOGS"); +tstHelper("BSNYON"); +tstHelper("BSNYUN"); +tstHelper("BSNYUNG"); +tstHelper("BSNYUNGS"); +tstHelper("BSO"); +tstHelper("BSOD"); +tstHelper("BSOGS"); +tstHelper("BSOL"); +tstHelper("BSONG"); +tstHelper("BSOS"); +tstHelper("BSPOBS"); +tstHelper("BSPYAD"); +tstHelper("BSRABS"); +tstHelper("BSRAD"); +tstHelper("BSRANG"); +tstHelper("BSRE"); +tstHelper("BSREG"); +tstHelper("BSREGS"); +tstHelper("BSREL"); +tstHelper("BSRES"); +tstHelper("BSRI"); +tstHelper("BSRID"); +tstHelper("BSRING"); +tstHelper("BSRINGS"); +tstHelper("BSRI'O"); +tstHelper("BSRO"); +tstHelper("BSROG"); +tstHelper("BSROS"); +tstHelper("BSRUBS"); +tstHelper("BSRUNG"); +tstHelper("BSRUNGS"); +tstHelper("BSTA"); +tstHelper("BSTAB"); +tstHelper("BSTABS"); +tstHelper("BSTAD"); +tstHelper("BSTAN"); +tstHelper("BSTANG"); +tstHelper("BSTANGS"); +tstHelper("BSTAR"); +tstHelper("BSTAS"); +tstHelper("BSTE"); +tstHelper("BSTED"); +tstHelper("BSTEN"); +tstHelper("BSTENG"); +tstHelper("BSTI"); +tstHelper("BSTING"); +tstHelper("BSTOBS"); +tstHelper("BSTOD"); +tstHelper("BSTON"); +tstHelper("BSTONG"); +tstHelper("BSTU"); +tstHelper("BSTUD"); +tstHelper("BSTUN"); +tstHelper("BSTUNG"); +tstHelper("BSTUNGS"); +tstHelper("BSTZAGS"); +tstHelper("BSTZAL"); +tstHelper("BSTZOL"); +tstHelper("BSU"); +tstHelper("BSUN"); +tstHelper("BSUNG"); +tstHelper("BSU'O"); +tstHelper("BSUR"); +tstHelper("BSUS"); +tstHelper("BTA"); +tstHelper("BTA'"); +tstHelper("BTAB"); +tstHelper("BTABS"); +tstHelper("BTAD"); +tstHelper("BTAG"); +tstHelper("BTAGS"); +tstHelper("BTAMS"); +tstHelper("BTANG"); +tstHelper("BTANGS"); +tstHelper("BTA'O"); +tstHelper("BTAR"); +tstHelper("BTAS"); +tstHelper("BTEG"); +tstHelper("BTENG"); +tstHelper("BTHOB"); +tstHelper("BTING"); +tstHelper("BTOD"); +tstHelper("BTOGS"); +tstHelper("BTOL"); +tstHelper("BTON"); +tstHelper("BTONG"); +tstHelper("BTSAL"); +tstHelper("BTSAN"); +tstHelper("BTSANGS"); +tstHelper("BTSUN"); +tstHelper("BTU"); +tstHelper("BTUB"); +tstHelper("BTUD"); +tstHelper("BTU'I"); +tstHelper("BTUL"); +tstHelper("BTUNG"); +tstHelper("BTUS"); +tstHelper("BTZA'"); +tstHelper("BTZAD"); +tstHelper("BTZAG"); +tstHelper("BTZAGS"); +tstHelper("BTZAL"); +tstHelper("BTZAM"); +tstHelper("BTZAMS"); +tstHelper("BTZAN"); +tstHelper("BTZANG"); +tstHelper("BTZAR"); +tstHelper("BTZAS"); +tstHelper("BTZE"); +tstHelper("BTZEM"); +tstHelper("BTZEMS"); +tstHelper("BTZIR"); +tstHelper("BTZO"); +tstHelper("BTZOD"); +tstHelper("BTZOG"); +tstHelper("BTZOM"); +tstHelper("BTZON"); +tstHelper("BTZONG"); +tstHelper("BTZONGS"); +tstHelper("BTZO'O"); +tstHelper("BTZOS"); +tstHelper("BTZUD"); +tstHelper("BTZUG"); +tstHelper("BTZUGS"); +tstHelper("BTZUM"); +tstHelper("BTZUMS"); +tstHelper("BTZUN"); +tstHelper("BTZVA"); +tstHelper("BTZWA"); +tstHelper("BU"); +tstHelper("'BU"); +tstHelper("BU'"); +tstHelper("BU'AM"); +tstHelper("BU'ANG"); +tstHelper("BUB"); +tstHelper("'BUBS"); +tstHelper("BUD"); +tstHelper("'BUD"); +tstHelper("BU-DADHA"); +tstHelper("BUDDHA"); +tstHelper("BUDDH'A"); +tstHelper("BUG"); +tstHelper("'BUGS"); +tstHelper("'BU'I"); +tstHelper("BU'I"); +tstHelper("BU'I'O"); +tstHelper("BUL"); +tstHelper("'BUL"); +tstHelper("BUm"); +tstHelper("BUM"); +tstHelper("'BUM"); +tstHelper("BU'MA"); +tstHelper("BUN"); +tstHelper("BUNG"); +tstHelper("BUNGS"); +tstHelper("'BUNGS"); +tstHelper("BU'O"); +tstHelper("BUR"); +tstHelper("'BUR"); +tstHelper("BUS"); +tstHelper("'BUS"); +tstHelper("BYA"); +tstHelper("BYA'AM"); +tstHelper("BYA'ANG"); +tstHelper("BYAB"); +tstHelper("BYAD"); +tstHelper("BYA'I"); +tstHelper("BYAM"); +tstHelper("'BYAM"); +tstHelper("BYAMS"); +tstHelper("BYAN"); +tstHelper("BYANG"); +tstHelper("'BYANG"); +tstHelper("BYANGS"); +tstHelper("BYA'O"); +tstHelper("BYA'OSHES"); +tstHelper("BYAR"); +tstHelper("'BYAR"); +tstHelper("BYAS"); +tstHelper("BYE"); +tstHelper("'BYE"); +tstHelper("BYE'AM"); +tstHelper("BYEB"); +tstHelper("BYED"); +tstHelper("'BYED"); +tstHelper("'BYEL"); +tstHelper("BYEM"); +tstHelper("BYEMS"); +tstHelper("BYEN"); +tstHelper("'BYENG"); +tstHelper("BYER"); +tstHelper("'BYER"); +tstHelper("BYES"); +tstHelper("'BYES"); +tstHelper("BYE'U"); +tstHelper("BYI"); +tstHelper("'BYI"); +tstHelper("BYID"); +tstHelper("'BYID"); +tstHelper("BYIN"); +tstHelper("'BYIN"); +tstHelper("BYING"); +tstHelper("'BYING"); +tstHelper("BYINGS"); +tstHelper("BYIR"); +tstHelper("BYIS"); +tstHelper("BYI'U"); +tstHelper("BYO"); +tstHelper("'BYO"); +tstHelper("BYOD"); +tstHelper("BYOG"); +tstHelper("BYOL"); +tstHelper("'BYOL"); +tstHelper("BYON"); +tstHelper("'BYON"); +tstHelper("'BYONG"); +tstHelper("'BYOR"); +tstHelper("BYOS"); +tstHelper("BYU"); +tstHelper("BY'U"); +tstHelper("BYU'"); +tstHelper("BYUD"); +tstHelper("'BYUD"); +tstHelper("BYUG"); +tstHelper("'BYUG"); +tstHelper("BYUGS"); +tstHelper("BYUL"); +tstHelper("BYUMS"); +tstHelper("BYUN"); +tstHelper("BYUNB"); +tstHelper("BYUNG"); +tstHelper("'BYUNG"); +tstHelper("BYUNGS"); +tstHelper("BYUR"); +tstHelper("'BYUR"); +tstHelper("BZA'"); +tstHelper("BZAD"); +tstHelper("BZAG"); +tstHelper("BZA'I"); +tstHelper("BZAL"); +tstHelper("BZALS"); +tstHelper("BZANG"); +tstHelper("BZANGS"); +tstHelper("BZA'O"); +tstHelper("BZAR"); +tstHelper("BZAS"); +tstHelper("BZED"); +tstHelper("BZENG"); +tstHelper("BZENGS"); +tstHelper("BZHAB"); +tstHelper("BZHABS"); +tstHelper("BZHAD"); +tstHelper("BZHAG"); +tstHelper("BZHAL"); +tstHelper("BZHAM"); +tstHelper("BZHAMS"); +tstHelper("BZHAN"); +tstHelper("BZHAR"); +tstHelper("BZHAS"); +tstHelper("BZHE"); +tstHelper("BZHED"); +tstHelper("BZHEGS"); +tstHelper("BZHEN"); +tstHelper("BZHENGS"); +tstHelper("BZHES"); +tstHelper("BZHI"); +tstHelper("BZHI'AM"); +tstHelper("BZHI'ANG"); +tstHelper("BZHIB"); +tstHelper("BZHIBS"); +tstHelper("BZHIG"); +tstHelper("BZHIGS"); +tstHelper("BZHI'I"); +tstHelper("BZHIL"); +tstHelper("BZHI'MA"); +tstHelper("BZHIN"); +tstHelper("BZHING"); +tstHelper("BZHINGS"); +tstHelper("BZHINN"); +tstHelper("BZHI'O"); +tstHelper("BZHIR"); +tstHelper("BZHIS"); +tstHelper("BZHO"); +tstHelper("BZHOG"); +tstHelper("BZHON"); +tstHelper("BZHOS"); +tstHelper("BZHU"); +tstHelper("BZHUD"); +tstHelper("BZHUG"); +tstHelper("BZHUGS"); +tstHelper("BZHUNG"); +tstHelper("BZHUS"); +tstHelper("BZIN"); +tstHelper("BZLA"); +tstHelper("BZLA'O"); +tstHelper("BZLAR"); +tstHelper("BZLAS"); +tstHelper("BZLOG"); +tstHelper("BZLOGS"); +tstHelper("BZLUGS"); +tstHelper("BZLUM"); +tstHelper("BZLUMS"); +tstHelper("BZO"); +tstHelper("BZO'AM"); +tstHelper("BZOD"); +tstHelper("BZO'I"); +tstHelper("BZON"); +tstHelper("BZONG"); +tstHelper("BZOR"); +tstHelper("BZOS"); +tstHelper("BZUD"); +tstHelper("BZUGS"); +tstHelper("BZUNG"); +tstHelper("BZUNGS"); +tstHelper("BZUR"); +tstHelper("CA"); +tstHelper("CA'AM"); +tstHelper("CAD"); +tstHelper("'CAD"); +tstHelper("CAG"); +tstHelper("CAGS"); +tstHelper("CA'I"); +tstHelper("CAL"); +tstHelper("CAM"); +tstHelper("CAN"); +tstHelper("CANG"); +tstHelper("CAR"); +tstHelper("CARVED"); +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"); + + } +} diff --git a/source/org/thdl/tib/text/ttt/ParseIterator.java b/source/org/thdl/tib/text/ttt/ParseIterator.java new file mode 100644 index 0000000..66ebd99 --- /dev/null +++ b/source/org/thdl/tib/text/ttt/ParseIterator.java @@ -0,0 +1,100 @@ +/* +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 java.util.ListIterator; +import java.util.NoSuchElementException; +import java.util.ArrayList; + +/** An object that can iterate over an {@link #TParseTree}. + * + * @author David Chandler */ +class ParseIterator { + private ArrayList al = null; + private int sz; + private ListIterator[] iterators; + private boolean first = true; + private boolean hasNextParse = true; + /** Constructs a new ParseIterator that iterates over a list of + * TStackListLists. */ + ParseIterator(ArrayList al) { + this.al = al; + sz = al.size(); + iterators = new ListIterator[sz]; + hasNextParse = false; + for (int i = 0; i < sz; i++) { + iterators[i] = ((TStackListList)al.get(i)).listIterator(); + if (iterators[i].hasNext()) + hasNextParse = true; + } + } + + /** Returns true if and only if there is another parse + * available. */ + boolean hasNext() { + return hasNextParse; + } + + /** Returns the next available parse. */ + TStackList next() { + if (!hasNextParse) + throw new NoSuchElementException("no parses left"); + if (first) { + first = false; + TStackList x = new TStackList(); + for (int i = 0; i < sz; i++) { + TStackList nextSL = (TStackList)iterators[i].next(); + x.addAll(nextSL); + } + + // The next guy is found by taking the previous item of + // each iterator. + hasNextParse = false; + for (int i = sz - 1; i >= 0; i--) { + if (iterators[i].hasNext()) { + iterators[i].next(); + hasNextParse = true; + break; + } + } + return x; + } + + // Up the rightmost iterator you can. If you can, reset all + // guys to the right of it. If you can't, we're done. + TStackList x = new TStackList(sz); + hasNextParse = false; + for (int i = sz - 1; i >= 0; i--) { + TStackList prevSL = (TStackList)iterators[i].previous(); + x.addAll(0, prevSL); + iterators[i].next(); + if (!hasNextParse && iterators[i].hasNext()) { + hasNextParse = true; + iterators[i].next(); + // Reset all iterators to the right of i. + for (int j = i + 1; j < sz; j++) { + while (iterators[j].hasPrevious()) + iterators[j].previous(); + iterators[j].next(); + } + } + } + return x; + } +} diff --git a/source/org/thdl/tib/text/ttt/TPair.java b/source/org/thdl/tib/text/ttt/TPair.java new file mode 100644 index 0000000..065d14a --- /dev/null +++ b/source/org/thdl/tib/text/ttt/TPair.java @@ -0,0 +1,170 @@ +/* +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.ThdlDebug; + +/** An ordered pair used in ACIP-to-TMW conversion. The left side is + * the consonant or empty; the right side is the vowel, '+', or '-'. + * @author David Chandler */ +/* DLC BIG FIXME: make this package work for EWTS, not just ACIP. */ +class TPair { + /** The left side, or null if there is no left side. That is, the + * non-vowel, non-'m', non-':', non-'-', non-'+' guy. */ + private String l; + String getLeft() { + ThdlDebug.verify(!"".equals(l)); + return l; + } + + /** The right side. That is, the vowel, with 'm' or ':' "vowel" + * after it if appropriate, or "-" (disambiguator), or "+" + * (stacking), or null otherwise. */ + private String r; + String getRight() { + ThdlDebug.verify(!"".equals(r)); + return r; + } + + /** Constructs a new TPair with left side l and right side r. + * Use null or the empty string to represent an absence. */ + TPair(String l, String r) { + // Normalize: + if (null != l && l.equals("")) l = null; + if (null != r && r.equals("")) r = null; + + this.l = l; + this.r = r; + } + + /** Returns a nice String representation. Returns "(D . E)" for + * ACIP {DE}, e.g., and (l . r) in general. */ + public String toString() { + return "(" + + ((null == l) ? "" : l) + " . " + + ((null == r) ? "" : r) + ")"; + } + + /** Returns the number of ACIP characters that make up this + * TPair. */ + int size() { + return (((l == null) ? 0 : l.length()) + + ((r == null) ? 0 : r.length())); + } + + /** Returns an TPair that is like this one except that it is + * missing N characters. The characters are taken from r, the + * right side, first and from l, the left side, second. + * @throw IllegalArgumentException if N is out of range */ + TPair minusNRightmostACIPCharacters(int N) + throws IllegalArgumentException + { + int sz; + String newL = l, newR = r; + if (N > size()) + throw new IllegalArgumentException("Don't have that many to remove."); + if (N < 1) + throw new IllegalArgumentException("You should't call this if you don't want to remove any."); + if (null != r && (sz = r.length()) > 0) { + int min = Math.min(sz, N); + newR = r.substring(0, sz - min); + N -= min; + } + if (N > 0) { + sz = l.length(); + newL = l.substring(0, sz - N); + } + return new TPair(newL, newR); + } + + /** Returns true if and only if this is nonempty and is l, if + * present, is a legal ACIP consonant, and is r, if present, is a + * legal ACIP vowel. */ + boolean isLegal() { + if (size() < 1) + return false; + if (null != l && !ACIPRules.isConsonant(l)) + return false; + if (null != r && !ACIPRules.isVowel(l)) + return false; + return true; + } + + /** Returns true if and only if this pair could be a Tibetan + * prefix. */ + boolean isPrefix() { + return (null != l + && ((null == r || "".equals(r)) + || "-".equals(r) + || "A".equals(r)) // DLC though check for BASKYABS and warn because BSKYABS is more common + && ("'".equals(l) + || "M".equals(l) + || "B".equals(l) + || "D".equals(l) + || "G".equals(l))); + } + + /** Returns true if and only if this pair is merely a + * disambiguator. */ + boolean isDisambiguator() { + return ("-".equals(r) && getLeft() == null); + } + + /** Returns an TPair that is like this pair except that it has + * a "+" on the right if this pair is empty on the right and is + * empty on the right if this pair has a disambiguator (i.e., a + * '-') on the right. May return itself (but never mutates this + * instance). */ + TPair insideStack() { + if (null == getRight()) + return new TPair(getLeft(), "+"); + else if ("-".equals(getRight())) + return new TPair(getLeft(), null); + else + return this; + } + + /** Returns true if this pair contains a Tibetan number. */ + boolean isNumeric() { + char ch; + return (l != null && l.length() == 1 && (ch = l.charAt(0)) >= '0' && ch <= '9'); + } + + /** Returns the EWTS Wylie that corresponds to this pair. Untested. */ + String getWylie() { + String leftWylie = null; + if (getLeft() != null) { + leftWylie = ACIPRules.getWylieForACIPConsonant(getLeft()); + if (leftWylie == null) { + if (isNumeric()) + leftWylie = getLeft(); + } + } + String rightWylie = null; + if ("-".equals(getRight())) + rightWylie = "."; + else if ("+".equals(getRight())) + rightWylie = "+"; + else if (getRight() != null) + rightWylie = ACIPRules.getWylieForACIPVowel(getRight()); + if (null == leftWylie) leftWylie = ""; + if (null == rightWylie) rightWylie = ""; + return leftWylie + rightWylie; + } +} diff --git a/source/org/thdl/tib/text/ttt/TPairList.java b/source/org/thdl/tib/text/ttt/TPairList.java new file mode 100644 index 0000000..1b0dd23 --- /dev/null +++ b/source/org/thdl/tib/text/ttt/TPairList.java @@ -0,0 +1,579 @@ +/* +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.tib.text.TibetanMachineWeb; +import org.thdl.tib.text.TGCPair; +import org.thdl.util.ThdlDebug; + +import java.util.ArrayList; + +/** A list of {@link TPair TPairs}, typically corresponding to + * one tsheg bar. l' in the design doc is an TPairList. + * + * @author David Chandler */ +class TPairList { + /** FIXME: change me and see if performance improves. */ + private static final int INITIAL_SIZE = 1; + + /** a fast, non-thread-safe, random-access list implementation: */ + private ArrayList al; + + /** Creates a new list containing just p. */ + public TPairList(TPair p) { + al = new ArrayList(1); + add(p); + } + + /** Creates an empty list. */ + public TPairList() { + al = new ArrayList(INITIAL_SIZE); + } + + /** Creates an empty list with the capacity to hold N items. */ + public TPairList(int N) { + al = new ArrayList(N); + } + + /** Returns the ith pair in this list. */ + public TPair get(int i) { return (TPair)al.get(i); } + + /** Adds p to the end of this list. */ + public void add(TPair p) { + if (p == null || (p.getLeft() == null && p.getRight() == null)) + throw new IllegalArgumentException("p is weird"); + al.add(p); + } + + /** Prepends p to the current list of TPairs. */ + public void prepend(TPair p) { + al.add(0, p); + } + + /** Returns the number of TPairs in this list. */ + public int size() { return al.size(); } + + /** Returns a human-readable representation. + * @return something like [(R . ), (D . O)] */ + public String toString2() { + return al.toString(); + } + + /** Returns a human-readable representation like {G}{YA} or + * {G-}{YA}. */ + public String toString() { + int sz = size(); + StringBuffer b = new StringBuffer(); + for (int i = 0; i < sz; i++) { + b.append('{'); + if (null != get(i).getLeft()) + b.append(get(i).getLeft()); + if (null != get(i).getRight()) + b.append(get(i).getRight()); + b.append('}'); + } + return b.toString(); + } + + /** Returns the ACIP corresponding to this TPairList. It will + * be as ambiguous as the input. It may have more disambiguators + * than the original, such as in the case of the ACIP {1234}. */ + String recoverACIP() { + StringBuffer original = new StringBuffer(); + int sz = size(); + for (int i = 0; i < sz; i++) { + TPair p = get(i); + if (p.getLeft() != null) + original.append(p.getLeft()); + if (p.getRight() != null) + original.append(p.getRight()); + } + return original.toString(); + } + + /** Returns true if this list contains ( . ) or (A . ), + * which are two simple errors you encounter if you interpret DAA + * or TAA or DAI or DAE the wrong way. */ + boolean hasSimpleError() { + int sz = size(); + for (int i = 0; i < sz; i++) { + TPair p = get(i); + if ((null == p.getLeft() && !"-".equals(p.getRight())) + || ("A".equals(p.getLeft()) && null == p.getRight())) + return true; + } + return false; + } + +// DLC [THE FOLLOWIN... appears, so [#comment] or [comment] is possible. [BLANK PAGE] [MISSING PAGE] [FIRST] [SECOND] [DD1] [DD2] [46A.2] [THE ... [FOLLOWING... [PAGE ... [THESE ... @[7B] [SW: OK] [A FIRST... [ADDENDUM... [END ... [Additional [Some [Note [MISSING [DDD] [INCOMPLETE [LINE [DATA +// [A pair of ... which is part of the text! S0200A.ACE +// [D] is a correction, eh? + + +// DLC BDE 'BA' ZHIG RGYUN DU BSTEN, ,YENGS KYANG THUB NA [GNYEN PO,) +// 'BYONGS [BLO,) S0375M.ACT + + +// S0011N.ACT contains [SMON TSIG 'DI'I RTZOM MING MI GSAL,], why the brackets? IS all this really a correction? DLC? +// DLC: what are () for? + + /** Finds errors so simple that they can be detected without using + * the rules of Tibetan spelling (i.e., tsheg bar syntax). + * Returns an error message, or null if there is no error that + * you can find without the help of tsheg bar syntax rules. */ + // DLC RENAME + // DLC FIXME: 9BLTA is an error, numbers are all or nothing + String getACIPError() { + int sz = size(); + if (0 == sz) + return "Warning, empty tsheg bar found while converting from ACIP!"; + boolean first = true; + StringBuffer rv = null; + boolean mustBeEntirelyNumeric = get(0).isNumeric(); + for (int i = 0; i < sz; i++) { + TPair p = get(i); + if (mustBeEntirelyNumeric != p.isNumeric()) + return "Cannot convert ACIP " + recoverACIP() + " because it contains a number but also a non-number."; + + if ((i == 0 && "V".equals(p.getLeft())) + || (i > 0 && "V".equals(p.getLeft()) + && (null != get(i - 1).getRight() + && !"+".equals(get(i - 1).getRight())))) { + if (first) { + first = false; + rv = new StringBuffer("Cannot convert ACIP "); + rv.append(recoverACIP()); + rv.append(" because {V}, wa-zur, appears without being subscribed to a consonant."); + } else { + rv.append("; also, {V}, wa-zur, appears without being subscribed to a consonant"); + } + } else if ("A".equals(p.getLeft()) && (null == p.getRight() || "".equals(p.getRight()))) { + if (first) { + first = false; + rv = new StringBuffer("Cannot convert ACIP "); + rv.append(recoverACIP()); + rv.append(" because we would be required to assume that {A} is a consonant, when it is not clear if it is a consonant or a vowel."); + } else { + rv.append("; also, we would be required to assume that {A} is a consonant, when it is not clear if it is a consonant or a vowel."); + } + } else if ((null == p.getLeft() && !"-".equals(p.getRight())) + || (null != p.getLeft() + && !ACIPRules.isConsonant(p.getLeft()) + && !p.isNumeric())) { + if (first) { + first = false; + rv = new StringBuffer("Cannot convert ACIP "); + rv.append(recoverACIP()); + rv.append(" because "); + if (null == p.getLeft()) { + rv.append(p.getRight()); + rv.append(" is a \"vowel\" without an associated consonant"); + } else { + rv.append(p.getLeft()); + rv.append(" is not an ACIP consonant"); + } + } else { + if (null == p.getLeft()) { + rv.append("; also, "); + rv.append(p.getRight()); + rv.append(" is an ACIP \"vowel\" without an associated consonant"); + } else { + rv.append("; also, "); + rv.append(p.getLeft()); + rv.append(" is not an ACIP consonant"); + } + } + } + } + if ("+".equals(get(sz - 1).getRight())) { + if (first) { + first = false; + rv = new StringBuffer("Cannot convert ACIP "); + rv.append(recoverACIP()); + rv.append(" because it ends with a {+}."); + } else { + rv.append("; also, it ends with a {+}."); + } + } + + // DLC really this is a warning, not an error: + if ("-".equals(get(sz - 1).getRight())) { + if (first) { + first = false; + rv = new StringBuffer("Cannot convert ACIP "); + rv.append(recoverACIP()); + rv.append(" because it ends with a {-}."); + } else { + rv.append("; also, it ends with a {-}."); + } + } + + return (rv == null) ? null : rv.toString(); + } + + /** Returns true if and only if either x is an TPairList object + * representing the same TPairs in the same order or x is a + * String that is equals to the result of {@link #toString()}. */ + public boolean equals(Object x) { + if (x instanceof TPairList) { + return al.equals(((TPairList)x).al); + } else if (x instanceof String) { + return toString().equals(x) || toString2().equals(x); + } + return false; + } + + /** Returns true if and only if this list is empty. */ + public boolean isEmpty() { return al.isEmpty(); } + + /** Returns a hashCode appropriate for use with our {@link + * #equals(Object)} method. */ + public int hashCode() { return al.hashCode(); } + + private static final int STOP_STACK = 0; + private static final int KEEP_STACKING = 1; + private static final int ALWAYS_KEEP_STACKING = 2; + private static final int ALWAYS_STOP_STACKING = 3; + + // DLC TEST: BA'I has exactly two syntactically legal parses but just one TStackList. + + /** Returns a set (as as ArrayList) of all possible + * TStackLists. Uses knowledge of Tibetan spelling rules + * (i.e., tsheg bar syntax) to do so. If this list of pairs has + * something clearly illegal in it, or is empty, or is merely a + * list of disambiguators etc., then this returns null. */ + public TParseTree getParseTree() { + TParseTree pt = new TParseTree(); + int sz = size(); + int firstPair = 0; + for (int i = 0; i < sz; i++) { + + // We treat [(B . ), (G . +), (K . ), (T . A)] as if it + // could be {B+G+K+T} or {B}{G+K}{T} or {B+G+K}{T} or + // {B}{G+K+T} (modulo stack legality); we're conservative. + // (Though some stacks won't be legal.) + + + if (ddebug) System.out.println("i is " + i); + TPair p = get(i); + if (p.getRight() == null && firstPair + 1 < sz) { + // Here's the ambiguity. Let's fill up sl. (B . ) (G + // . +) (K . A) could be {B+G+KA} or {BA}{G+KA}, so we + // go until we hit a vowel and then break into + // TPairLists. + int start = firstPair; + int blanks[] = new int[sz - start]; // we may not use all of this. + int j; + for (j = start; j < sz; j++) { + TPair pj = get(j); + boolean isBlank; + if (ddebug) System.out.println("right guy is " + pj.getRight()); + if (pj.isDisambiguator()) + blanks[j-start] = ALWAYS_STOP_STACKING; + else { + if (!(isBlank = (pj.getRight() == null)) && !"+".equals(pj.getRight())) { + if (ddebug) System.out.println("breaker breaker at j=" + j); + break; + } + blanks[j-start] = isBlank ? STOP_STACK : ALWAYS_KEEP_STACKING; + } + } + if (j >= sz) j = sz - 1; + + blanks[j-start] = ALWAYS_STOP_STACKING; + + // get(j) [corresponding to blanks[j-i]] is + // the last pair in the ambiguous stretch; get(i) + // [corresponding to blanks[0]] is the first. + + // We'll end up doing 2**(j-i+1) (i.e., (1 << + // (j-i+1))) iterations. If that's going to be too + // many, let's just say there's no legal parse. FIXME: + // give a nice error message in this case. + if (ddebug) System.out.println("ddebug: we're going to do 2^" + (j-i+1) + " [or " + (1 << (j-i+1)) + "] wacky iterations!"); + if ((j-i+1) > 13) // if you don't use 13, then change PackageTest.testSlowestTshegBar(). + return new TParseTree(); + + boolean keepGoing = true; + TStackListList sll = new TStackListList(); + do { + // Add the stack list currently specified by + // blanks if all the stacks in it are legal. +// DLC DELETE { +// ArrayList x = new ArrayList((j-start+1)); +// for (int ii = 0; ii < (j-start+1); ii++) +// x.add(new Integer(blanks[ii])); +// } + TStackList sl = new TStackList(sz - start); + boolean illegal = false; + TPairList currentStack = new TPairList(); + for (int k = 0; k < j-start+1; k++) { + TPair pk = get(start + k); + if (!pk.isDisambiguator()) { + currentStack.add(pk.insideStack()); + if (blanks[k] == STOP_STACK) { + if (currentStack.isLegalTibetanOrSanskritStack()) + sl.add(currentStack.asStack()); + else { + illegal = true; + break; + } + currentStack = new TPairList(); + } + } + } + if (!illegal && !currentStack.isEmpty()) { + if (currentStack.isLegalTibetanOrSanskritStack()) { + TPairList stack = currentStack.asStack(); + if (ddebug) System.out.println("adding currentStack " + stack + " to sl " + sl); + sl.add(stack); + } else { + illegal = true; + } + } + if (!illegal) { + if (ddebug) System.out.println("adding sl " + sl + " to sll " + sll); + sll.add(sl); + } + + // Update blanks. Think of this as doing base 2 + // arithmetic where STOP_STACK is zero, + // KEEP_STACKING is one, and ALWAYS_KEEP_STACKING + // and ALWAYS_STOP_STACKING are digits we cannot + // modify. We'll end up doing 2^M iterations, + // where M is the number of fields in blanks that + // are not equal to ALWAYS_KEEP_STACKING or + // ALWAYS_STOP_STACKING. + keepGoing = false; + for (int k = j-start; k >= 0; k--) { + if (blanks[k] == STOP_STACK) { + keepGoing = true; + blanks[k] = KEEP_STACKING; + // reset all digits to the right of k to + // "zero": + for (int m = k + 1; m < j-start+1; m++) { + if (blanks[m] == KEEP_STACKING) + blanks[m] = STOP_STACK; + } + break; + } + } + } while (keepGoing); + if (sll.isEmpty()) + return null; // STXAL or shT+ZNAGN, e.g. + else { + if (ddebug) System.out.println("adding sll " + sll + " to parse tree " + pt); + pt.add(sll); + } + + if (ddebug) System.out.println("i is " + i + " and j is " + j + " and we are resetting so that i==j+1 next time."); + i = j; + firstPair = j + 1; + } else if ("+".equals(p.getRight())) { + // Keep firstPair where it is. + } else { + // Add all pairs in the range [firstPair, i]. Some + // pairs are stacks all by themselves, some pairs have + // '+' on the right and are thus just part of a stack. + // We'll add a whole number of stacks, though. + + // this is initialized to hold the max we might use: + TStackListList sll + = new TStackListList(i - firstPair + 1); + + TPairList currentStack = new TPairList(); + for (int j = firstPair; j <= i; j++) { + TPair pj = get(j); + if (!pj.isDisambiguator()) { + currentStack.add(pj.insideStack()); + if (!"+".equals(pj.getRight())) { + if (currentStack.isLegalTibetanOrSanskritStack()) + sll.add(new TStackList(currentStack.asStack())); + else { + return null; + } + currentStack = new TPairList(); + } + } + } + if (!currentStack.isEmpty()) + throw new Error("how can this happen? currentStack is " + currentStack); + + if (!sll.isEmpty()) { + if (ddebug) System.out.println("adding sll " + sll + " to parse tree " + pt); + pt.add(sll); + firstPair = i + 1; + } // else you probably have {G--YA} or something as + // your tsheg bar. + } + } + return pt; + } + + /** Returns true if and only if this list of TPairs can be + * interpreted as a legal Tibetan stack or a legal Tibetanized + * Sanskrit stack. This is private because a precondition is + * that no vowels or disambiguators appear except possibly in the + * final pair. */ + private boolean isLegalTibetanOrSanskritStack() { + StringBuffer tibetan = new StringBuffer(); + StringBuffer sanskrit = new StringBuffer(); + int sz = size(); + + // Special case because otherwise wa-zur alone would be seen + // as legal. + if (sz == 1 && "V".equals(get(0).getLeft())) + return false; + + for (int i = 0; i < sz; i++) { + TPair p = get(i); + String ewts_form + = ACIPRules.getWylieForACIPConsonant(p.getLeft()); + if (null == ewts_form) { + if (p.isNumeric()) + ewts_form = p.getLeft(); + } + if (null == ewts_form) { + if (ddebug) System.out.println("testing " + toString2() + " for legality said false. numeric?" + p.isNumeric() + "[1]"); + return false; + } + tibetan.append(ewts_form); + sanskrit.append(ewts_form); + if (i + 1 < sz) { + tibetan.append('-'); + sanskrit.append('+'); + } + } + boolean ans = + (TibetanMachineWeb.hasGlyph(tibetan.toString()) + || TibetanMachineWeb.hasGlyph(sanskrit.toString())); + if (ddebug) System.out.println("testing " + toString2() + " for legality said " + ans + " [2]; san is " + sanskrit + " tib is " + tibetan + "."); + return ans; + } + private static final boolean ddebug = false; + + /** Mutates this TPairList object such that the last pair is + * empty or is a vowel, but is never the stacking operator ('+') + * or a disambiguator (i.e., a '-' on the right). + * @return this instance */ + private TPairList asStack() { + if (!isEmpty()) { + TPair lastPair = get(size() - 1); + if ("+".equals(lastPair.getRight())) + al.set(size() - 1, new TPair(lastPair.getLeft(), null)); + else if ("-".equals(lastPair.getRight())) + al.set(size() - 1, new TPair(lastPair.getLeft(), null)); + } + return this; + } + + /** Adds the TGCPairs corresponding to this list to the end of + * pl. Some TPairs correspond to more than one TGCPair + * ({AA:}); some TGCPairs correspond to more than one TPair + * ({G+YA}). To keep track, indexList will be appended to in + * lockstep with pl. index (wrapped as an {@link + * java.lang#Integer}) will be appended to indexList once each + * time we append to pl. This assumes that this TPairList + * corresponds to exactly one Tibetan grapheme cluster (i.e., + * stack). Note that U+0F7F (ACIP {:}) is part of a stack, not a + * stack all on its own. */ + void populateWithTGCPairs(ArrayList pl, ArrayList indexList, int index) { + int sz = size(); + if (sz == 0) { + return; + } else { + // drop the disambiguator, if there is one. + + boolean isNumeric = false; + StringBuffer lWylie = new StringBuffer(); + int i; + // All pairs but the last: + for (i = 0; i + 1 < sz; i++) { + lWylie.append(get(i).getWylie()); + if (get(i).isNumeric()) + isNumeric = true; + } + + // The last pair: + TPair p = get(i); + ThdlDebug.verify(!"+".equals(p.getRight())); + int where; + boolean add_U0F7F = false; + if (p.getRight() != null + && (where = p.getRight().indexOf(':')) >= 0) { + // this ':' guy is his own TGCPair. + add_U0F7F = true; + StringBuffer rr = new StringBuffer(p.getRight()); + rr.deleteCharAt(where); + p = new TPair(p.getLeft(), rr.toString()); + } + boolean hasNonAVowel = (!"A".equals(p.getRight()) && null != p.getRight()); + String thislWylie = ACIPRules.getWylieForACIPConsonant(p.getLeft()); + if (thislWylie == null) { + char ch; + if (p.isNumeric()) { + thislWylie = p.getLeft(); + isNumeric = true; + } + } + + if (null == thislWylie) throw new Error("BADNESS AT MAXIMUM: p is " + p + " and thislWylie is " + thislWylie); + lWylie.append(thislWylie); + StringBuffer ll = new StringBuffer(lWylie.toString()); + int ww; + // DLC NOW: what about fixed-form RA on top??? test it. + while ((ww = ll.indexOf("+")) >= 0) + ll.deleteCharAt(ww); + boolean isTibetan = TibetanMachineWeb.isWylieTibetanConsonantOrConsonantStack(ll.toString()); + boolean isSanskrit = TibetanMachineWeb.isWylieSanskritConsonantStack(lWylie.toString()); + if (!isTibetan && !isSanskrit && !isNumeric && true) { + System.out.println("DLC: OTHER for " + lWylie + " with vowel " + ACIPRules.getWylieForACIPVowel(p.getRight()) + " and p.getRight()=" + p.getRight()); + } + if (isTibetan && isSanskrit) isSanskrit = false; // RVA, e.g. + if (true && hasNonAVowel && ACIPRules.getWylieForACIPVowel(p.getRight()) == null) { + System.out.println("DLC: vowel " + ACIPRules.getWylieForACIPVowel(p.getRight()) + " and p.getRight()=" + p.getRight()); + } + TGCPair tp; + indexList.add(new Integer(index)); + tp = new TGCPair(lWylie.toString() + + (hasNonAVowel + ? ACIPRules.getWylieForACIPVowel(p.getRight()) + : ""), + (isNumeric + ? TGCPair.OTHER + : (hasNonAVowel + ? (isSanskrit + ? TGCPair.SANSKRIT_WITH_VOWEL + : (isTibetan + ? TGCPair.CONSONANTAL_WITH_VOWEL + : TGCPair.OTHER)) + : (isSanskrit + ? TGCPair.SANSKRIT_WITHOUT_VOWEL + : (isTibetan + ? TGCPair.CONSONANTAL_WITHOUT_VOWEL + : TGCPair.OTHER))))); + pl.add(tp); + if (add_U0F7F) { + indexList.add(new Integer(index)); + pl.add(new TGCPair("H", TGCPair.OTHER)); + } + } + } +} +// DLC FIXME: handle 'o' and 'x', e.g. KAo and NYAx. diff --git a/source/org/thdl/tib/text/ttt/TPairListFactory.java b/source/org/thdl/tib/text/ttt/TPairListFactory.java new file mode 100644 index 0000000..9264b6d --- /dev/null +++ b/source/org/thdl/tib/text/ttt/TPairListFactory.java @@ -0,0 +1,167 @@ +/* +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; + +/** A factory for creating {@link TPairList TPairLists} from + * Strings of ACIP. + * @author David Chandler */ +class TPairListFactory { + /** This class is not instantiable. */ + private TPairListFactory() { } + + /** Returns a new TPairList instance. Breaks an ACIP tsheg bar + * (roughly a "syllable") into chunks; this computes l' + * (for you design doc enthusiasts). + * + *

Here's a rough sketch of the algorithm: run along getting + * the current TPair as big as you can. If you get it very + * big, but there's something illegal afterward that wouldn't + * otherwise be illegal, undo as little as possible to correct. + * For example, G'A'I becomes [(G . 'A), (' . I)], and TAA + * becomes [(T . A)] in a first pass but then we see that the + * rest would be suboptimal, so we backtrack to [(T . )] and then + * finally become [(T . ), (A . A)]. We look for (A . ) and ( + * . ) in the rest in order to say "the rest would be + * suboptimal", i.e. we use TPairList.hasSimpleError() + * @param acip a string of ACIP with no punctuation in it */ + static TPairList breakACIPIntoChunks(String acip) { + + // base case for our recursion: + if ("".equals(acip)) + return new TPairList(); + + StringBuffer acipBuf = new StringBuffer(acip); + int howMuchBuf[] = new int[1]; + TPair head = getFirstConsonantAndVowel(acipBuf, howMuchBuf); + int howMuch = howMuchBuf[0]; + TPairList tail; + if ((tail + = breakACIPIntoChunks(acipBuf.substring(howMuch))).hasSimpleError()) { + for (int i = 1; i < howMuch; i++) { + // try giving i characters back if that leaves us with + // a legal head and makes the rest free of simple + // errors. + TPairList newTail = null; + TPair newHead; + if ((newHead = head.minusNRightmostACIPCharacters(i)).isLegal() + && !(newTail + = breakACIPIntoChunks(acipBuf.substring(howMuch - i))).hasSimpleError()) { + newTail.prepend(newHead); + return newTail; + } + } + // It didn't work. Return the first thing we'd thought + // of: head appended with tail. (I.e., fall through.) + } + tail.prepend(head); + return tail; + } + + /** Returns the largest TPair we can make from the acip + * starting from the left. This will return a size zero pair if + * and only if acip is the empty string; otherwise, it may return + * a pair with either the left or right component empty. This + * mutates acip when we run into {NA+YA}; it mutates acip into + * {N+YA}. For {NE+YA}, it doesn not mutate acip or behave + * intelligently. A later phase will need to turn that into + * {N+YE} (DLC). howMuch[0] will be set to the number of + * characters of acip that this call has consumed. */ + private static TPair getFirstConsonantAndVowel(StringBuffer acip, + int howMuch[]) { + // Note that it is *not* the case that if acip.substring(0, N) + // is legal (according to TPair.isLegal()), then + // acip.substring(0, N-1) is legal for all N. For example, + // think of {shA} and {KshA}. However, 's' is the only tricky + // fellow, so it is true that acip.substring(0, N-1) is either + // legal or ends with 's' if acip.substring(0, N) is legal. + // + // We don't, however, use this approach. We just try to find + // a consonant of length 3, and then, failing that, of length + // 2, etc. Likewise with vowels. This avoids the issue. + + int i, xl = acip.length(); + if (0 == xl) { + howMuch[0] = 0; + return new TPair(null, null); + } + if (acip.charAt(0) == '-') { + howMuch[0] = 1; + return new TPair(null, "-"); + } + char ch = acip.charAt(0); + + // Numbers never appear in stacks, so if you see 1234, that's + // like seeing 1-2-3-4. + if (ch >= '0' && ch <= '9') { + howMuch[0] = 1; // not 2... + return new TPair(acip.substring(0, 1), (xl == 1) ? null : "-"); + } + + String l = null, r = null; + for (i = Math.min(ACIPRules.MAX_CONSONANT_LENGTH, xl); i >= 1; i--) { + String t = null; + if (ACIPRules.isConsonant(t = acip.substring(0, i))) { + l = t; + break; + } + } + int ll = (null == l) ? 0 : l.length(); + if (null != l && xl > ll && acip.charAt(ll) == '-') { + howMuch[0] = l.length() + 1; + return new TPair(l, "-"); + } + if (null != l && xl > ll && acip.charAt(ll) == '+') { + howMuch[0] = l.length() + 1; + return new TPair(l, "+"); + } + for (i = Math.min(ACIPRules.MAX_VOWEL_LENGTH, xl - ll); i >= 1; i--) { + String t = null; + if (ACIPRules.isVowel(t = acip.substring(ll, ll + i))) { + r = t; + break; + } + } + + // Treat {BATA+SA'I} like {BAT+SA'I}: + int z; + if (null != l && "A".equals(r) && ((z = ll + "A".length()) < xl) + && acip.charAt(z) == '+') { + acip.deleteCharAt(z-1); + howMuch[0] = l.length() + 1; + return new TPair(l, "+"); + } + + // what if we see a character that's not part of any vowel or + // consonant? We return it. + if (null == l && null == r) { + howMuch[0] = 1; // not 2... + // add a '-' to avoid exponentials: + return new TPair(acip.substring(0, 1), (xl == 1) ? null : "-"); + } + + howMuch[0] = (((l == null) ? 0 : l.length()) + + ((r == null) ? 0 : r.length())); + return new TPair(l, r); + } +} + + +// DLC strip out [#...] comments; test for nested comments + +// DLC see Translit directory on ACIP v4 CD-ROM diff --git a/source/org/thdl/tib/text/ttt/TParseTree.java b/source/org/thdl/tib/text/ttt/TParseTree.java new file mode 100644 index 0000000..ea428f2 --- /dev/null +++ b/source/org/thdl/tib/text/ttt/TParseTree.java @@ -0,0 +1,200 @@ +/* +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 java.util.ArrayList; + +/** A list of non-empty list of {@link #TStackListList + * TStackListLists} representing all the ways you could break up a + * tsheg bar of ACIP into stacks (i.e., grapheme clusters). + * + * @author David Chandler */ +class TParseTree { + /** a fast, non-thread-safe, random-access list implementation: */ + private ArrayList al = new ArrayList(); + + /** Creates an empty list. */ + public TParseTree() { } + + /** Returns the ith pair in this list. */ + public TStackListList get(int i) { return (TStackListList)al.get(i); } + + /** Adds p to the end of this list. */ + public void add(TStackListList p) + throws IllegalArgumentException + { + if (p.isEmpty()) + throw new IllegalArgumentException("p is empty"); + al.add(p); + } + + /** Returns the number of TStackListLists in this list. See + * also {@link #numberOfParses()}, which gives a different + * interpretation of the size of this tree. */ + public int size() { return al.size(); } + + /** Returns the number of different parses one could make from + * this parse tree. Returns zero if this list is empty. */ + public int numberOfParses() { + if (al.isEmpty()) return 0; + int k = 1; + int sz = size(); + for (int i = 0; i < sz; i++) { + k *= get(i).size(); + } + return k; + } + + /** Returns the number of {@link #TPair pairs} that are in a + * parse of this tree. */ + public int numberOfPairs() { + if (al.isEmpty()) return 0; + int k = 1; + int sz = size(); + for (int i = 0; i < sz; i++) { + // get(i).get(0) is the same size as get(i).get(1), + // get(i).get(2), ... + k += get(i).get(0).size(); + } + return k; + } + + /** Returns an iterator that will iterate over the {@link + * #numberOfParses} available. */ + public ParseIterator getParseIterator() { + return new ParseIterator(al); + } + + /** Returns a list containing the legal parses of this parse tree. + * By "legal", we mean a sequence of stacks that is + * legal by the rules of Tibetan tsheg bar syntax (sometimes + * called spelling). This will return the {G-YA} parse of {GYA} + * as well as the {GYA} parse, so watch yourself. */ + public TStackListList getLegalParses() { + TStackListList sll = new TStackListList(2); // save memory + ParseIterator pi = getParseIterator(); + while (pi.hasNext()) { + TStackList sl = pi.next(); + if (sl.isLegalTshegBar().isLegal) { + sll.add(sl); + } + } + return sll; + } + + /** Returns a list containing the parses of this parse tree that + * are not clearly illegal. */ + public TStackListList getNonIllegalParses() { + TStackListList sll = new TStackListList(2); // save memory + ParseIterator pi = getParseIterator(); + while (pi.hasNext()) { + TStackList sl = pi.next(); + if (!sl.isClearlyIllegal()) { + sll.add(sl); + } + } + return sll; + } + + /** Returns the best parse, if there is a unique parse that is + * clearly preferred to other parses. Basically, if there's a + * unique legal parse, you get it. If there's not, but there is + * a unique non-illegal parse, you get it. If there's not a + * unique answer, null is returned. */ + // {TZANDRA} is not solved by this, DLC NOW. Solve PADMA PROBLEM! + + // DLC by using this we can get rid of single-sanskrit-gc, eh? + public TStackList getBestParse() { + TStackListList up = getUniqueParse(); + if (up.size() == 1) + return up.get(0); + else if (up.size() == 2) { + } + up = getNonIllegalParses(); + int sz = up.size(); + if (up.size() == 1) { + return up.get(0); + } + return null; + } + + /** Returns a list containing the unique legal parse of this parse + * tree if there is a unique legal parse. Note that {SRAS} has a + * unique legal parse, though {SRS} has two equally good parses; + * i.e., note that the {A} vowel is treated specially here + * (unlike in {@link #getLegalParses()}). Returns an empty list + * if there are no legal parses. Returns a list containing all + * legal parses if there two or more equally good parses. By + * "legal", we mean a sequence of stacks that is legal + * by the rules of Tibetan tsheg bar syntax (sometimes called + * spelling). */ + public TStackListList getUniqueParse() { + TStackListList allLegalParses = new TStackListList(2); // save memory + TStackListList legalParsesWithVowelOnRoot = new TStackListList(1); + ParseIterator pi = getParseIterator(); + while (pi.hasNext()) { + TStackList sl = pi.next(); + BoolPair bpa = sl.isLegalTshegBar(); + if (bpa.isLegal) { + if (bpa.isLegalAndHasAVowelOnRoot) + legalParsesWithVowelOnRoot.add(sl); + allLegalParses.add(sl); + } + } + if (legalParsesWithVowelOnRoot.size() == 1) + return legalParsesWithVowelOnRoot; + else { + if (legalParsesWithVowelOnRoot.size() == 2) { + // DLC is this even valid? + if (legalParsesWithVowelOnRoot.get(0).size() != 1 + legalParsesWithVowelOnRoot.get(1).size()) + throw new Error("Something other than the G-YA vs. GYA case appeared. Sorry for your trouble! " + legalParsesWithVowelOnRoot.get(0) + " ;; " + legalParsesWithVowelOnRoot.get(1)); + return new TStackListList(legalParsesWithVowelOnRoot.get(1)); + } + if (allLegalParses.size() == 2) { + // DLC is this even valid? + if (allLegalParses.get(0).size() != 1 + allLegalParses.get(1).size()) + throw new Error("Something other than the G-YA vs. GYA case appeared. Sorry for your trouble! " + allLegalParses.get(0) + " ;; " + allLegalParses.get(1)); + return new TStackListList(allLegalParses.get(1)); + } + return allLegalParses; + } + } + + /** Returns a human-readable representation. */ + public String toString() { + return al.toString(); + } + + /** Returns true if and only if either x is an TParseTree + * object representing the same TPairLists in the same order + * or x is a String that is equals to the result of {@link + * #toString()}. */ + public boolean equals(Object x) { + if (x instanceof TParseTree) { + return al.equals(((TParseTree)x).al); + } else if (x instanceof String) { + return toString().equals(x); + } + return false; + } + + /** Returns a hashCode appropriate for use with our {@link + * #equals(Object)} method. */ + public int hashCode() { return al.hashCode(); } +} diff --git a/source/org/thdl/tib/text/ttt/TStackList.java b/source/org/thdl/tib/text/ttt/TStackList.java new file mode 100644 index 0000000..56d08e7 --- /dev/null +++ b/source/org/thdl/tib/text/ttt/TStackList.java @@ -0,0 +1,176 @@ +/* +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.tib.text.TibTextUtils; +import org.thdl.tib.text.TGCList; + +import java.util.ArrayList; +import java.util.ListIterator; + +/** A list of {@link TPairList TPairLists}, each of which is for + * a stack (a grapheme cluster), typically corresponding to one tsheg + * bar. + * + * @author David Chandler */ +class TStackList { + /** FIXME: change me and see if performance improves. */ + private static final int INITIAL_SIZE = 1; + + /** a fast, non-thread-safe, random-access list implementation: */ + private ArrayList al; + + /** Creates an empty list. */ + public TStackList() { al = new ArrayList(INITIAL_SIZE); } + + /** Creates a list containing just p. */ + public TStackList(TPairList p) { + al = new ArrayList(1); + add(p); + } + + /** Creates an empty list with the capacity to hold N items. */ + public TStackList(int N) { + al = new ArrayList(N); + } + + /** Returns the ith pair in this list. */ + public TPairList get(int i) { return (TPairList)al.get(i); } + + /** Adds p to the end of this list. */ + public void add(TPairList p) { al.add(p); } + + /** Adds all the stacks in c to the end of this list. */ + public void addAll(TStackList c) { al.addAll(c.al); } + + /** Adds all the stacks in c to this list, inserting them at + * position k. */ + public void addAll(int k, TStackList c) { al.addAll(k, c.al); } + + /** Returns the number of TPairLists in this list. */ + public int size() { return al.size(); } + + /** Returns true if and only if this list is empty. */ + public boolean isEmpty() { return al.isEmpty(); } + + /** Returns a human-readable representation like {G}{YA} or + * {GYA}. */ + public String toString() { + int sz = size(); + StringBuffer b = new StringBuffer(); + for (int i = 0; i < sz; i++) { + b.append('{'); + b.append(get(i).recoverACIP()); + b.append('}'); + } + return b.toString(); + } + + /** Returns a human-readable representation. + * @return something like [[(R . ), (D . O)], [(R . ), (J . E)]] */ + public String toString2() { + return al.toString(); + } + + /** Returns true if and only if either x is an TStackList + * object representing the same TPairLists in the same + * order or x is a String that is equals to the result of {@link + * #toString()}. */ + public boolean equals(Object x) { + if (x instanceof TStackList) { + return al.equals(((TStackList)x).al); + } else if (x instanceof String) { + return toString().equals(x) || toString2().equals(x); + } + return false; + } + + /** Returns a hashCode appropriate for use with our {@link + * #equals(Object)} method. */ + public int hashCode() { return al.hashCode(); } + + /** Returns an iterator for this list. Mutate this list while + * iterating and you'll have to read the code to know what will + * happen. */ + public ListIterator listIterator() { return al.listIterator(); } + + /** Returns a pair with {@link BoolPair#isLegal} true if and only + * if this list of stacks is a legal tsheg bar by the rules of + * Tibetan syntax (sometimes called rules of spelling). If this + * is legal, then {@link BoolPair#isLegalAndHasAVowelOnRoot} will + * be true if and only if there is an explicit {A} vowel on the + * root stack. */ + public BoolPair isLegalTshegBar() { + // DLC handle PADMA and other Tibetanized Sanskrit fellows. Right now we only handle single-stack guys. + + TTGCList tgcList = new TTGCList(this); + StringBuffer warnings = new StringBuffer(); + String candidateType + = TibTextUtils.getClassificationOfTshegBar(tgcList, warnings); + // System.out.println("DLC: " + toString() + " has candidateType " + candidateType + " and warnings " + warnings); + + // preliminary answer: + boolean isLegal = (candidateType != "invalid"); + + if (isLegal) { + if (isClearlyIllegal()) + isLegal = false; + } + + boolean isLegalAndHasAVowelOnRoot = false; + if (isLegal) { + int rootIndices[] + = TibTextUtils.getIndicesOfRootForCandidateType(candidateType); + for (int i = 0; i < 2; i++) { + if (rootIndices[i] >= 0) { + int pairListIndex = tgcList.getTPairListIndex(rootIndices[i]); + TPairList pl = get(pairListIndex); + TPair p = pl.get(pl.size() - 1); + isLegalAndHasAVowelOnRoot + = (p.getRight() != null && p.getRight().startsWith("A")); // could be {A:}, e.g. + if (isLegalAndHasAVowelOnRoot) + break; + } + } + } + return new BoolPair(isLegal, isLegalAndHasAVowelOnRoot); + } + + /** Returns true if and only if this stack list contains a clearly + * illegal construct, such as an TPair (V . something). */ + boolean isClearlyIllegal() { + // check for {D}{VA} sorts of things: + for (int i = 0; i < size(); i++) { + if (get(i).getACIPError() != null) { + System.out.println("DLC: error is " + get(i).getACIPError()); + return true; + } + } + return false; + } +} + +class BoolPair { + boolean isLegal; + boolean isLegalAndHasAVowelOnRoot; + BoolPair(boolean isLegal, boolean isLegalAndHasAVowelOnRoot) { + this.isLegal = isLegal; + this.isLegalAndHasAVowelOnRoot = isLegalAndHasAVowelOnRoot; + } +} diff --git a/source/org/thdl/tib/text/ttt/TStackListList.java b/source/org/thdl/tib/text/ttt/TStackListList.java new file mode 100644 index 0000000..f826598 --- /dev/null +++ b/source/org/thdl/tib/text/ttt/TStackListList.java @@ -0,0 +1,86 @@ +/* +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 java.util.ArrayList; +import java.util.ListIterator; + +/** A list of {@link #TStackList} objects, each of which is for a + * stack (a grapheme cluster), typically corresponding to one + * ambiguous section of a tsheg bar. + * + * @author David Chandler */ +class TStackListList { + /** a fast, non-thread-safe, random-access list implementation: */ + private ArrayList al; + + /** Creates an empty list. */ + public TStackListList() { al = new ArrayList(); } + + /** Creates a list containing just p. */ + public TStackListList(TStackList p) { + al = new ArrayList(1); + add(p); + } + + /** Creates an empty list with the capacity to hold N items. */ + public TStackListList(int N) { + al = new ArrayList(N); + } + + /** Returns the ith pair in this list. */ + public TStackList get(int i) { return (TStackList)al.get(i); } + + /** Adds p to the end of this list. */ + public void add(TStackList p) { al.add(p); } + + /** Returns the number of TStackList objects in this list. */ + public int size() { return al.size(); } + + /** Returns true if and only if this list is empty. */ + public boolean isEmpty() { return al.isEmpty(); } + + /** Returns a human-readable representation. + * @return something like [[[(R . ), (D . O)], [(R . ), (J . E)]]] */ + public String toString() { + return al.toString(); + } + + /** Returns true if and only if either x is an TStackListList + * object representing the same TStackList objects in the same + * order or x is a String that is equals to the result of {@link + * #toString()}. */ + public boolean equals(Object x) { + if (x instanceof TStackListList) { + return al.equals(((TStackListList)x).al); + } else if (x instanceof String) { + return toString().equals(x); + } + return false; + } + + /** Returns a hashCode appropriate for use with our {@link + * #equals(Object)} method. */ + public int hashCode() { return al.hashCode(); } + + /** Returns an iterator for this list. Mutate this list while + * iterating and you'll have to read the code to know what will + * happen. */ + public ListIterator listIterator() { return al.listIterator(); } +} diff --git a/source/org/thdl/tib/text/ttt/TTGCList.java b/source/org/thdl/tib/text/ttt/TTGCList.java new file mode 100644 index 0000000..c0f4c5a --- /dev/null +++ b/source/org/thdl/tib/text/ttt/TTGCList.java @@ -0,0 +1,63 @@ +/* +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.tib.text.TGCList; +import org.thdl.tib.text.TGCPair; + +import java.util.ArrayList; + +/** A list of grapheme clusters. + * + * @author David Chandler */ +class TTGCList implements TGCList { + // I could use one list of an ordered pair (TGCPair, int), but I + // use two lists. + private ArrayList al; + private ArrayList stackIndices; + + /** Don't use this. */ + private TTGCList() { } + + /** Creates a TGCList. */ + public TTGCList(TStackList sl) { + al = new ArrayList(); + stackIndices = new ArrayList(); + int sz = sl.size(); + for (int i = 0; i < sz; i++) { + sl.get(i).populateWithTGCPairs(al, stackIndices, i); + } + } + + /** Returns the ith pair in this list. */ + public TGCPair get(int i) { + return (TGCPair)al.get(i); + } + + /** Returns the number of TGCPairs in this list. */ + public int size() { return al.size(); } + + /** Returns a zero-based index of an TPairList inside the stack + * list from which this list was constructed. This pair list is + * the one that caused the TGCPair at index tgcPairIndex to come + * into existence. */ + public int getTPairListIndex(int tgcPairIndex) { + return ((Integer)stackIndices.get(tgcPairIndex)).intValue(); + } +} diff --git a/source/org/thdl/tib/text/ttt/package.html b/source/org/thdl/tib/text/ttt/package.html new file mode 100644 index 0000000..db7b7fe --- /dev/null +++ b/source/org/thdl/tib/text/ttt/package.html @@ -0,0 +1,31 @@ + + + + + + + +Provides classes and methods for converting Latin transliteration of +Tibetan text into Tibetan. +

+This package (whose name, ttt, stands for transliteration-to-Tibetan) +contains methods for converting ACIP transliteration into Tibetan +Machine Web and methods for converting EWTS transliteration into +Tibetan Machine Web.  It has extensive tests, though probably not +mentioned in these Javadoc documents. +

+

Related Documentation

+@see org.thdl.tib.text + +