package xtc.parser;
header {
    import xtc.util.Utilities;
    import xtc.tree.Attribute;
}
class PParser;
body {
    public static void main (String [] args) {
        PParser parser;
        String filename = null;
        long initTime = 0;
        long parseTime = 0;
        long startTime = 0;
        long stopTime = 0;
        if (args.length == 1)
        {
            filename = args[0];
            System.out.println("Java Parser Version 1.1 (for Java1.4 code):  Reading from file " + filename + " . . .");
            try
            {
                startTime = System.currentTimeMillis();
                parser = new PParser(new java.io.FileReader(filename), filename);
                stopTime = System.currentTimeMillis();
                initTime = stopTime - startTime;
            } catch (java.io.FileNotFoundException e)
            {
                System.out.println("Java Parser Version 1.1 (for Java1.4 code):  File " + filename + " not found.");
                return;
            }
        } else
        {
            System.out.println("Java Parser Version 1.1 (for Java1.4 code):  Usage is one of:");
            System.out.println("         java Parser inputfile");
            return;
        }

        try {
            startTime = System.currentTimeMillis();
            Result result = parser.ptext();
            if (! result.hasValue()) {
                ParseError      err    = (ParseError)result;
                System.err.println();
                //Utilities.msg(err.msg, err.parser.location(), source);
                return;
            }
            stopTime = System.currentTimeMillis();
            parseTime = stopTime - startTime;
            System.out.println("   Lojban parser parsed " + filename + " successfully in " + (initTime + parseTime) + " ms.");
            System.out.println("      parser initialization time was " + initTime + " ms.");
            System.out.println("      parser parse time was " + parseTime + " ms.");
            System.out.println("Value: " + result.semanticValue());
        } catch (Throwable x) {
            while (null != x.getCause()) {
                x = x.getCause();
            }
        }
    }
}
footer {
}
option location,debug;
top text;

String text = textFirst / textSecond;
String textFirst = textPre text1 textRest ;
String textSecond = textPre joikJek text1 textRest;
String textThird = textPre textRest;
String textFourth = textPre joikJek textRest;
String textPre = spaces* suClause* spaces* (Y !BU)? siClause? NAI* ((CMENE !ZEI !BU)+ free* / (indicators free+ / indicators / free+))? ;

String textRest = (FAhO .*)?;

String text1 = ((I (jek / joik)? (stag? BO)? text1 free*)+ / NIhO+ paragraphs? free*)? paragraphs;

String paragraphs = paragraph (NIhO+ free* paragraphs)?;

String paragraph = (statement / fragment) (I free* (statement / fragment)?)*;

String statement = statement1 / prenex statement;

String statement1 = statement2 (I joikJek statement2)* / statement2 (I joikJek statement2?)*;

String statement2 = statement3 (I (jek / joik)? stag? BO free* statement2)? / statement3 (I (jek / joik)? stag? BO free* statement2?)?;

String statement3 = sentence / tag? TUhE free* text1 (TUhU free*)?;

String fragment = terms (VAU free*)? / ek free* / gihek free* / quantifier / NA free* / prenex / relativeClauses / links / linkargs;

String prenex = terms ZOhU free*;

String sentence = (terms (CU free*)?)? bridiTail / bridiTail;

String subsentence = sentence / prenex subsentence;

String bridiTail = bridiTail1 (gihek stag? KE free* bridiTail (KEhE free*)? tailTerms)?;

String bridiTail1 = bridiTail2 (gihek free* bridiTail2 tailTerms)*;

String bridiTail2 = bridiTail3 (gihek stag? BO free* bridiTail2 tailTerms)?;

String bridiTail3 = selbri tailTerms / gekSentence;

String gekSentence = gek subsentence gik subsentence tailTerms / tag? KE free* gekSentence (KEhE free*)? / NA free* gekSentence;

String tailTerms = terms? (VAU free*)?;

String terms = terms1+;

String terms1 = terms2 (PEhE free* joikJek terms2)*;

String terms2 = term (CEhE free* term)*;

String term = sumti / ( (tag / FA free*) (sumti / (KU free*)?) ) / termset / NA KU free*;

String termset = NUhI free* gek terms NUhU free* gik terms (NUhU free*)? / NUhI free* terms (NUhU free*)?;

String sumti = sumti1 (VUhO free* relativeClauses)?;

String sumti1 = sumti2 ((ek / joik) stag? KE free* sumti (KEhE free*)?)?;

String sumti2 = sumti3 (joikEk sumti3)*;

String sumti3 = sumti4 ((ek / joik) stag? BO free* sumti3)?;

String sumti4 = sumti5 / gek sumti gik sumti4;

String sumti5 = quantifier? sumti6 relativeClauses? / quantifier selbri (KU free*)? relativeClauses?;

String sumti6 = zoClause / LOhU lohuTail free* / lerfuString (BOI free*)? / LU text (LIhU free*)? / (LAhE free* / NAhE BO free*) relativeClauses? sumti (LUhU free*)? / KOhA free* / LA free* relativeClauses? CMENE+ free* / (LA / LE) free* sumtiTail (KU free*)? / LI free* mex (LOhO free*)? ;
// / ZOI any-word anything any-word free*

String zoClause = ZO zoSiClause? Y free* / ZO zoSiClause? anyWord free*;
String zoSiClause = (Y / anyWordNoSIHandling) SI / (Y / anyWordNoSIHandling) zoSiClause SI;

String lohuTail = lehuSiClause lohuTail / LEhU / anyWordNoSIHandling lohuTail;

String lehuSiClause = LEhU SI / anyWordNoSIHandling SI / LEhU lehuSiClause SI / anyWordNoSIHandling lehuSiClause SI ;

String sumtiTail = (sumti6 relativeClauses?)? sumtiTail1 / relativeClauses sumtiTail1;

String sumtiTail1 = quantifier? selbri relativeClauses? / quantifier sumti;

String relativeClauses = relativeClause (ZIhE free* relativeClause)*;

String relativeClause = GOI free* term (GEhU free*)? / NOI free* subsentence (KUhO free*)?;

String selbri = tag? selbri1;

String selbri1 = selbri2 / NA free* selbri;

String selbri2 = selbri3 (CO free* selbri2)?;

String selbri3 = selbri4+;

String selbri4 = selbri5 (joikJek selbri5 / joik stag? KE free* selbri3 (KEhE free*)?)*;

String selbri5 = selbri6 ((jek / joik) stag? BO free* selbri5)?;

String selbri6 = tanruUnit (BO free* selbri6)? / (NAhE free*)? guhek selbri gik selbri6;

String tanruUnit = tanruUnit1 (CEI free* tanruUnit1)*;

String tanruUnit1 = tanruUnit2 linkargs?;

String tanruUnit2 = anyWord (ZEI anyWord)+ / BRIVLA free* / GOhA RAhO? free* / KE free* selbri3 (KEhE free*)? / ME free* sumti (MEhU free*)? (MOI free*)? / (number / lerfuString) MOI free* / NUhA free* mexOperator / SE free* tanruUnit2 / JAI free* tag? tanruUnit2 / NAhE free* tanruUnit2 / NU NAI? free* (joikJek NU NAI? free*)* subsentence (KEI free*)?;

String linkargs = BE free* term links? (BEhO free*)?;

String links = BEI free* term links?;

String quantifier = number (BOI free*)? / VEI free* mex (VEhO free*)?;

String mex = mex1 (operator mex1)* / FUhA free* rpExpression;

String mex1 = mex2 (BIhE free* operator mex1)?;

String mex2 = operand / (PEhO free*)? operator mex2+ (KUhE free*)?;

//li fu'a reboi ci pi'i voboi mu pi'i su'i reboi ci vu'u su'i du li rexa
//rp-expression <- rp-operand rp-operand operator
//rp-operand <- operand / rp-expression

String rpExpression = operand rpExpressionTail;
String rpExpressionTail = rpExpression operator rpExpressionTail / ();

String operator = operator1 (joikJek operator1 / joik stag? KE free* operator (KEhE free*)?)*;

String operator1 = operator2 / guhek operator1 gik operator2 / operator2 (jek / joik) stag? BO free* operator1;

String operator2 = mexOperator / KE free* operator (KEhE free*)?;

String mexOperator = SE free* mexOperator / NAhE free* mexOperator / MAhO free* mex (TEhU free*)? / NAhU free* selbri (TEhU free*)? / VUhU free*;

String operand = operand1 ((ek / joik) stag? KE free* operand (KEhE free*)?)?;

String operand1 = operand2 (joikEk operand2)*;

String operand2 = operand3 ((ek / joik) stag? BO free* operand2)?;

String operand3 = quantifier / lerfuString (BOI free*)? / NIhE free* selbri (TEhU free*)? / MOhE free* sumti (TEhU free*)? / JOhI free* mex2+ (TEhU free*)? / gek operand gik operand3 / (LAhE free* / NAhE BO free*) operand (LUhU free*)?;

String number = PA (PA / lerfuWord)*;

String lerfuString = lerfuWord (PA / lerfuWord)*;

String lerfuWord = buClause / BY / LAU lerfuWord / TEI lerfuString FOI;

String buClause = BAhE BU+ / Y BU+ / !BUBare anyWordNoBUHandling BU+;

String ek = NA? SE? A NAI?;

String gihek = NA? SE? GIhA NAI?;

String jek = NA? SE? JA NAI?;

String joik = SE? JOI NAI? / interval / GAhO interval GAhO;

String interval = SE? BIhI NAI?;

String joikEk = joik free* / ek free*;

String joikJek = joik free* / jek free*;

String gek = SE? GA NAI? free* / joik GI free* / stag gik;

String guhek = SE? GUhA NAI? free*;

String gik = GI NAI? free*;

String tag = tenseModal (joikJek tenseModal)*;

String stag = simpleTenseModal ((jek / joik) simpleTenseModal)*;

String tenseModal = simpleTenseModal free* / FIhO free* selbri (FEhU free*)?;

String simpleTenseModal = NAhE? SE? BAI NAI? KI? / NAhE? ((time space? / space time?) / CAhA / (time space? / space time?) CAhA) KI? / KI / CUhE;

String time = ZI timeOffset* (ZEhA (PU NAI?)?)? intervalProperty* / ZI? timeOffset+ (ZEhA (PU NAI?)?)? intervalProperty* / ZI? timeOffset* ZEhA (PU NAI?)? intervalProperty* / ZI? timeOffset* (ZEhA (PU NAI?)?)? intervalProperty+;

String timeOffset = PU NAI? ZI?;

String space = VA spaceOffset* spaceInterval? (MOhI spaceOffset)? / VA? spaceOffset+ spaceInterval? (MOhI spaceOffset)? / VA? spaceOffset* spaceInterval (MOhI spaceOffset)? / VA? spaceOffset* spaceInterval? MOhI spaceOffset;

String spaceOffset = FAhA NAI? VA?;

String spaceInterval = (VEhA / VIhA / VEhA VIhA) (FAhA NAI?)? spaceIntProps / (VEhA / VIhA / VEhA VIhA) (FAhA NAI?)? / spaceIntProps;

String spaceIntProps = (FEhE intervalProperty)+;

String intervalProperty = number ROI NAI? / TAhE NAI? / ZAhO NAI?;

String free = SEI free* (terms (CU free*)?)? selbri SEhU? / SOI free* sumti sumti? SEhU? / vocative relativeClauses? selbri relativeClauses? DOhU? / vocative relativeClauses? CMENE+ free* relativeClauses? DOhU? / vocative sumti? DOhU? / (number / lerfuString) MAI / TO text TOI? / XI free* (number / lerfuString) BOI? / XI free* VEI free* mex VEhO?;

String vocative = (COI NAI?)+ DOI / (COI NAI?)+ / DOI;

String indicators = FUhE? indicator+;

String indicator =  ((UI / CAI) NAI? / Y / DAhO / FUhO) !BUBare;

// The following rules are non-formal:
// 
// word<1100> <- [BAhE] any-word [indicators]
// 
// null<1101> <- any-word SI / utterance SA / text SU

//         any single lexable Lojban words 
String anyWord = CMAVO / BRIVLA / CMENE;
String anyWordNoSIHandling = CMAVONoSIHandling / BRIVLANoSIHandling / CMENENoSIHandling;
String anyWordNoSAHandling = CMAVONoSAHandling / BRIVLANoSIHandling / CMENENoSIHandling;
String anyWordNoBUHandling = CMAVONoBUHandling / BRIVLANoBUHandling / CMENENoBUHandling;

//         a possibly unlexable phoneme string 
// anything <- "AnyThing" 

// --- MORPHOLOGY ---

// Letter Groups
String consonant = [bcdfgjklmnprstvxz];
String cmeneConsonant = [bcdfgjklmnprstvxz] / [BCDFGJKLMNPRSTVXZ];
String vowel = [aeiouy];
String otherLetter = [',];
String lojbanLetter = consonant / vowel / otherLetter;
String cmeneLetter = lojbanLetter / [BCDFGJKLMNPRSTVXZ] / [AEIOU] / [hY];

// Indicator absorbtion; grammar.300 4d and 4e
String absorbIndicators = UI NAI? / CAI NAI? / Y / DAhO / FUhO / FUhE;

// Handling of spaces
String spacing = !. / spaces+ siClause absorbIndicators*;
String spaces = '.' / ' ' / '\n' / '\t' / '\r' / Y;
String spacesNotY = '.' / ' ' / '\n' / '\t' / '\r';

// SU clauses
String suClause = (!SU !NIhO !LU !TUhE !TO anyWord)+ SU;

// Handling of SI and interactions with zo and lo'u...le'u

String siClause = (LOhU lohuTailSiClause SI / !LOhU !SI !ZO anyWordNoSIHandling SI / !LOhU !SI !ZO anyWordNoSIHandling siClause SI )* ENDSICLAUSE;
//; This is just to make reading the parser output easier.
String ENDSICLAUSE = ();

String lohuTailSiClause = LEhUNoSIHandling siClause SI / !SI anyWordNoSIHandling lohuTailSiClause SI;

// For handling things of higher priority than SI (i.e. lo'u...le'u, zo)
String spacingNoSIHandling = spaces+;
String siSpacing = spaces+;

// For handling BU issues
String spacingNoBUHandling = spaces+ absorbIndicators*;

//         any brivla 
// For now: gismu pattern.
// BRIVLA	: /[bcdfgjklmnprstvxz]{2}['a-z]{2,}[aeiou]/
//		/ /[bcdfgjklmnprstvxz][aeiou][bcdfgjklmnprstvxz]y?[bcdfgjklmnprstvxz]['a-z]*[aeiou]/
//		/ /[bcdfgjklmnprstvxz][aeiou]'?[aeiou][bcdfgjklmnprstvxz]{2}['a-z]*[aeiou]/
//		/ /[aeiou]('?[aeiou]){,2}[bcdfgjklmnprstvxz]{2}['a-z]*[aeiou]/

String BRIVLA = BAhE? consonant consonant lojbanLetter lojbanLetter brivlaTail / BAhE? consonant vowel consonant 'y'? consonant brivlaTail / BAhE? consonant vowel [']? vowel consonant consonant brivlaTail;

String brivlaTail = vowel spacing / lojbanLetter brivlaTail;

String BRIVLANoSIHandling = consonant consonant lojbanLetter lojbanLetter brivlaTailNoSIHandling / consonant vowel consonant 'y'? consonant brivlaTailNoSIHandling / consonant vowel [']? vowel consonant consonant brivlaTailNoSIHandling;

String brivlaTailNoSIHandling = vowel spacingNoSIHandling / lojbanLetter brivlaTailNoSIHandling;

String BRIVLANoBUHandling = consonant consonant lojbanLetter lojbanLetter brivlaTailNoBUHandling / consonant vowel consonant 'y'? consonant brivlaTailNoBUHandling / consonant vowel [']? vowel consonant consonant brivlaTailNoBUHandling;

String brivlaTailNoBUHandling = vowel spacingNoBUHandling / lojbanLetter brivlaTailNoBUHandling;

// CMENE <- /\.?[,'a-pr-z]+[bcdfgjklmnprstvxz]/
String CMENE = BAhE? cmeneLetter cmeneTail;

String cmeneTail = cmeneConsonant spacing / cmeneLetter cmeneTail;

String CMENENoSIHandling = cmeneLetter cmeneTailNoSIHandling;

String cmeneTailNoSIHandling = cmeneConsonant spacingNoSIHandling / cmeneLetter cmeneTailNoSIHandling;

String CMENENoBUHandling = cmeneLetter cmeneTailNoBUHandling;
String cmeneTailNoBUHandling = cmeneConsonant spacingNoBUHandling / cmeneLetter cmeneTailNoBUHandling;

// The "CMAVO-post" productions only occur after another cmavo as a
// test for whether another cmavo immediately follows, with  no
// intervening spaces; hence must start with consonant.
String CMAVOPost = !. / !vowel CMAVOConsonantCheck knownCmavo / !vowel CMAVOConsonantCheck consonant vowel (['] vowel / vowel)+;
String CMAVOPostNoSIHandling = !. / !vowel CMAVOConsonantCheck consonant vowel (['] vowel / vowel)*;
String CMAVOPostNoBUHandling = !. / !vowel CMAVOConsonantCheck consonant vowel (['] vowel / vowel)*;

String CMAVOConsonantCheck = !['] !( cmeneLetter cmeneLetter cmeneLetter consonant consonant / cmeneLetter cmeneLetter consonant consonant / cmeneLetter consonant consonant / consonant consonant ) ;

String CMAVO = CMAVOConsonantCheck knownCmavo postCmavoSpacing / CMAVOConsonantCheck consonant? vowel (['] vowel / vowel)+ postCmavoSpacing;
String CMAVONoSIHandling = CMAVOConsonantCheck consonant? vowel (['] vowel / vowel)* postCmavoNoSIHandling;
String CMAVONoSAHandling = CMAVOConsonantCheck consonant? vowel (['] vowel / vowel)* postCmavo;
String CMAVONoBUHandling = CMAVOConsonantCheck consonant? vowel (['] vowel / vowel)* postCmavoNoBUHandling;

String knownCmavo = A / BAI / BAhE / BE / BEI / BEhO / BIhE / BIhI / BO / BOI / BU / BY / CAI / CAhA / CEI / CEhE / CO / COI / CU / CUhE / DAhO / DOI / DOhU / FA / FAhA / FAhO / FEhE / FEhU / FIhO / FOI / FUhA / FUhE / FUhO / GA / GAhO / GEhU / GI / GIhA / GOI / GOhA / GUhA / I / JA / JAI / JOI / JOhI / KE / KEI / KEhE / KI / KOhA / KU / KUhE / KUhO / LA / LAU / LAhE / LE / LEhU / LI / LIhU / LOhO / LOhU / LU / LUhU / MAI / MAhO / ME / MEhU / MOI / MOhE / MOhI / NA / NAI / NAhE / NAhU / NIhE / NIhO / NOI / NU / NUhA / NUhI / NUhU / PA / PEhE / PEhO / PU / RAhO / ROI / SA / SE / SEI / SEhU / SI / SOI / SU / TAhE / TEI / TEhU / TO / TOI / TUhE / TUhU / UI / VA / VAU / VEI / VEhA / VEhO / VIhA / VUhO / VUhU / XI / Y / ZAhO / ZEI / ZEhA / ZI / ZIhE / ZO / ZOI / ZOhU;

// Handling of what can go after a cmavo
String postCmavo = !BUBare postCmavoSpacing;
String postCmavoSpacing = postCmavoCheck siClause absorbIndicators*;
String postCmavoCheck = !. / spaces+ / &CMAVOPost / &BRIVLA / &CMENE;
String postCmavoNoSIHandling = siSpacing / &CMAVOPostNoSIHandling / &BRIVLA / &CMENE/ SI;
String postCmavoNoBUHandling = spacingNoBUHandling / &CMAVOPostNoBUHandling / &BRIVLA / &CMENE/ BU;

String preCmavo = BAhE? spacesNotY*;

// --- SELMAHO ---


//         eks; basic afterthought logical connectives 
String A = preCmavo ASaClause? AWords postCmavo;
String ANoSAHandling = preCmavo AWords postCmavo;
String ASaClause = AWords spaces* ASaTail;
String ASaTail = SA &(preCmavo AWords) / !AWords anyWordNoSAHandling ASaTail;
String AWords = "a" / "e" / "ji" / "o" / "u";

//         modal operators 
String BAI = preCmavo BAISaClause? BAIWords postCmavo;
String BAINoSAHandling = preCmavo BAIWords postCmavo;
String BAISaClause = BAIWords spaces* BAISaTail;
String BAISaTail = SA &(preCmavo BAIWords) / !BAIWords anyWordNoSAHandling BAISaTail;
String BAIWords = "du'o" / "si'u" / "zau" / "ki'i" / "du'i" / "cu'u" / "tu'i" / "ti'u" / "di'o" / "ji'u" / "ri'a" / "ni'i" / "mu'i" / "ki'u" / "va'u" / "koi" / "ca'i" / "ta'i" / "pu'e" / "ja'i" / "kai" / "bai" / "fi'e" / "de'i" / "ci'o" / "mau" / "mu'u" / "ri'i" / "ra'i" / "ka'a" / "pa'u" / "pa'a" / "le'a" / "ku'u" / "tai" / "bau" / "ma'i" / "ci'e" / "fau" / "po'i" / "cau" / "ma'e" / "ci'u" / "ra'a" / "pu'a" / "li'e" / "la'u" / "ba'i" / "ka'i" / "sau" / "fa'e" / "be'i" / "ti'i" / "ja'e" / "ga'a" / "va'o" / "ji'o" / "me'a" / "do'e" / "ji'e" / "pi'o" / "gau" / "zu'e" / "me'e" / "rai";
//         next word intensifier 
String BAhE = (BAhEWords postCmavo)+;
String BAhEWords = "ba'e" / "za'e";
//         sumti link to attach sumti to a selbri 
String BE = preCmavo BESaClause? BEWords postCmavo;
String BENoSAHandling = preCmavo BEWords postCmavo;
String BESaClause = BEWords spaces* BESaTail;
String BESaTail = SA &(preCmavo BEWords) / !BEWords anyWordNoSAHandling BESaTail;
String BEWords = "be";
//         multiple sumti separator between BE, BEI 
String BEI = preCmavo BEISaClause? BEIWords postCmavo;
String BEINoSAHandling = preCmavo BEIWords postCmavo;
String BEISaClause = BEIWords spaces* BEISaTail;
String BEISaTail = SA &(preCmavo BEIWords) / !BEIWords anyWordNoSAHandling BEISaTail;
String BEIWords = "bei";
//         terminates BEBEI specified descriptors 
String BEhO = preCmavo BEhOSaClause? BEhOWords postCmavo;
String BEhONoSAHandling = preCmavo BEhOWords postCmavo;
String BEhOSaClause = BEhOWords spaces* BEhOSaTail;
String BEhOSaTail = SA &(preCmavo BEhOWords) / !BEhOWords anyWordNoSAHandling BEhOSaTail;
String BEhOWords = "be'o";
//         prefix for high-priority MEX operator 
String BIhE = preCmavo BIhESaClause? BIhEWords postCmavo;
String BIhENoSAHandling = preCmavo BIhEWords postCmavo;
String BIhESaClause = BIhEWords spaces* BIhESaTail;
String BIhESaTail = SA &(preCmavo BIhEWords) / !BIhEWords anyWordNoSAHandling BIhESaTail;
String BIhEWords = "bi'e";
//         interval component of JOI 
String BIhI = preCmavo BIhISaClause? BIhIWords postCmavo;
String BIhINoSAHandling = preCmavo BIhIWords postCmavo;
String BIhISaClause = BIhIWords spaces* BIhISaTail;
String BIhISaTail = SA &(preCmavo BIhIWords) / !BIhIWords anyWordNoSAHandling BIhISaTail;
String BIhIWords = "mi'i" / "bi'o" / "bi'i";
//         joins two units with shortest scope 
String BO = preCmavo BOSaClause? BOWords postCmavo;
String BONoSAHandling = preCmavo BOWords postCmavo;
String BOSaClause = BOWords spaces* BOSaTail;
String BOSaTail = SA &(preCmavo BOWords) / !BOWords anyWordNoSAHandling BOSaTail;
String BOWords = "bo";
//         number or lerfu-string terminator 
String BOI = preCmavo BOISaClause? BOIWords postCmavo;
String BOINoSAHandling = preCmavo BOIWords postCmavo;
String BOISaClause = BOIWords spaces* BOISaTail;
String BOISaTail = SA &(preCmavo BOIWords) / !BOIWords anyWordNoSAHandling BOISaTail;
String BOIWords = "boi";
//         turns any word into a BY lerfu word 
String BU = BUWords postCmavoNoBUHandling;
String BUWords = "bu";
String BUBare = spacesNotY* !['] !( cmeneLetter cmeneLetter cmeneLetter consonant consonant / cmeneLetter cmeneLetter consonant consonant / cmeneLetter consonant consonant / consonant consonant ) "bu" !['] spacesNotY*;
//         individual lerfu words 
String BY = preCmavo BYSaClause? BYWords postCmavo;
String BYNoSAHandling = preCmavo BYWords postCmavo;
String BYSaClause = BYWords spaces* BYSaTail;
String BYSaTail = SA &(preCmavo BYWords) / !BYWords anyWordNoSAHandling BYSaTail;
String BYWords = "jo'o" / "ru'o" / "ge'o" / "je'o" / "lo'a" / "na'a" / "se'e" / "to'a" / "ga'e" / "y'y" / "by" / "cy" / "dy" / "fy" / "gy" / "jy" / "ky" / "ly" / "my" / "ny" / "py" / "ry" / "sy" / "ty" / "vy" / "xy" / "zy";

//         specifies actualitypotentiality of tense 
String CAhA = preCmavo CAhASaClause? CAhAWords postCmavo;
String CAhANoSAHandling = preCmavo CAhAWords postCmavo;
String CAhASaClause = CAhAWords spaces* CAhASaTail;
String CAhASaTail = SA &(preCmavo CAhAWords) / !CAhAWords anyWordNoSAHandling CAhASaTail;
String CAhAWords = "ca'a" / "pu'i" / "nu'o" / "ka'e";
//         afterthought intensity marker 
String CAI = preCmavo CAISaClause? CAIWords postCmavo;
String CAINoSAHandling = preCmavo CAIWords postCmavo;
String CAISaClause = CAIWords spaces* CAISaTail;
String CAISaTail = SA &(preCmavo CAIWords) / !CAIWords anyWordNoSAHandling CAISaTail;
String CAIWords = "pei" / "cai" / "cu'i" / "sai" / "ru'e";
//         pro-bridi assignment operator 
String CEI = preCmavo CEISaClause? CEIWords postCmavo;
String CEINoSAHandling = preCmavo CEIWords postCmavo;
String CEISaClause = CEIWords spaces* CEISaTail;
String CEISaTail = SA &(preCmavo CEIWords) / !CEIWords anyWordNoSAHandling CEISaTail;
String CEIWords = "cei";
//         afterthought term list connective 
String CEhE = preCmavo CEhESaClause? CEhEWords postCmavo;
String CEhENoSAHandling = preCmavo CEhEWords postCmavo;
String CEhESaClause = CEhEWords spaces* CEhESaTail;
String CEhESaTail = SA &(preCmavo CEhEWords) / !CEhEWords anyWordNoSAHandling CEhESaTail;
String CEhEWords = "ce'e";
//         names; require consonant end, then pause no
//                                    LA or DOI selma'o embedded, pause before if
//                                    vowel initial and preceded by a vowel 
//         tanru inversion  
String CO = preCmavo COSaClause? COWords postCmavo;
String CONoSAHandling = preCmavo COWords postCmavo;
String COSaClause = COWords spaces* COSaTail;
String COSaTail = SA &(preCmavo COWords) / !COWords anyWordNoSAHandling COSaTail;
String COWords = "co";
String COI = preCmavo COISaClause? COIWords postCmavo;
String COINoSAHandling = preCmavo COIWords postCmavo;
String COISaClause = COIWords spaces* COISaTail;
String COISaTail = SA &(preCmavo COIWords) / !COIWords anyWordNoSAHandling COISaTail;
String COIWords = "ju'i" / "coi" / "fi'i" / "ta'a" / "mu'o" / "fe'o" / "co'o" / "pe'u" / "ke'o" / "nu'e" / "re'i" / "be'e" / "je'e" / "mi'e" / "ki'e" / "vi'o";
//         vocative marker permitted inside names; must
//                                    always be followed by pause or DOI 
//         separator between head sumti and selbri 
String CU = preCmavo CUSaClause? CUWords postCmavo;
String CUNoSAHandling = preCmavo CUWords postCmavo;
String CUSaClause = CUWords spaces* CUSaTail;
String CUSaTail = SA &(preCmavo CUWords) / !CUWords anyWordNoSAHandling CUSaTail;
String CUWords = "cu";
//         tensemodal question 
String CUhE = preCmavo CUhESaClause? CUhEWords postCmavo;
String CUhENoSAHandling = preCmavo CUhEWords postCmavo;
String CUhESaClause = CUhEWords spaces* CUhESaTail;
String CUhESaTail = SA &(preCmavo CUhEWords) / !CUhEWords anyWordNoSAHandling CUhESaTail;
String CUhEWords = "cu'e" / "nau";

//         cancel anaphoracataphora assignments 
String DAhO = preCmavo DAhOSaClause? DAhOWords postCmavo;
String DAhONoSAHandling = preCmavo DAhOWords postCmavo;
String DAhOSaClause = DAhOWords spaces* DAhOSaTail;
String DAhOSaTail = SA &(preCmavo DAhOWords) / !DAhOWords anyWordNoSAHandling DAhOSaTail;
String DAhOWords = "da'o";
//         vocative marker 
String DOI = preCmavo DOISaClause? DOIWords postCmavo;
String DOINoSAHandling = preCmavo DOIWords postCmavo;
String DOISaClause = DOIWords spaces* DOISaTail;
String DOISaTail = SA &(preCmavo DOIWords) / !DOIWords anyWordNoSAHandling DOISaTail;
String DOIWords = "doi";
//         terminator for DOI-marked vocatives 
String DOhU = preCmavo DOhUSaClause? DOhUWords postCmavo;
String DOhUNoSAHandling = preCmavo DOhUWords postCmavo;
String DOhUSaClause = DOhUWords spaces* DOhUSaTail;
String DOhUSaTail = SA &(preCmavo DOhUWords) / !DOhUWords anyWordNoSAHandling DOhUSaTail;
String DOhUWords = "do'u";

//         modifier head generic case tag 
String FA = preCmavo FASaClause? FAWords postCmavo;
String FANoSAHandling = preCmavo FAWords postCmavo;
String FASaClause = FAWords spaces* FASaTail;
String FASaTail = SA &(preCmavo FAWords) / !FAWords anyWordNoSAHandling FASaTail;
String FAWords = "fai" / "fa" / "fe" / "fo" / "fu" / "fi'a" / "fi";
//         superdirections in space 
String FAhA = preCmavo FAhASaClause? FAhAWords postCmavo;
String FAhANoSAHandling = preCmavo FAhAWords postCmavo;
String FAhASaClause = FAhAWords spaces* FAhASaTail;
String FAhASaTail = SA &(preCmavo FAhAWords) / !FAhAWords anyWordNoSAHandling FAhASaTail;
String FAhAWords = "du'a" / "be'a" / "ne'u" / "vu'a" / "ga'u" / "ti'a" / "ni'a" / "ca'u" / "zu'a" / "ri'u" / "ru'u" / "re'o" / "te'e" / "bu'u" / "ne'a" / "pa'o" / "ne'i" / "to'o" / "zo'i" / "ze'o" / "zo'a" / "fa'a";
String FAhO = preCmavo FAhOSaClause? FAhOWords postCmavo;
String FAhONoSAHandling = preCmavo FAhOWords postCmavo;
String FAhOSaClause = FAhOWords spaces* FAhOSaTail;
String FAhOSaTail = SA &(preCmavo FAhOWords) / !FAhOWords anyWordNoSAHandling FAhOSaTail;
String FAhOWords = "fa'o";
//         normally elided 'done pause' to indicate end
//                                    of utterance string 
//         space interval mod flag 
String FEhE = preCmavo FEhESaClause? FEhEWords postCmavo;
String FEhENoSAHandling = preCmavo FEhEWords postCmavo;
String FEhESaClause = FEhEWords spaces* FEhESaTail;
String FEhESaTail = SA &(preCmavo FEhEWords) / !FEhEWords anyWordNoSAHandling FEhESaTail;
String FEhEWords = "fe'e";
//         ends bridi to modal conversion 
String FEhU = preCmavo FEhUSaClause? FEhUWords postCmavo;
String FEhUNoSAHandling = preCmavo FEhUWords postCmavo;
String FEhUSaClause = FEhUWords spaces* FEhUSaTail;
String FEhUSaTail = SA &(preCmavo FEhUWords) / !FEhUWords anyWordNoSAHandling FEhUSaTail;
String FEhUWords = "fe'u";
//         marks bridi to modal conversion 
String FIhO = preCmavo FIhOSaClause? FIhOWords postCmavo;
String FIhONoSAHandling = preCmavo FIhOWords postCmavo;
String FIhOSaClause = FIhOWords spaces* FIhOSaTail;
String FIhOSaTail = SA &(preCmavo FIhOWords) / !FIhOWords anyWordNoSAHandling FIhOSaTail;
String FIhOWords = "fi'o";
//         end compound lerfu 
String FOI = preCmavo FOISaClause? FOIWords postCmavo;
String FOINoSAHandling = preCmavo FOIWords postCmavo;
String FOISaClause = FOIWords spaces* FOISaTail;
String FOISaTail = SA &(preCmavo FOIWords) / !FOIWords anyWordNoSAHandling FOISaTail;
String FOIWords = "foi";
//         reverse Polish flag 
String FUhA = preCmavo FUhASaClause? FUhAWords postCmavo;
String FUhANoSAHandling = preCmavo FUhAWords postCmavo;
String FUhASaClause = FUhAWords spaces* FUhASaTail;
String FUhASaTail = SA &(preCmavo FUhAWords) / !FUhAWords anyWordNoSAHandling FUhASaTail;
String FUhAWords = "fu'a";
//         open long scope for indicator 
String FUhE = preCmavo FUhESaClause? FUhEWords postCmavo;
String FUhENoSAHandling = preCmavo FUhEWords postCmavo;
String FUhESaClause = FUhEWords spaces* FUhESaTail;
String FUhESaTail = SA &(preCmavo FUhEWords) / !FUhEWords anyWordNoSAHandling FUhESaTail;
String FUhEWords = "fu'e";
//         close long scope for indicator 
String FUhO = preCmavo FUhOSaClause? FUhOWords postCmavo;
String FUhONoSAHandling = preCmavo FUhOWords postCmavo;
String FUhOSaClause = FUhOWords spaces* FUhOSaTail;
String FUhOSaTail = SA &(preCmavo FUhOWords) / !FUhOWords anyWordNoSAHandling FUhOSaTail;
String FUhOWords = "fu'o";

//         geks; forethought logical connectives 
String GA = preCmavo GASaClause? GAWords postCmavo;
String GANoSAHandling = preCmavo GAWords postCmavo;
String GASaClause = GAWords spaces* GASaTail;
String GASaTail = SA &(preCmavo GAWords) / !GAWords anyWordNoSAHandling GASaTail;
String GAWords = "ge'i" / "ge" /  "go" / "ga" / "gu";
//         openclosed interval markers for BIhI 
String GAhO = preCmavo GAhOSaClause? GAhOWords postCmavo;
String GAhONoSAHandling = preCmavo GAhOWords postCmavo;
String GAhOSaClause = GAhOWords spaces* GAhOSaTail;
String GAhOSaTail = SA &(preCmavo GAhOWords) / !GAhOWords anyWordNoSAHandling GAhOSaTail;
String GAhOWords = "ke'i" / "ga'o";
//         marker ending GOI relative clauses 
String GEhU = preCmavo GEhUSaClause? GEhUWords postCmavo;
String GEhUNoSAHandling = preCmavo GEhUWords postCmavo;
String GEhUSaClause = GEhUWords spaces* GEhUSaTail;
String GEhUSaTail = SA &(preCmavo GEhUWords) / !GEhUWords anyWordNoSAHandling GEhUSaTail;
String GEhUWords = "ge'u";
//         forethought medial marker 
String GI = preCmavo GISaClause? GIWords postCmavo;
String GINoSAHandling = preCmavo GIWords postCmavo;
String GISaClause = GIWords spaces* GISaTail;
String GISaTail = SA &(preCmavo GIWords) / !GIWords anyWordNoSAHandling GISaTail;
String GIWords = "gi";
//         logical connectives for bridi-tails 
String GIhA = preCmavo GIhASaClause? GIhAWords postCmavo;
String GIhANoSAHandling = preCmavo GIhAWords postCmavo;
String GIhASaClause = GIhAWords spaces* GIhASaTail;
String GIhASaTail = SA &(preCmavo GIhAWords) / !GIhAWords anyWordNoSAHandling GIhASaTail;
String GIhAWords = "gi'e" / "gi'i" / "gi'o" / "gi'a" / "gi'u";
//         attaches a sumti modifier to a sumti 
String GOI = preCmavo GOISaClause? GOIWords postCmavo;
String GOINoSAHandling = preCmavo GOIWords postCmavo;
String GOISaClause = GOIWords spaces* GOISaTail;
String GOISaTail = SA &(preCmavo GOIWords) / !GOIWords anyWordNoSAHandling GOISaTail;
String GOIWords = "no'u" / "ne" / "goi" / "po'u" / "pe" / "po'e" / "po";
//         pro-bridi 
String GOhA = preCmavo GOhASaClause? GOhAWords postCmavo;
String GOhANoSAHandling = preCmavo GOhAWords postCmavo;
String GOhASaClause = GOhAWords spaces* GOhASaTail;
String GOhASaTail = SA &(preCmavo GOhAWords) / !GOhAWords anyWordNoSAHandling GOhASaTail;
String GOhAWords = "mo" / "nei" / "go'u" / "go'o" / "go'i" / "no'a" / "go'e" / "go'a" / "du" / "bu'a" / "bu'e" / "bu'i" / "co'e";
//         GEK for tanru units, corresponds to JEKs 
String GUhA = preCmavo GUhASaClause? GUhAWords postCmavo;
String GUhANoSAHandling = preCmavo GUhAWords postCmavo;
String GUhASaClause = GUhAWords spaces* GUhASaTail;
String GUhASaTail = SA &(preCmavo GUhAWords) / !GUhAWords anyWordNoSAHandling GUhASaTail;
String GUhAWords = "gu'e" / "gu'i" / "gu'o" / "gu'a" / "gu'u";

//         sentence link 
String I = preCmavo ISaClause? IWords postCmavo;
String INoSAHandling = preCmavo IWords postCmavo;
String ISaClause = IWords spaces* ISaTail;
String ISaTail = SA &(preCmavo IWords) / !IWords anyWordNoSAHandling ISaTail;
String IWords = "i";

//         jeks; logical connectives within tanru 
String JA = preCmavo JASaClause? JAWords postCmavo;
String JANoSAHandling = preCmavo JAWords postCmavo;
String JASaClause = JAWords spaces* JASaTail;
String JASaTail = SA &(preCmavo JAWords) / !JAWords anyWordNoSAHandling JASaTail;
String JAWords = "je'i" / "je" /  "jo" / "ja" / "ju";
//         modal conversion flag 
String JAI = preCmavo JAISaClause? JAIWords postCmavo;
String JAINoSAHandling = preCmavo JAIWords postCmavo;
String JAISaClause = JAIWords spaces* JAISaTail;
String JAISaTail = SA &(preCmavo JAIWords) / !JAIWords anyWordNoSAHandling JAISaTail;
String JAIWords = "jai";
//         flags an array operand 
String JOhI = preCmavo JOhISaClause? JOhIWords postCmavo;
String JOhINoSAHandling = preCmavo JOhIWords postCmavo;
String JOhISaClause = JOhIWords spaces* JOhISaTail;
String JOhISaTail = SA &(preCmavo JOhIWords) / !JOhIWords anyWordNoSAHandling JOhISaTail;
String JOhIWords = "jo'i";
//         non-logical connectives 
String JOI = preCmavo JOISaClause? JOIWords postCmavo;
String JOINoSAHandling = preCmavo JOIWords postCmavo;
String JOISaClause = JOIWords spaces* JOISaTail;
String JOISaTail = SA &(preCmavo JOIWords) / !JOIWords anyWordNoSAHandling JOISaTail;
String JOIWords = "fa'u" / "pi'u" / "joi" / "ce'o" / "ce" / "jo'u" / "ku'a" / "jo'e" / "ju'e";

//         left long scope marker 
String KE = preCmavo KESaClause? KEWords postCmavo;
String KENoSAHandling = preCmavo KEWords postCmavo;
String KESaClause = KEWords spaces* KESaTail;
String KESaTail = SA &(preCmavo KEWords) / !KEWords anyWordNoSAHandling KESaTail;
String KEWords = "ke";
//         right terminator for KE groups 
String KEhE = preCmavo KEhESaClause? KEhEWords postCmavo;
String KEhENoSAHandling = preCmavo KEhEWords postCmavo;
String KEhESaClause = KEhEWords spaces* KEhESaTail;
String KEhESaTail = SA &(preCmavo KEhEWords) / !KEhEWords anyWordNoSAHandling KEhESaTail;
String KEhEWords = "ke'e";
//         right terminator, NU abstractions 
String KEI = preCmavo KEISaClause? KEIWords postCmavo;
String KEINoSAHandling = preCmavo KEIWords postCmavo;
String KEISaClause = KEIWords spaces* KEISaTail;
String KEISaTail = SA &(preCmavo KEIWords) / !KEIWords anyWordNoSAHandling KEISaTail;
String KEIWords = "kei";
//         multiple utterance scope for tenses 
String KI = preCmavo KISaClause? KIWords postCmavo;
String KINoSAHandling = preCmavo KIWords postCmavo;
String KISaClause = KIWords spaces* KISaTail;
String KISaTail = SA &(preCmavo KIWords) / !KIWords anyWordNoSAHandling KISaTail;
String KIWords = "ki";
//         sumti anaphora 
String KOhA = preCmavo KOhASaClause? KOhAWords postCmavo;
String KOhANoSAHandling = preCmavo KOhAWords postCmavo;
String KOhASaClause = KOhAWords spaces* KOhASaTail;
String KOhASaTail = SA &(preCmavo KOhAWords) / !KOhAWords anyWordNoSAHandling KOhASaTail;
String KOhAWords = "da'u" / "da'e" / "di'u" / "di'e" / "de'u" / "de'e" / "dei" / "do'i" / "mi'o" / "ma'a" / "mi'a" / "do'o" / "ko'a" / "fo'u" / "ko'e" / "ko'i" / "ko'o" / "ko'u" / "fo'a" / "fo'e" / "fo'i" / "fo'o" / "vo'a" / "vo'e" / "vo'i" / "vo'o" / "vo'u" / "ru" / "ri" / "ra" / "ta" / "tu" / "ti" / "zi'o" / "ke'a" / "ma" / "zu'i" / "zo'e" / "ce'u" / "da" / "de" / "di" / "ko" / "mi" / "do";
//         right terminator for descriptions, etc. 
String KU = preCmavo KUSaClause? KUWords postCmavo;
String KUNoSAHandling = preCmavo KUWords postCmavo;
String KUSaClause = KUWords spaces* KUSaTail;
String KUSaTail = SA &(preCmavo KUWords) / !KUWords anyWordNoSAHandling KUSaTail;
String KUWords = "ku";
//         MEX forethought delimiter 
String KUhE = preCmavo KUhESaClause? KUhEWords postCmavo;
String KUhENoSAHandling = preCmavo KUhEWords postCmavo;
String KUhESaClause = KUhEWords spaces* KUhESaTail;
String KUhESaTail = SA &(preCmavo KUhEWords) / !KUhEWords anyWordNoSAHandling KUhESaTail;
String KUhEWords = "ku'e";
//         right terminator, NOI relative clauses 
String KUhO = preCmavo KUhOSaClause? KUhOWords postCmavo;
String KUhONoSAHandling = preCmavo KUhOWords postCmavo;
String KUhOSaClause = KUhOWords spaces* KUhOSaTail;
String KUhOSaTail = SA &(preCmavo KUhOWords) / !KUhOWords anyWordNoSAHandling KUhOSaTail;
String KUhOWords = "ku'o";

//         name descriptors 
String LA = preCmavo LASaClause? LAWords postCmavo;
String LANoSAHandling = preCmavo LAWords postCmavo;
String LASaClause = LAWords spaces* LASaTail;
String LASaTail = SA &(preCmavo LAWords) / !LAWords anyWordNoSAHandling LASaTail;
String LAWords = "lai" / "la'i" / "la";
//         lerfu prefixes 
String LAU = preCmavo LAUSaClause? LAUWords postCmavo;
String LAUNoSAHandling = preCmavo LAUWords postCmavo;
String LAUSaClause = LAUWords spaces* LAUSaTail;
String LAUSaTail = SA &(preCmavo LAUWords) / !LAUWords anyWordNoSAHandling LAUSaTail;
String LAUWords = "ce'a" / "lau" / "zai" / "tau";
//         sumti qualifiers 
String LAhE = preCmavo LAhESaClause? LAhEWords postCmavo;
String LAhENoSAHandling = preCmavo LAhEWords postCmavo;
String LAhESaClause = LAhEWords spaces* LAhESaTail;
String LAhESaTail = SA &(preCmavo LAhEWords) / !LAhEWords anyWordNoSAHandling LAhESaTail;
String LAhEWords = "tu'a" / "lu'a" / "lu'o" / "la'e" / "vu'i" / "lu'i" / "lu'e";
//         sumti descriptors 
String LE = preCmavo LESaClause? LEWords postCmavo;
String LENoSAHandling = preCmavo LEWords postCmavo;
String LESaClause = LEWords spaces* LESaTail;
String LESaTail = SA &(preCmavo LEWords) / !LEWords anyWordNoSAHandling LESaTail;
String LEWords = "lei" / "loi" / "le'i" / "lo'i" / "le'e" / "lo'e" / "lo" / "le";
//         possibly ungrammatical text right quote 
String LEhU = preCmavo LEhUSaClause? LEhUWords postCmavo;
String LEhUNoSAHandling = preCmavo LEhUWords postCmavo;
String LEhUSaClause = LEhUWords spaces* LEhUSaTail;
String LEhUSaTail = SA &(preCmavo LEhUWords) / !LEhUWords anyWordNoSAHandling LEhUSaTail;
String LEhUNoSIHandling = preCmavo LEhUWords postCmavoNoSIHandling;
String LEhUWords = "le'u";
//         convert number to sumti 
String LI = preCmavo LISaClause? LIWords postCmavo;
String LINoSAHandling = preCmavo LIWords postCmavo;
String LISaClause = LIWords spaces* LISaTail;
String LISaTail = SA &(preCmavo LIWords) / !LIWords anyWordNoSAHandling LISaTail;
String LIWords = "me'o" / "li";
//         grammatical text right quote 
String LIhU = preCmavo LIhUSaClause? LIhUWords postCmavo;
String LIhUNoSAHandling = preCmavo LIhUWords postCmavo;
String LIhUSaClause = LIhUWords spaces* LIhUSaTail;
String LIhUSaTail = SA &(preCmavo LIhUWords) / !LIhUWords anyWordNoSAHandling LIhUSaTail;
String LIhUWords = "li'u";
//         elidable terminator for LI 
String LOhO = preCmavo LOhOSaClause? LOhOWords postCmavo;
String LOhONoSAHandling = preCmavo LOhOWords postCmavo;
String LOhOSaClause = LOhOWords spaces* LOhOSaTail;
String LOhOSaTail = SA &(preCmavo LOhOWords) / !LOhOWords anyWordNoSAHandling LOhOSaTail;
String LOhOWords = "lo'o";
//         possibly ungrammatical text left quote 
String LOhU = preCmavo LOhUWords postCmavoNoSIHandling;
String LOhUWords = "lo'u";
//         grammatical text left quote 
String LU = preCmavo LUSaClause? LUWords postCmavo;
String LUNoSAHandling = preCmavo LUWords postCmavo;
String LUSaClause = LUWords spaces* LUSaTail;
String LUSaTail = SA &(preCmavo LUWords) / !LUWords anyWordNoSAHandling LUSaTail;
String LUWords = "lu";
//         LAhE close delimiter 
String LUhU = preCmavo LUhUSaClause? LUhUWords postCmavo;
String LUhUNoSAHandling = preCmavo LUhUWords postCmavo;
String LUhUSaClause = LUhUWords spaces* LUhUSaTail;
String LUhUSaTail = SA &(preCmavo LUhUWords) / !LUhUWords anyWordNoSAHandling LUhUSaTail;
String LUhUWords = "lu'u";

//         change MEX expressions to MEX operators 
String MAhO = preCmavo MAhOSaClause? MAhOWords postCmavo;
String MAhONoSAHandling = preCmavo MAhOWords postCmavo;
String MAhOSaClause = MAhOWords spaces* MAhOSaTail;
String MAhOSaTail = SA &(preCmavo MAhOWords) / !MAhOWords anyWordNoSAHandling MAhOSaTail;
String MAhOWords = "ma'o";
//         change numbers to utterance ordinals 
String MAI = preCmavo MAISaClause? MAIWords postCmavo;
String MAINoSAHandling = preCmavo MAIWords postCmavo;
String MAISaClause = MAIWords spaces* MAISaTail;
String MAISaTail = SA &(preCmavo MAIWords) / !MAIWords anyWordNoSAHandling MAISaTail;
String MAIWords = "mo'o" / "mai";
//         converts a sumti into a tanru_unit 
String ME = preCmavo MESaClause? MEWords postCmavo;
String MENoSAHandling = preCmavo MEWords postCmavo;
String MESaClause = MEWords spaces* MESaTail;
String MESaTail = SA &(preCmavo MEWords) / !MEWords anyWordNoSAHandling MESaTail;
String MEWords = "me";
//         terminator for ME 
String MEhU = preCmavo MEhUSaClause? MEhUWords postCmavo;
String MEhUNoSAHandling = preCmavo MEhUWords postCmavo;
String MEhUSaClause = MEhUWords spaces* MEhUSaTail;
String MEhUSaTail = SA &(preCmavo MEhUWords) / !MEhUWords anyWordNoSAHandling MEhUSaTail;
String MEhUWords = "me'u";
//         change sumti to operand, inverse of LI 
String MOhE = preCmavo MOhESaClause? MOhEWords postCmavo;
String MOhENoSAHandling = preCmavo MOhEWords postCmavo;
String MOhESaClause = MOhEWords spaces* MOhESaTail;
String MOhESaTail = SA &(preCmavo MOhEWords) / !MOhEWords anyWordNoSAHandling MOhESaTail;
String MOhEWords = "mo'e";
//         motion tense marker 
String MOhI = preCmavo MOhISaClause? MOhIWords postCmavo;
String MOhINoSAHandling = preCmavo MOhIWords postCmavo;
String MOhISaClause = MOhIWords spaces* MOhISaTail;
String MOhISaTail = SA &(preCmavo MOhIWords) / !MOhIWords anyWordNoSAHandling MOhISaTail;
String MOhIWords = "mo'i";
//         change number to selbri 
String MOI = preCmavo MOISaClause? MOIWords postCmavo;
String MOINoSAHandling = preCmavo MOIWords postCmavo;
String MOISaClause = MOIWords spaces* MOISaTail;
String MOISaTail = SA &(preCmavo MOIWords) / !MOIWords anyWordNoSAHandling MOISaTail;
String MOIWords = "mei" / "moi" / "si'e" / "cu'o" / "va'e";

//         bridi negation  
String NA = preCmavo NASaClause? NAWords postCmavo;
String NANoSAHandling = preCmavo NAWords postCmavo;
String NASaClause = NAWords spaces* NASaTail;
String NASaTail = SA &(preCmavo NAWords) / !NAWords anyWordNoSAHandling NASaTail;
String NAWords = "ja'a" / "na";
//         attached to words to negate them 
String NAI = preCmavo NAISaClause? NAIWords postCmavo;
String NAINoSAHandling = preCmavo NAIWords postCmavo;
String NAISaClause = NAIWords spaces* NAISaTail;
String NAISaTail = SA &(preCmavo NAIWords) / !NAIWords anyWordNoSAHandling NAISaTail;
String NAIWords = "nai";
//         scalar negation  
String NAhE = preCmavo NAhESaClause? NAhEWords postCmavo;
String NAhENoSAHandling = preCmavo NAhEWords postCmavo;
String NAhESaClause = NAhEWords spaces* NAhESaTail;
String NAhESaTail = SA &(preCmavo NAhEWords) / !NAhEWords anyWordNoSAHandling NAhESaTail;
String NAhEWords = "to'e" / "je'a" / "na'e" / "no'e";
//         change a selbri into an operator 
String NAhU = preCmavo NAhUSaClause? NAhUWords postCmavo;
String NAhUNoSAHandling = preCmavo NAhUWords postCmavo;
String NAhUSaClause = NAhUWords spaces* NAhUSaTail;
String NAhUSaTail = SA &(preCmavo NAhUWords) / !NAhUWords anyWordNoSAHandling NAhUSaTail;
String NAhUWords = "na'u";
//         change selbri to operand; inverse of MOI 
String NIhE = preCmavo NIhESaClause? NIhEWords postCmavo;
String NIhENoSAHandling = preCmavo NIhEWords postCmavo;
String NIhESaClause = NIhEWords spaces* NIhESaTail;
String NIhESaTail = SA &(preCmavo NIhEWords) / !NIhEWords anyWordNoSAHandling NIhESaTail;
String NIhEWords = "ni'e";
//         new paragraph; change of subject 
String NIhO = preCmavo NIhOSaClause? NIhOWords suClause* postCmavo;
String NIhONoSAHandling = preCmavo NIhOWords suClause* postCmavo;
String NIhOSaClause = NIhOWords spaces* NIhOSaTail;
String NIhOSaTail = SA &(preCmavo NIhOWords) / !NIhOWords anyWordNoSAHandling NIhOSaTail;
String NIhOWords = "ni'o" / "no'i";
//         attaches a subordinate clause to a sumti 
String NOI = preCmavo NOISaClause? NOIWords postCmavo;
String NOINoSAHandling = preCmavo NOIWords postCmavo;
String NOISaClause = NOIWords spaces* NOISaTail;
String NOISaTail = SA &(preCmavo NOIWords) / !NOIWords anyWordNoSAHandling NOISaTail;
String NOIWords = "voi" / "noi" / "poi";
//         abstraction  
String NU = preCmavo NUSaClause? NUWords postCmavo;
String NUNoSAHandling = preCmavo NUWords postCmavo;
String NUSaClause = NUWords spaces* NUSaTail;
String NUSaTail = SA &(preCmavo NUWords) / !NUWords anyWordNoSAHandling NUSaTail;
String NUWords = "ni" / "du'u" / "si'o" / "nu" / "li'i" / "ka" / "jei" / "su'u" / "zu'o" / "mu'e" / "pu'u" / "za'i";
//         change operator to selbri; inverse of MOhE 
String NUhA = preCmavo NUhASaClause? NUhAWords postCmavo;
String NUhANoSAHandling = preCmavo NUhAWords postCmavo;
String NUhASaClause = NUhAWords spaces* NUhASaTail;
String NUhASaTail = SA &(preCmavo NUhAWords) / !NUhAWords anyWordNoSAHandling NUhASaTail;
String NUhAWords = "nu'a";
//         marks the start of a termset 
String NUhI = preCmavo NUhISaClause? NUhIWords postCmavo;
String NUhINoSAHandling = preCmavo NUhIWords postCmavo;
String NUhISaClause = NUhIWords spaces* NUhISaTail;
String NUhISaTail = SA &(preCmavo NUhIWords) / !NUhIWords anyWordNoSAHandling NUhISaTail;
String NUhIWords = "nu'i";
//         marks the middle and end of a termset 
String NUhU = preCmavo NUhUSaClause? NUhUWords postCmavo;
String NUhUNoSAHandling = preCmavo NUhUWords postCmavo;
String NUhUSaClause = NUhUWords spaces* NUhUSaTail;
String NUhUSaTail = SA &(preCmavo NUhUWords) / !NUhUWords anyWordNoSAHandling NUhUSaTail;
String NUhUWords = "nu'u";

//         numbers and numeric punctuation 
String PA = preCmavo PASaClause? PAWords postCmavo;
String PANoSAHandling = preCmavo PAWords postCmavo;
String PASaClause = PAWords spaces* PASaTail;
String PASaTail = SA &(preCmavo PAWords) / !PAWords anyWordNoSAHandling PASaTail;
String PAWords = "dau" / "fei" / "gai" / "jau" / "rei" / "vai" / "pi'e" / "pi" /  "fi'u" / "za'u" / "me'i" / "ni'u" / "ki'o" / "ce'i" / "ma'u" / "ra'e" / "da'a" / "so'a" / "ji'i" / "su'o" / "su'e" / "ro" / "rau" / "so'u" / "so'i" / "so'e" / "so'o" / "mo'a" / "du'e" / "te'o" / "ka'o" / "ci'i" / "tu'o" / "xo" / "pai" / "no'o" / "no" / "pa" / "re" / "ci" / "vo" / "mu" / "xa" / "ze" / "bi" / "so";
//         afterthought termset connective prefix 
String PEhE = preCmavo PEhESaClause? PEhEWords postCmavo;
String PEhENoSAHandling = preCmavo PEhEWords postCmavo;
String PEhESaClause = PEhEWords spaces* PEhESaTail;
String PEhESaTail = SA &(preCmavo PEhEWords) / !PEhEWords anyWordNoSAHandling PEhESaTail;
String PEhEWords = "pe'e";
//         forethought (Polish) flag 
String PEhO = preCmavo PEhOSaClause? PEhOWords postCmavo;
String PEhONoSAHandling = preCmavo PEhOWords postCmavo;
String PEhOSaClause = PEhOWords spaces* PEhOSaTail;
String PEhOSaTail = SA &(preCmavo PEhOWords) / !PEhOWords anyWordNoSAHandling PEhOSaTail;
String PEhOWords = "pe'o";
//         directions in time 
String PU = preCmavo PUSaClause? PUWords postCmavo;
String PUNoSAHandling = preCmavo PUWords postCmavo;
String PUSaClause = PUWords spaces* PUSaTail;
String PUSaTail = SA &(preCmavo PUWords) / !PUWords anyWordNoSAHandling PUSaTail;
String PUWords = "ba" / "pu" / "ca";

//         flag for modified interpretation of GOhI 
String RAhO = preCmavo RAhOSaClause? RAhOWords postCmavo;
String RAhONoSAHandling = preCmavo RAhOWords postCmavo;
String RAhOSaClause = RAhOWords spaces* RAhOSaTail;
String RAhOSaTail = SA &(preCmavo RAhOWords) / !RAhOWords anyWordNoSAHandling RAhOSaTail;
String RAhOWords = "ra'o";
//         converts number to extensional tense 
String ROI = preCmavo ROISaClause? ROIWords postCmavo;
String ROINoSAHandling = preCmavo ROIWords postCmavo;
String ROISaClause = ROIWords spaces* ROISaTail;
String ROISaTail = SA &(preCmavo ROIWords) / !ROIWords anyWordNoSAHandling ROISaTail;
String ROIWords = "re'u" / "roi";

String SA = preCmavo SAWords postCmavo;
String SAWords = "sa";
//         metalinguistic eraser to the beginning of
//                                    the current utterance 
//         conversions 
String SE = preCmavo SESaClause? SEWords postCmavo;
String SENoSAHandling = preCmavo SEWords postCmavo;
String SESaClause = SEWords spaces* SESaTail;
String SESaTail = SA &(preCmavo SEWords) / !SEWords anyWordNoSAHandling SESaTail;
String SEWords = "se" / "te" / "ve" / "xe";
//         metalinguistic bridi insert marker 
String SEI = preCmavo SEISaClause? SEIWords postCmavo;
String SEINoSAHandling = preCmavo SEIWords postCmavo;
String SEISaClause = SEIWords spaces* SEISaTail;
String SEISaTail = SA &(preCmavo SEIWords) / !SEIWords anyWordNoSAHandling SEISaTail;
String SEIWords = "sei" / "ti'o";
//         metalinguistic bridi end marker 
String SEhU = preCmavo SEhUSaClause? SEhUWords postCmavo;
String SEhUNoSAHandling = preCmavo SEhUWords postCmavo;
String SEhUSaClause = SEhUWords spaces* SEhUSaTail;
String SEhUSaTail = SA &(preCmavo SEhUWords) / !SEhUWords anyWordNoSAHandling SEhUSaTail;
String SEhUWords = "se'u";
//         metalinguistic single word eraser 
String SI = SIWords postCmavoNoSIHandling;
String SIWords = "si";
//         reciprocal sumti marker 
String SOI = preCmavo SOISaClause? SOIWords postCmavo;
String SOINoSAHandling = preCmavo SOIWords postCmavo;
String SOISaClause = SOIWords spaces* SOISaTail;
String SOISaTail = SA &(preCmavo SOIWords) / !SOIWords anyWordNoSAHandling SOISaTail;
String SOIWords = "soi";
//         metalinguistic eraser of the entire text 
String SU = preCmavo SUSaClause? SUWords postCmavo;
String SUNoSAHandling = preCmavo SUWords postCmavo;
String SUSaClause = SUWords spaces* SUSaTail;
String SUSaTail = SA &(preCmavo SUWords) / !SUWords anyWordNoSAHandling SUSaTail;
String SUWords = "su";

//         tense interval properties 
String TAhE = preCmavo TAhESaClause? TAhEWords postCmavo;
String TAhENoSAHandling = preCmavo TAhEWords postCmavo;
String TAhESaClause = TAhEWords spaces* TAhESaTail;
String TAhESaTail = SA &(preCmavo TAhEWords) / !TAhEWords anyWordNoSAHandling TAhESaTail;
String TAhEWords = "ru'i" / "ta'e" / "di'i" / "na'o";
//         closing gap for MEX constructs 
String TEhU = preCmavo TEhUSaClause? TEhUWords postCmavo;
String TEhUNoSAHandling = preCmavo TEhUWords postCmavo;
String TEhUSaClause = TEhUWords spaces* TEhUSaTail;
String TEhUSaTail = SA &(preCmavo TEhUWords) / !TEhUWords anyWordNoSAHandling TEhUSaTail;
String TEhUWords = "te'u";
//         start compound lerfu 
String TEI = preCmavo TEISaClause? TEIWords postCmavo;
String TEINoSAHandling = preCmavo TEIWords postCmavo;
String TEISaClause = TEIWords spaces* TEISaTail;
String TEISaTail = SA &(preCmavo TEIWords) / !TEIWords anyWordNoSAHandling TEISaTail;
String TEIWords = "tei";
//         left discursive parenthesis 
String TO = preCmavo TOSaClause? TOWords postCmavo;
String TONoSAHandling = preCmavo TOWords postCmavo;
String TOSaClause = TOWords spaces* TOSaTail;
String TOSaTail = SA &(preCmavo TOWords) / !TOWords anyWordNoSAHandling TOSaTail;
String TOWords = "to'i" / "to";
//         right discursive parenthesis 
String TOI = preCmavo TOISaClause? TOIWords postCmavo;
String TOINoSAHandling = preCmavo TOIWords postCmavo;
String TOISaClause = TOIWords spaces* TOISaTail;
String TOISaTail = SA &(preCmavo TOIWords) / !TOIWords anyWordNoSAHandling TOISaTail;
String TOIWords = "toi";
//         multiple utterance scope mark 
String TUhE = preCmavo TUhESaClause? TUhEWords suClause* postCmavo;
String TUhENoSAHandling = preCmavo TUhEWords suClause* postCmavo;
String TUhESaClause = TUhEWords spaces* TUhESaTail;
String TUhESaTail = SA &(preCmavo TUhEWords) / !TUhEWords anyWordNoSAHandling TUhESaTail;
String TUhEWords = "tu'e";
//         multiple utterance end scope mark 
String TUhU = preCmavo TUhUSaClause? TUhUWords postCmavo;
String TUhUNoSAHandling = preCmavo TUhUWords postCmavo;
String TUhUSaClause = TUhUWords spaces* TUhUSaTail;
String TUhUSaTail = SA &(preCmavo TUhUWords) / !TUhUWords anyWordNoSAHandling TUhUSaTail;
String TUhUWords = "tu'u";

//         attitudinals, observationals, discursives 
String UI = preCmavo UISaClause? UIWords postCmavo;
String UINoSAHandling = preCmavo UIWords postCmavo;
String UISaClause = UIWords spaces* UISaTail;
String UISaTail = SA &(preCmavo UIWords) / !UIWords anyWordNoSAHandling UISaTail;
String UIWords = "i'a" / "ie" / "a'e" / "u'i" / "i'o" / "i'e" / "a'a" / "ia" / "o'i" / "o'e" / "e'e" / "oi" / "uo" / "e'i" / "u'o" / "au" / "ua" / "a'i" / "i'u" / "ii" / "u'a" / "ui" / "a'o" / "ai" / "a'u" / "iu" / "ei" / "o'o" / "e'a" / "uu" / "o'a" / "o'u" / "u'u" / "e'o" / "io" / "e'u" / "ue" / "i'i" / "u'e" / "ba'a" / "ja'o" / "ca'e" / "su'a" / "ti'e" / "ka'u" / "se'o" / "za'a" / "pe'i" / "ru'a" / "ju'a" / "ta'o" / "ra'u" / "li'a" / "ba'u" / "mu'a" / "do'a" / "to'u" / "va'i" / "pa'e" / "zu'u" / "sa'e" / "la'a" / "ke'u" / "sa'u" / "da'i" / "je'u" / "sa'a" / "kau" / "ta'u" / "na'i" / "jo'a" / "bi'u" / "li'o" / "pau" / "mi'u" / "ku'i" / "ji'a" / "si'a" / "po'o" / "pe'a" / "ro'i" / "ro'e" / "ro'o" / "ro'u" / "ro'a" / "re'e" / "le'o" / "ju'o" / "fu'i" / "dai" / "ga'i" / "zo'o" / "be'u" / "ri'e" / "se'i" / "se'a" / "vu'e" / "ki'a" / "xu" / "ge'e" / "bu'o";

//         distance in space-time 
String VA = preCmavo VASaClause? VAWords postCmavo;
String VANoSAHandling = preCmavo VAWords postCmavo;
String VASaClause = VAWords spaces* VASaTail;
String VASaTail = SA &(preCmavo VAWords) / !VAWords anyWordNoSAHandling VASaTail;
String VAWords = "vi" / "va" / "vu";
//         end simple bridi or bridi-tail 
String VAU = preCmavo VAUSaClause? VAUWords postCmavo;
String VAUNoSAHandling = preCmavo VAUWords postCmavo;
String VAUSaClause = VAUWords spaces* VAUSaTail;
String VAUSaTail = SA &(preCmavo VAUWords) / !VAUWords anyWordNoSAHandling VAUSaTail;
String VAUWords = "vau";
//         left MEX bracket 
String VEI = preCmavo VEISaClause? VEIWords postCmavo;
String VEINoSAHandling = preCmavo VEIWords postCmavo;
String VEISaClause = VEIWords spaces* VEISaTail;
String VEISaTail = SA &(preCmavo VEIWords) / !VEIWords anyWordNoSAHandling VEISaTail;
String VEIWords = "vei";
//         right MEX bracket 
String VEhO = preCmavo VEhOSaClause? VEhOWords postCmavo;
String VEhONoSAHandling = preCmavo VEhOWords postCmavo;
String VEhOSaClause = VEhOWords spaces* VEhOSaTail;
String VEhOSaTail = SA &(preCmavo VEhOWords) / !VEhOWords anyWordNoSAHandling VEhOSaTail;
String VEhOWords = "ve'o";
//         MEX operator 
String VUhU = preCmavo VUhUSaClause? VUhUWords postCmavo;
String VUhUNoSAHandling = preCmavo VUhUWords postCmavo;
String VUhUSaClause = VUhUWords spaces* VUhUSaTail;
String VUhUSaTail = SA &(preCmavo VUhUWords) / !VUhUWords anyWordNoSAHandling VUhUSaTail;
String VUhUWords = "ge'a" / "fu'u" / "pi'i" / "fe'i" / "vu'u" / "su'i" / "ju'u" / "gei" / "pa'i" / "fa'i" / "te'a" / "cu'a" / "va'a" / "ne'o" / "de'o" / "fe'a" / "sa'o" / "re'a" / "ri'o" / "sa'i" / "pi'a" / "si'i";
//         space-time interval size 
String VEhA = preCmavo VEhASaClause? VEhAWords postCmavo;
String VEhANoSAHandling = preCmavo VEhAWords postCmavo;
String VEhASaClause = VEhAWords spaces* VEhASaTail;
String VEhASaTail = SA &(preCmavo VEhAWords) / !VEhAWords anyWordNoSAHandling VEhASaTail;
String VEhAWords = "ve'u" / "ve'a" / "ve'i" / "ve'e";
//         space-time dimensionality marker 
String VIhA = preCmavo VIhASaClause? VIhAWords postCmavo;
String VIhANoSAHandling = preCmavo VIhAWords postCmavo;
String VIhASaClause = VIhAWords spaces* VIhASaTail;
String VIhASaTail = SA &(preCmavo VIhAWords) / !VIhAWords anyWordNoSAHandling VIhASaTail;
String VIhAWords = "vi'i" / "vi'a" / "vi'u" / "vi'e";
String VUhO = preCmavo VUhOSaClause? VUhOWords postCmavo;
String VUhONoSAHandling = preCmavo VUhOWords postCmavo;
String VUhOSaClause = VUhOWords spaces* VUhOSaTail;
String VUhOSaTail = SA &(preCmavo VUhOWords) / !VUhOWords anyWordNoSAHandling VUhOSaTail;
String VUhOWords = "vu'o";
//         glue between logically connected sumti
//                                     and relative clauses 

//         subscripting operator 
String XI = preCmavo XISaClause? XIWords postCmavo;
String XINoSAHandling = preCmavo XIWords postCmavo;
String XISaClause = XIWords spaces* XISaTail;
String XISaTail = SA &(preCmavo XIWords) / !XIWords anyWordNoSAHandling XISaTail;
String XIWords = "xi";

//         hesitation 
String Y = preCmavo YSaClause? YWords postCmavo;
String YNoSAHandling = preCmavo YWords postCmavo;
String YSaClause = YWords spaces* YSaTail;
String YSaTail = SA &(preCmavo YWords) / !YWords anyWordNoSAHandling YSaTail;
String YWords = "y"+;

//         event properties - inchoative, etc. 
String ZAhO = preCmavo ZAhOSaClause? ZAhOWords postCmavo;
String ZAhONoSAHandling = preCmavo ZAhOWords postCmavo;
String ZAhOSaClause = ZAhOWords spaces* ZAhOSaTail;
String ZAhOSaTail = SA &(preCmavo ZAhOWords) / !ZAhOWords anyWordNoSAHandling ZAhOSaTail;
String ZAhOWords = "co'i" / "pu'o" / "co'u" / "mo'u" / "ca'o" / "co'a" / "de'a" / "ba'o" / "di'a" / "za'o";
//         time interval size tense 
String ZEhA = preCmavo ZEhASaClause? ZEhAWords postCmavo;
String ZEhANoSAHandling = preCmavo ZEhAWords postCmavo;
String ZEhASaClause = ZEhAWords spaces* ZEhASaTail;
String ZEhASaTail = SA &(preCmavo ZEhAWords) / !ZEhAWords anyWordNoSAHandling ZEhASaTail;
String ZEhAWords = "ze'u" / "ze'a" / "ze'i" / "ze'e";
//         lujvo glue 
String ZEI = preCmavo ZEISaClause? ZEIWords postCmavo;
String ZEINoSAHandling = preCmavo ZEIWords postCmavo;
String ZEISaClause = ZEIWords spaces* ZEISaTail;
String ZEISaTail = SA &(preCmavo ZEIWords) / !ZEIWords anyWordNoSAHandling ZEISaTail;
String ZEIWords = "zei";
//         time distance tense 
String ZI = preCmavo ZISaClause? ZIWords postCmavo;
String ZINoSAHandling = preCmavo ZIWords postCmavo;
String ZISaClause = ZIWords spaces* ZISaTail;
String ZISaTail = SA &(preCmavo ZIWords) / !ZIWords anyWordNoSAHandling ZISaTail;
String ZIWords = "zu" / "za" / "zi";
//         conjoins relative clauses 
String ZIhE = preCmavo ZIhESaClause? ZIhEWords postCmavo;
String ZIhENoSAHandling = preCmavo ZIhEWords postCmavo;
String ZIhESaClause = ZIhEWords spaces* ZIhESaTail;
String ZIhESaTail = SA &(preCmavo ZIhEWords) / !ZIhEWords anyWordNoSAHandling ZIhESaTail;
String ZIhEWords = "zi'e";
//         single word metalinguistic quote marker 
String ZO = preCmavo ZOWords zoPostCmavo;
String ZOWords = "zo";
String zoPostCmavo =  spacesNotY+ / &CMAVOPostNoSIHandling / SI;
//         delimited quote marker 
String ZOI = preCmavo ZOISaClause? ZOIWords postCmavo;
String ZOINoSAHandling = preCmavo ZOIWords postCmavo;
String ZOISaClause = ZOIWords spaces* ZOISaTail;
String ZOISaTail = SA &(preCmavo ZOIWords) / !ZOIWords anyWordNoSAHandling ZOISaTail;
String ZOIWords = "zoi" / "la'o";
//         prenex terminator (not elidable) 
String ZOhU = preCmavo ZOhUSaClause? ZOhUWords postCmavo;
String ZOhUNoSAHandling = preCmavo ZOhUWords postCmavo;
String ZOhUSaClause = ZOhUWords spaces* ZOhUSaTail;
String ZOhUSaTail = SA &(preCmavo ZOhUWords) / !ZOhUWords anyWordNoSAHandling ZOhUSaTail;
String ZOhUWords = "zo'u";