Chip 2003 January/ChipCD_1.03.iso/zkuste/talk/install/Microsoft/spchapi.exe/VCMD.EXE/BINARY/113

Text File | 1999-01-12 | 55.4 KB | 1,640 lines

[Space]
"\n" "" ""
"\r" "" ""
"\t" "" ""

"" "\n" ""
"" "\r" ""
"" "\t" ""

"" "." ""
"" "," ""
"" "\\" ""
"\\" "" ""
"" ":" ""
"" ";" ""
"" "%" ""
"" "?" ""
"" "!" ""

".www" "" ""
"" ".com" ""

"\" " "" ""
"" "\"" " " {E"\""}
"" "\"" ""  {O"\""}

"' " "" ""
"" "'" " " {E"'"}
"" "'" ""  {O"'"}

"\"." "" "  " {1}
"\"." "" " "  {!1}

"\"?" "" "  " {1}
"\"?" "" " "  {!1}

"\"!" "" "  " {1}
"\"!" "" " "  {!1}

"'." "" "  " {1}
"'." "" " "  {!1}

"'?" "" "  " {1}
"'?" "" " "  {!1}

"'!" "" "  " {1}
"'!" "" " "  {!1}

")." "" "  " {1}
")." "" " "  {!1}

")?" "" "  " {1}
")?" "" " "  {!1}

")!" "" "  " {1}
")!" "" " "  {!1}

"/" "" "" {!23}
"/" "" " " {23}
"" "/" "" {!23}
"" "/" " " {23}

"* " "" ""
"" "*" " " {E"*"}
"" "*" ""  {O"*"}

"(" "" ""
"A" ")" ""

"[" "" ""
"A" "]" ""

"{" "" ""
"A" "}" ""

"<" "" ""
"A" ">" ""

.\dot "" ""
"" .\dot ""

"@" "" ""
"" "@" ""
@\at-sign "" ""
"" @\at-sign ""

.\period "" "  " {1}
.\period "" " "  {!1}
. "" "  " {1}
. "" " "  {!1}

"?" "" "  " {1}
"?" "" " "  {!1}

"!" "" "  " {1}
"!" "" " "  {!1}


"" "/" ""
"/A" "" ""

"" "-0" " "
"" "-1" " "
"" "-2" " "
"" "-3" " "
"" "-4" " "
"" "-5" " "
"" "-6" " "
"" "-7" " "
"" "-8" " "
"" "-9" " "

"-" "-" ""
"--" "" " "
"" "--" " "
"-A" "" ""
"" "-" ""



[Capital]
.\period
.
!\exclamation-point
!
?\question-mark
?

Mr.
Mrs.
Ms.
Dr.
Mme.

bullet-text
item-one
item-two
item-three
item-four
item-five
item-six
item-seven
item-eight
item-nine
item-ten
item-eleven
item-twelve
item-thirteen
item-fourteen
item-fifteen
item-sixteen
item-seventeen
item-eighteen
item-nineteen

"\n"
"\r"
"\t"

"\"\n"
"\"\r"
"\"\t"

"\"."
"\"?"
"\"!"
" \"."
" \"?"
" \"!"
"  \"."
"  \"?"
"  \"!"

"\" ."
"\" ?"
"\" !"
"\"  ."
"\"  ?"
"\"  !"

"'."
"'?"
"'!"
" '."
" '?"
" '!"
"  '."
"  '?"
"  '!"

"' ."
"' ?"
"' !"
"'  ."
"'  ?"
"'  !"

"( ."
"( ?"
"( !"
"(  ."
"(  ?"
"(  !"

")?"
")!"
")."
" )."
" )?"
" )!"
"  )."
"  )?"
"  )!"

"-\r"
"-\n"
".1"
".2"
".3"
".4"
".5"
".6"
".7"
".8"
".9"
".0"

"?"
"!"
" ?"
" !"
"  ?"
"  !"


[Switch]
1= 1 "Spaces Between Sentences" "Places two spaces between sentences ending with a period, question mark, and exclamation point."
2= 1 "Time" "Converts times (ex: 'ten oh two p m' = '10:02 PM')"
3= 1 "Currency" "Converts currency (ex: 'three dollars and fifteen cents' = '$3.15')"
4= 1 "Fractions" "Converts fractions (ex: 'one and one half' = '1 1/2')"
5= 1 "Phone Numbers" "Converts phone numbers"
6= 1 "Acronyms" "Converts acronyms (ex: 'f. b. i.' to 'FBI')"
7= 1 "Years" "Converts years (ex: 'nineteen ninety four' to '1994')"
8= 1 "Numbers (20+)" "Converts all numbers above 19 to numerical form (ex: 'eighty two' to '82')"
9= 1 "Measurements" "Converts measurements (ex: 'fifteen feet' to '15 ft.')"
10= 1 "Degrees" "Converts degrees (ex: 'eight degrees' to '8░')"
11= 1 "Dates" "Converts dates (ex: 'november first nineteen sixty-nine' to 'November 1, 1969')"
12= 1 "Numeric Streets" "Converts numeric streets (ex: 'fifty first street' to '51st St.')"
13= 1 "Copyright" "Converts copyrighted dates (ex: 'copyright nineteen ninety-seven' to '⌐1997')"
14= 1 "State and Zip" "Converts a state followed by a zip code (ex: 'new york one four oh five two' to 'NY, 14052')"
15= 1 "Currency, decimal" "Automatically appends .00 to the number of dollars."
16= 0 "Acronyms, period" "Places a period after every letter."
17= 0 "Currency, cents" "Uses the cent marker for sub-dollar amounts. (ex: 'fifty two cents' to '52ó')"
18= 0 "Dates, numbers" "Shows dates as numbers. (ex: 'march nineteen ninety-six' to '3/1996')"
19= 1 "Digits" "Converts a series of digits (ex: 'one two three' to '123')"
20= 0 "Numbers (All)" "Converts all numbers (including 19 or below) to numerical form, instead of words. (ex: 'five' to '5')"
21= 1 "Number to #" "Converts the word 'number' to '#' if it occurs before a number."
22= 1 "Ratios" "Converts '<number> colon <number>' (ex: 'five colon fifteen' to '5:15')"
23= 0 "Spaces around slash" "Puts spaces around the slash character. (ex: 'one slash four' to '1 / 4' instead of '1/4')"

[Rules]
// Start
<Start> = {6} <Acronym>
<Start> = {19} <Digits>
<Start> = {3} <Currency>
<Start> = {2} <Time>
<Start> = {5} <PhoneNum>
<Start> = {7} <DoubleNumber>
<Start> = {7} <PluralNumber>
<Start> = {8} {!20} <OrdinalEnd19>
<Start> = {8} {!20} <Float19>
<Start> = {20} <Float>
<Start> = {9} <Measurement>
<Start> = {10} <Degrees>
<Start> = {11} <Dates>
<Start> = {12} <Streets>
<Start> = {13} <Copyright>
<Start> = {14} <StateZip>
<Start> = {21} number "#" <Float>
<Start> = {22} <Ratios>
<Start> = {4} <Fraction>

// State & zip code, putting comma in
<StateZip> = ", " <State> " " <Digits>
<StateZip> = ", " <Province> " " <LetterWithO> <O0..9> <LetterWithO> <O0..9> <LetterWithO> <O0..9>
<State> = Alabama    "AL"
<State> = Alaska "AK"
<State> = American Samoa "AS"
<State> = Arizona "AZ"
<State> = Arkansas "AR"
<State> = California "CA"
<State> = Colorado "CO"
<State> = Connecticut "CT"
<State> = Delaware "DE"
<State> = District of Columbia DC"
<State> = Federated States of Micronesia "FM"
<State> = Florida "FL"
<State> = Georgia "GA"
<State> = Guam "GU"
<State> = Hawaii "HI"
<State> = Idaho "ID"
<State> = Illinois "IL"
<State> = Indiana "IN"
<State> = Iowa "IA"
<State> = Kansas "KS"
<State> = Kentucky "KY"
<State> = Louisiana "LA"
<State> = Maine "ME"
<State> = Marshall Islands "MH"
<State> = Maryland "MD"
<State> = Massachusetts "MA"
<State> = Michigan "MI"
<State> = Minnesota "MN"
<State> = Mississippi "MS"
<State> = Missouri "MO"
<State> = Montana "MT"
<State> = Nebraska "NE"
<State> = Nevada "NV"
<State> = New Hampshire "NH"
<State> = New Jersey "NJ"
<State> = New Mexico "NM"
<State> = New York "NY"
<State> = North Carolina "NC"
<State> = North Dakota "ND"
<State> = Northern Mariana Island "MP"
<State> = Ohio "OH"
<State> = Oklahoma "OK"
<State> = Oregon "OR"
<State> = Pennsylvania "PA"
<State> = Puerto Rico "PR"
<State> = Rhode Island "RI"
<State> = South Carolina "SC"
<State> = South Dakota "SD"
<State> = Texas "TX"
<State> = Utah "UT"
<State> = Vermont "VT"
<State> = Virginia "VA"
<State> = Virgin Islands "VI"
<State> = Washington "WA"
<State> = Washington D. C. "Washington, DC"
<State> = Washington DC "Washington, DC"
<State> = West Virginia "WV"
<State> = Wisconsin "WI"
<State> = Wyoming "WY"
<Province> = Alberta "AL"
<Province> = British Columbia "BC"
<Province> = Manitoba "MB"
<Province> = New Brunswick "NB"
<Province> = Newfoundland and Labrador "NF"
<Province> = Newfoundland "NF"
<Province> = Labrador "NF"
<Province> = Northwest Territories "NT"
<Province> = Ontario "ON"
<Province> = Prince Edward Island "PE"
<Province> = Quebec "PQ"
<Province> = Saskatchewan "SK"

// Phone numbers
<PhoneNum> = area code <ThreeDigits> [opt] <DashSlash> "-" <ThreeDigits> [opt] <DashSlash> "-" <FourDigits>
<PhoneNum> = <ThreeDigits> [opt] <DashSlash> "-" <FourDigits>
<PhoneNum> = <ThreeDigits> [opt] <DashSlash> "-" <ThreeDigits> [opt] <DashSlash> "-" <FourDigits>
<PhoneNum> = one "1-" <ThreeDigits> [opt] <DashSlash> "-" <ThreeDigits> [opt] <DashSlash> "-" <FourDigits>
<PhoneNum> = one eight hundred "1-800-" <ThreeDigits> [opt] <DashSlash> "-" <FourDigits>
<PhoneNum> = one nine hundred "1-900-" <ThreeDigits> [opt] <DashSlash> "-" <FourDigits>
<PhoneNum> = X. "x" [1+] <O0..9>
<PhoneNum> = extension "x" [1+] <O0..9>
<ThreeDigits> = <O0..9> <O0..9> <O0..9>
<FourDigits> = <O0..9> <O0..9> <O0..9> <O0..9>
<DashSlash> = -\dash
<DashSlash> = dash
<DashSlash> = /\slash
<DashSlash> = slash
<O0..9> = O. "0"
<O0..9> = oh "0"
<O0..9> = <0..9>


// Copyright
<Copyright> = copyright "⌐" <Year>

// Streets
<Streets> = <OrdinalEnd> [opt] <StreetDirectSpace> <StreetAve> [opt] <StreetDirectSpace>
<Streets> = <LetterWithONoA> <StreetAve>
<Streets> = <StreetAve> <StreetDirectSpace>
<Streets> = <StreetDirect> " " <OrdinalEnd> <StreetAve>
<StreetAve> = street " St." [opt] .\period
<StreetAve> = drive " Dr." [opt] .\period
<StreetAve> = ave " Ave." [opt] .\period
<StreetAve> = avenue " Ave." [opt] .\period
<StreetAve> = boulevard " Blvd." [opt] .\period
<StreetAve> = place " Pl." [opt] .\period
<StreetAve> = court " Ct." [opt] .\period
<StreetAve> = road " Rd." [opt] .\period
//<StreetAve> = way " Way"
<StreetAve> = loop " Loop"
<StreetDirectSpace> = " " <StreetDirect>
<StreetDirect> = north "N"
<StreetDirect> = south "S"
<StreetDirect> = east "E"
<StreetDirect> = west "W"
<StreetDirect> = north-east "NE"
<StreetDirect> = northeast  "NE"
<StreetDirect> = north east "NE"
<StreetDirect> = north-west "NW"
<StreetDirect> = northwest  "NW"
<StreetDirect> = north west "NW"
<StreetDirect> = south-east "SE"
<StreetDirect> = southeast  "SE"
<StreetDirect> = south east "SE"
<StreetDirect> = south-west "SW"
<StreetDirect> = southwest  "SW"
<StreetDirect> = south west "SW"

// Dates
<Dates> = {!18} <Month> " " <Ordinal>
<Dates> = {!18} <Month> " " <Ordinal> [opt] ,\comma ", " <Year>
<Dates> = {!18} <Month> " " <1..31>
<Dates> = {!18} <Month> " " <1..31> [opt] ,\comma ", " <Year>
<Dates> = {!18} <Month> " " <YearMore31>
<Dates> = {18} <MonthNumber> "/" <Ordinal>
<Dates> = {18} <MonthNumber> "/" <Ordinal> "/" <Year>
<Dates> = {18} <MonthNumber> "/" <Year>
<Dates> = {18} <MonthNumber> "/" <1..31> "/" <Year>
<Year> = <DoubleNumber>
<Year> = <Less1000000Not>
<Year> = <Less1000Not>
<Year> = {!18} "'" <Less100Not>
<Year> = {18} <Less100Not>
<YearMore31> = <DoubleNumber>
<YearMore31> = <Less1000000Not>
<YearMore31> = <Less1000Not>
<YearMore31> = {!18} "'" <32.99>
<YearMore31> = {18} <32.99>
<Month> = January "January"
<Month> = February "February"
<Month> = March "March"
<Month> = April "April"
<Month> = May "May"
<Month> = June "June"
<Month> = July "July"
<Month> = August "August"
<Month> = September "September"
<Month> = October "October"
<Month> = November "November"
<Month> = December "December"
<MonthNumber> = January "1"
<MonthNumber> = February "2"
<MonthNumber> = March "3"
<MonthNumber> = April "4"
<MonthNumber> = May "5"
<MonthNumber> = June "6"
<MonthNumber> = July "7"
<MonthNumber> = August "8"
<MonthNumber> = September "9"
<MonthNumber> = October "10"
<MonthNumber> = November "11"
<MonthNumber> = December "12"
<1..31> = <1..9>
<1..31> = <10.19>
<1..31> = <20.31>

// Time
<Time> = <Hours> o'clock ":00" [opt] <AMPM>
<Time> = <Hours> ":" <Minutes> [opt] <AMPM>
<Time> = <Hours> ":00" <AMPM>
<Time> = <Natural> hundred hours ":00"
<Time> = <Natural> ":" <Minutes> hours
<Time> = quarter <PastAfter> <Hours> ":15" [opt] <AMPM>
<Time> = quarter <PastAfter> noon "12:15 PM"
<Time> = quarter <PastAfter> midnight "12:15 AM"
<Time> = half <PastAfter> <Hours> ":30" [opt] <AMPM>
<Time> = half <PastAfter> noon "12:30 PM"
<Time> = half <PastAfter> midnight "12:30 AM"
<Time> = quarter <BeforeTo> <HoursMinus1> ":45" [opt] <AMPM>
<Time> = quarter <BeforeTo> noon "11:45 AM"
<Time> = quarter <BeforeTo> midnight "11:45 PM"
<PastAfter> = past
<PastAfter> = after
<BeforeTo> = before
<BeforeTo> = to
<BeforeTo> = 'til
<BeforeTo> = til
<Minutes> = <DoubleDigit>
<Minutes> = oh "0" <0..9>
<Minutes> = O. "0" <0..9>
<Hours> = <1..9>
<Hours> = ten "10"
<Hours> = eleven "11"
<Hours> = twelve "12"
<HoursMinus1> = one "12"
<HoursMinus1> = two "1"
<HoursMinus1> = three "2"
<HoursMinus1> = four "3"
<HoursMinus1> = five "4"
<HoursMinus1> = six "5"
<HoursMinus1> = seven "6"
<HoursMinus1> = eight "7"
<HoursMinus1> = nine "8"
<HoursMinus1> = ten "9"
<HoursMinus1> = eleven "10"
<HoursMinus1> = twelve "11"
<AMPM> = a. m. " AM"
<AMPM> = a.m. " AM"
<AMPM> = am " AM"
<AMPM> = p. m. " PM"
<AMPM> = p.m. " PM"
<AMPM> = pm " PM"

// Degrees (also temperature)
<Degrees> = <Float> <DegreePl> "░" [opt] <Degrees2>
<DegreePl> = degree
<DegreePl> = degrees
<Degrees2> = fahrenheit "F"
<Degrees2> = celcius "C"
<Degrees2> = celsius "C"
<Degrees2> = <NSEW>
<Degrees2> = [opt] and " " <Float> <MinutePl> "'" [opt] <Degrees3> [opt] <NSEW>
<Degrees3> = [opt] and " " <Float> <SecondPl> "''"
<MinutePl> = minute
<MinutePl> = minutes
<SecondPl> = second
<SecondPl> = seconds
<NSEW> = north " N." [opt] .\period
<NSEW> = south " S." [opt] .\period
<NSEW> = east " E." [opt] .\period
<NSEW> = west " W." [opt] .\period

// Measurements, such as 23.9 ft.
<Measurement> = <Float> [opt] <ToMeasurement> <UnitEnding>
<Measurement> = <Fraction> [opt] <ToMeasurement> <UnitEnding>
<ToMeasurement> = <MeasTo> " - " <Float>
<ToMeasurement> = <MeasTo> " - "<Fraction>
<MeasTo> = to
<MeasTo> = dash
<MeasTo> = -\dash
<MeasTo> = through

<UnitEnding> = <UnitArea>
<UnitEnding> = <UnitDistance>
<UnitEnding> = <UnitVolume>
<UnitEnding> = <UnitWeight>
<UnitEnding> = <UnitSpeed>
<UnitEnding> = <UnitMemory>
<UnitEnding> = <UnitFrequency>
<UnitEnding> = <Energy>
<UnitEnding> = <UnitTime>
<UnitEnding> = square " sq. " <UnitDistance>
<UnitEnding> = cubix " cb. " <UnitDistance>
<UnitEnding> = percent "%"
<UnitEnding> = %\percent "%"

<UnitMemory> = K. "K"
<UnitMemory> = KB "KB"
<UnitMemory> = K. B. "KB"
<UnitMemory> = kilobyte "KB"
<UnitMemory> = kilobyte "KB"
<UnitMemory> = kilobytes "KB"
<UnitMemory> = K-byte "KB"
<UnitMemory> = K-bytes "KB"
<UnitMemory> = meg "MB"
<UnitMemory> = megs "MB"
<UnitMemory> = megabyte "MB"
<UnitMemory> = megabytes "MB"
<UnitMemory> = gig "GB"
<UnitMemory> = gigs "GB"
<UnitMemory> = gigabyte "GB"
<UnitMemory> = gigabytes "GB"
<UnitMemory> = terabyte "TB"
<UnitMemory> = terabytes "TB"

<Energy> = watt " W"
<Energy> = watts " W"
<Energy> = kilowatt " kW"
<Energy> = kilowatts " kW"
<Energy> = kilowatt hour " kWh"
<Energy> = kilowatt hours " kWh"

<UnitTime> = ms " ms." [opt] .\period
<UnitTime> = millisecond " ms." [opt] .\period
<UnitTime> = milliseconds " ms." [opt] .\period

<UnitFrequency> = hz " Hz"
<UnitFrequency> = hz. " Hz"
<UnitFrequency> = hertz " Hz"
<UnitFrequency> = hurts " Hz"
<UnitFrequency> = mhz " mHz"
<UnitFrequency> = mhz. " mHz"
<UnitFrequency> = megahertz " mHz"

<UnitDistance> = mile " mi." [opt] .\period
<UnitDistance> = miles " mi." [opt] .\period
<UnitDistance> = of a mile " mi." [opt] .\period
<UnitDistance> = yard " yd." [opt] .\period
<UnitDistance> = yards " yd." [opt] .\period
<UnitDistance> = of a yard " yd." [opt] .\period
<UnitDistance> = foot " ft." [opt] .\period
<UnitDistance> = feet " ft." [opt] .\period
<UnitDistance> = of a foot " ft." [opt] .\period
<UnitDistance> = inch " in." [opt] .\period
<UnitDistance> = inches " in." [opt] .\period
<UnitDistance> = of an inch " in." [opt] .\period
<UnitDistance> = kilometer " km." [opt] .\period
<UnitDistance> = kilometers " km." [opt] .\period
<UnitDistance> = meter " m." [opt] .\period
<UnitDistance> = meters " m." [opt] .\period
<UnitDistance> = centimeter " cm." [opt] .\period
<UnitDistance> = centimeters " cm." [opt] .\period
<UnitDistance> = cm " cm." [opt] .\period
<UnitDistance> = millimeter " mm." [opt] .\period
<UnitDistance> = millimeters " mm." [opt] .\period
<UnitDistance> = mm " mm." [opt] .\period
<UnitDistance> = nanometer " nm." [opt] .\period
<UnitDistance> = nanometers " nm." [opt] .\period
<UnitDistance> = micron " mu." [opt] .\period
<UnitDistance> = microns " mu." [opt] .\period
<UnitDistance> = micron's " mu." [opt] .\period

<UnitArea> = acre " acre"
<UnitArea> = acres " acres"
<UnitArea> = hectar " hectar"
<UnitArea> = hectars " hectars"

<UnitVolume> = gallon " gal." [opt] .\period
<UnitVolume> = gallons " gal." [opt] .\period
<UnitVolume> = cup " c." [opt] .\period
<UnitVolume> = cups " c." [opt] .\period
<UnitVolume> = pint " pt." [opt] .\period
<UnitVolume> = pints " pts." [opt] .\period
<UnitVolume> = quart " qt." [opt] .\period
<UnitVolume> = quarts " qts." [opt] .\period
<UnitVolume> = teaspoon " tsp." [opt] .\period
<UnitVolume> = teaspoons " tsp." [opt] .\period
<UnitVolume> = tablespoon " tbsp." [opt] .\period
<UnitVolume> = tablespoons " tbsp." [opt] .\period
<UnitVolume> = liter " l." [opt] .\period
<UnitVolume> = liters " l." [opt] .\period
<UnitVolume> = milliliter " ml." [opt] .\period
<UnitVolume> = milliliters " ml." [opt] .\period
<UnitVolume> = ml " ml." [opt] .\period

<UnitWeight> = ton " tn." [opt] .\period
<UnitWeight> = tons " tn." [opt] .\period
<UnitWeight> = metric ton " tn." [opt] .\period
<UnitWeight> = metric tons " tn." [opt] .\period
<UnitWeight> = pound " lb." [opt] .\period
<UnitWeight> = pounds " lbs." [opt] .\period
<UnitWeight> = ounce " oz." [opt] .\period
<UnitWeight> = ounces " oz." [opt] .\period
<UnitWeight> = kilogram " kg." [opt] .\period
<UnitWeight> = kilograms " kg." [opt] .\period
<UnitWeight> = gram " g." [opt] .\period
<UnitWeight> = grams " g." [opt] .\period
<UnitWeight> = milligram " mg." [opt] .\period
<UnitWeight> = milligrams " mg." [opt] .\period

<UnitSpeed> = mile per hour " mph"
<UnitSpeed> = miles per hour " mph"
<UnitSpeed> = kilometer per hour " kmph"
<UnitSpeed> = kilometers per hour " kmph"

// Currency
<Currency> = {15} "$" <NaturalNotZillions> <Dollar> ".00"
<Currency> = {!15} "$" <NaturalNotZillions> <Dollar>
<Currency> = "$" <FloatOnly> thousand dollars " thousand"
<Currency> = "$" <Float> million dollars " million"
<Currency> = "$" <Float> billion dollars " billion"
<Currency> = "$" <Float> trillion dollars " trillion"
<Currency> = "$" <Natural19> million dollars " million"
<Currency> = "$" <Natural19> billion dollars " billion"
<Currency> = "$" <Natural19> trillion dollars " trillion"
<Currency> = "$" <Less100Not> million dollars " million"
<Currency> = "$" <Less100Not> billion dollars " billion"
<Currency> = "$" <Less100Not> trillion dollars " trillion"
<Currency> = "$" <Fraction> <Dollar>
<Currency> = "$" <Fraction> thousand dollars " thousand"
<Currency> = "$" <Fraction> million dollars " million"
<Currency> = "$" <Fraction> billion dollars " billion"
<Currency> = "$" <Fraction> trillion dollars " trillion"
<Currency> = "$" <Natural> <Dollar> [opt] and "." <Less100Pad> <CentCents>
<Currency> = "$" <FloatOnly> <Dollar>
<Currency> = {!17} "$0." <Less100Pad> <CentCents>
<Currency> = {17} <Float> <CentCents> "ó"
<CentCents> = cent
<CentCents> = cents

<Dollar> = dollar
<Dollar> = dollars
// BUGBUG: Other currencies

// acronyms with only letters get O. converteted to O
<Acronym> = <LetterWithO> [1+] <LetterWithOOrSymbol>
<Acronym> = <LetterWithO> [0+] <LetterWithOOrSymbol> <LetterPosess>

<Digits> = <O0..9> [1+] <O0..9>

<DigitLetterWithZero> = <0..9>
<DigitLetterWithZero> = <LetterWithZero>

<DigitLetterWithZeroOrSymbol> = <0..9>
<DigitLetterWithZeroOrSymbol> = <LetterWithZero>
<DigitLetterWithZeroOrSymbol> = <Symbol>

<LetterWithOOrSymbol> = <LetterWithO>
<LetterWithOOrSymbol> = <Symbol>

// Ratios
<Ratios> = <Integer> colon ":" <Integer>
<Ratios> = <Integer> :\colon ":" <Integer>

// Fractions
<Fraction> = one "1/" <DenomS>
<Fraction> = <NaturalNot1> "/" <DenomP>
<Fraction> = <Integer> <Fraction2>
<Fraction2> = and " " <NaturalNot1> "/" <DenomP>
<Fraction2> = and one " 1/" <DenomS>
<Fraction2> = and a " 1/" <DenomS>
<Fraction2> = and an " 1/" <DenomS>
<Fraction2> = and " " <Natural> over "/" <Natural>
<Fraction2> = over "/" <Natural>

// Denonimator
<Denom> = <DenomS>
<Denom> = <DenumP>
<DenomS> = half "2"
<DenomP> = halves "2"
<DenomS> = third "3"
<DenomP> = thirds "3"
<DenomS> = fourth "4"
<DenomP> = fourths "4"
<DenomS> = quarter "4"
<DenomP> = quarters "4"
<DenomS> = fifth "5"
<DenomP> = fifths "5"
<DenomS> = sixth "6"
<DenomP> = sixths "6"
<DenomS> = seventh "7"
<DenomP> = sevenths "7"
<DenomS> = eighth "8"
<DenomP> = eighths "8"
<DenomS> = ninth "9"
<DenomP> = ninths "9"
<DenomS> = tenth "10"
<DenomP> = tenths "10"
<DenomS> = eleventh "11"
<DenomP> = elevenths "11"
<DenomS> = twelfth "12"
<DenomP> = twelfths "12"
<DenomS> = thirteenth "13"
<DenomP> = thirteenths "13"
<DenomS> = fourteenth "14"
<DenomP> = fourteenths "14"
<DenomS> = fifteenth "15"
<DenomP> = fifteenths "15"
<DenomS> = sixteenth "16"
<DenomP> = sixteenths "16"
<DenomS> = seventeenth "17"
<DenomP> = seventeenths "17"
<DenomS> = eighteenth "18"
<DenomP> = eighteenths "18"
<DenomS> = nineteenth "19"
<DenomP> = nineteenths "19"
<DenomS> = twentieth "20"
<DenomP> = twentieths "20"
<DenomS> = thirtieth "30"
<DenomP> = thirtieths "30"
<DenomS> = fortieth "40"
<DenomP> = fortieths "40"
<DenomS> = fiftieth "50"
<DenomP> = fiftieths "50"
<DenomS> = sixtieth "60"
<DenomP> = sixtieths "60"
<DenomS> = seventieth "70"
<DenomP> = seventieths "70"
<DenomS> = eightieth "80"
<DenomP> = eightieths "80"
<DenomS> = ninetieth "90"
<DenomP> = ninetieths "90"
<DenomS> = hundredth "100"
<DenomP> = hundredths "100"
<DenomS> = thousandth "1000"
<DenomP> = thousandths "1000"
<DenomS> = millionth "1,000,000"
<DenomP> = millionths "1,000,000"
<DenomS> = billionth "1,000,000,000"
<DenomP> = billionths "1,000,000,000"
<DenomS> = trillionth "1,000,000,000,000"
<DenomP> = trillionths "1,000,000,000,000"

// Symbols
<Symbol> = ~\tilde "~"
<Symbol> = tilde "~"
<Symbol> = !\exclamation-point "!"
<Symbol> = bang "!"
<Symbol> = @\at-sign "@"
<Symbol> = #\pound-sign "#"
<Symbol> = #\pound "#"
<Symbol> = pound "#"
<Symbol> = $\dollar-sign "$"
<Symbol> = %\percent "%"
<Symbol> = percent "%"
<Symbol> = ^\caret "^"
<Symbol> = caret "^"
<Symbol> = &\and-sign "&"
<Symbol> = *\asterisk "*"
<Symbol> = asterisk "*"
<Symbol> = (\left-paren "("
<Symbol> = )\right-paren ")"
<Symbol> = -\dash "-"
<Symbol> = dash "-"
<Symbol> = _\underscore "_"
<Symbol> = underscore "_"
<Symbol> = /\slash "/"
<Symbol> = slash "/"
<Symbol> = \\backslash "\"
<Symbol> = backslash "\"
<Symbol> = +\plus "+"
<Symbol> = plus "+"
<Symbol> = =\equals "="
<Symbol> = equals "="
// <Symbol> = {\left-curly-brace "{"
// <Symbol> = }\right-curly-brace "}"
// <Symbol> = [\left-bracket "["
// <Symbol> = ]\right-bracket "]"
<Symbol> = |\vertical-bar "|"
<Symbol> = :\colon ":"
<Symbol> = colon ":"
<Symbol> = ;\semicolon ";"
<Symbol> = semicolon ";"
// <Symbol> = <\less-than "<"
// <Symbol> = >\more-than ">"
<Symbol> = ?\question-mark "?"
//<Symbol> = .\point " point"

// Letters
<LetterWithO> = <LetterNoO>
<LetterWithO> = O. "O" <PeriodAfter>
<LetterWithO> = O  "O" <PeriodAfter>
<LetterWithO> = oh "O" <PeriodAfter>
<LetterWithONoA> = <LetterNoOA>
<LetterWithONoA> = O. "O" <PeriodAfter>
<LetterWithONoA> = O  "O" <PeriodAfter>
<LetterWithONoA> = oh "O" <PeriodAfter>
<LetterWithZero> = <LetterNoO>
<LetterWithZero> = O. "0"
<LetterWithZero> = O  "0"
<LetterWithZero> = oh "0"
<LetterNoO> = <LetterNoOA>
<LetterNoO> = A "A" <PeriodAfter>
<LetterNoO> = A. "A" <PeriodAfter>
<LetterNoOA> = B. "B" <PeriodAfter>
<LetterNoOA> = C. "C" <PeriodAfter>
<LetterNoOA> = D. "D" <PeriodAfter>
<LetterNoOA> = E. "E" <PeriodAfter>
<LetterNoOA> = F. "F" <PeriodAfter>
<LetterNoOA> = G. "G" <PeriodAfter>
<LetterNoOA> = H. "H" <PeriodAfter>
<LetterNoOA> = I. "I" <PeriodAfter>
<LetterNoOA> = J. "J" <PeriodAfter>
<LetterNoOA> = K. "K" <PeriodAfter>
<LetterNoOA> = L. "L" <PeriodAfter>
<LetterNoOA> = M. "M" <PeriodAfter>
<LetterNoOA> = N. "N" <PeriodAfter>
<LetterNoOA> = P. "P" <PeriodAfter>
<LetterNoOA> = Q. "Q" <PeriodAfter>
<LetterNoOA> = R. "R" <PeriodAfter>
<LetterNoOA> = S. "S" <PeriodAfter>
<LetterNoOA> = T. "T" <PeriodAfter>
<LetterNoOA> = U. "U" <PeriodAfter>
<LetterNoOA> = V. "V" <PeriodAfter>
<LetterNoOA> = W. "W" <PeriodAfter>
<LetterNoOA> = X. "X" <PeriodAfter>
<LetterNoOA> = Y. "Y" <PeriodAfter>
<LetterNoOA> = Z. "Z" <PeriodAfter>
<LetterNoOA> = B "B" <PeriodAfter>
<LetterNoOA> = C "C" <PeriodAfter>
<LetterNoOA> = D "D" <PeriodAfter>
<LetterNoOA> = E "E" <PeriodAfter>
<LetterNoOA> = F "F" <PeriodAfter>
<LetterNoOA> = G "G" <PeriodAfter>
<LetterNoOA> = H "H" <PeriodAfter>
<LetterNoOA> = I "I" <PeriodAfter>
<LetterNoOA> = J "J" <PeriodAfter>
<LetterNoOA> = K "K" <PeriodAfter>
<LetterNoOA> = L "L" <PeriodAfter>
<LetterNoOA> = M "M" <PeriodAfter>
<LetterNoOA> = N "N" <PeriodAfter>
<LetterNoOA> = P "P" <PeriodAfter>
<LetterNoOA> = Q "Q" <PeriodAfter>
<LetterNoOA> = R "R" <PeriodAfter>
<LetterNoOA> = S "S" <PeriodAfter>
<LetterNoOA> = T "T" <PeriodAfter>
<LetterNoOA> = U "U" <PeriodAfter>
<LetterNoOA> = V "V" <PeriodAfter>
<LetterNoOA> = W "W" <PeriodAfter>
<LetterNoOA> = X "X" <PeriodAfter>
<LetterNoOA> = Y "Y" <PeriodAfter>
<LetterNoOA> = Z "Z" <PeriodAfter>
<PeriodAfter> = {16} "."
<PeriodAfter> = {!16} ""

<LetterPosess> = A.'s "A" <PeriodAfter> "'s"
<LetterPosess> = B.'s "B" <PeriodAfter> "'s"
<LetterPosess> = C.'s "C" <PeriodAfter> "'s"
<LetterPosess> = D.'s "D" <PeriodAfter> "'s"
<LetterPosess> = E.'s "E" <PeriodAfter> "'s"
<LetterPosess> = F.'s "F" <PeriodAfter> "'s"
<LetterPosess> = G.'s "G" <PeriodAfter> "'s"
<LetterPosess> = H.'s "H" <PeriodAfter> "'s"
<LetterPosess> = I.'s "I" <PeriodAfter> "'s"
<LetterPosess> = J.'s "J" <PeriodAfter> "'s"
<LetterPosess> = K.'s "K" <PeriodAfter> "'s"
<LetterPosess> = L.'s "L" <PeriodAfter> "'s"
<LetterPosess> = M.'s "M" <PeriodAfter> "'s"
<LetterPosess> = N.'s "N" <PeriodAfter> "'s"
<LetterPosess> = O.'s "O" <PeriodAfter> "'s"
<LetterPosess> = P.'s "P" <PeriodAfter> "'s"
<LetterPosess> = Q.'s "Q" <PeriodAfter> "'s"
<LetterPosess> = R.'s "R" <PeriodAfter> "'s"
<LetterPosess> = S.'s "S" <PeriodAfter> "'s"
<LetterPosess> = T.'s "T" <PeriodAfter> "'s"
<LetterPosess> = U.'s "U" <PeriodAfter> "'s"
<LetterPosess> = V.'s "V" <PeriodAfter> "'s"
<LetterPosess> = W.'s "W" <PeriodAfter> "'s"
<LetterPosess> = X.'s "X" <PeriodAfter> "'s"
<LetterPosess> = Y.'s "Y" <PeriodAfter> "'s"
<LetterPosess> = Z.'s "Z" <PeriodAfter> "'s"
<LetterPosess> = A's "A" <PeriodAfter> "'s"
<LetterPosess> = B's "B" <PeriodAfter> "'s"
<LetterPosess> = C's "C" <PeriodAfter> "'s"
<LetterPosess> = D's "D" <PeriodAfter> "'s"
<LetterPosess> = E's "E" <PeriodAfter> "'s"
<LetterPosess> = F's "F" <PeriodAfter> "'s"
<LetterPosess> = G's "G" <PeriodAfter> "'s"
<LetterPosess> = H's "H" <PeriodAfter> "'s"
<LetterPosess> = I's "I" <PeriodAfter> "'s"
<LetterPosess> = J's "J" <PeriodAfter> "'s"
<LetterPosess> = K's "K" <PeriodAfter> "'s"
<LetterPosess> = L's "L" <PeriodAfter> "'s"
<LetterPosess> = M's "M" <PeriodAfter> "'s"
<LetterPosess> = N's "N" <PeriodAfter> "'s"
<LetterPosess> = O's "N" <PeriodAfter> "'s"
<LetterPosess> = P's "P" <PeriodAfter> "'s"
<LetterPosess> = Q's "Q" <PeriodAfter> "'s"
<LetterPosess> = R's "R" <PeriodAfter> "'s"
<LetterPosess> = S's "S" <PeriodAfter> "'s"
<LetterPosess> = T's "T" <PeriodAfter> "'s"
<LetterPosess> = U's "U" <PeriodAfter> "'s"
<LetterPosess> = V's "V" <PeriodAfter> "'s"
<LetterPosess> = W's "W" <PeriodAfter> "'s"
<LetterPosess> = X's "X" <PeriodAfter> "'s"
<LetterPosess> = Y's "Y" <PeriodAfter> "'s"
<LetterPosess> = Z's "Z" <PeriodAfter> "'s"

// Natural Numbers
<Natural> = <Less1000000000000000Not>
<Natural> = <Less1000000000000Not>
<Natural> = <Less1000000000Not>
<Natural> = <Less1000000Not>
<Natural> = <Less1000Not>
<Natural> = <Less100Not>

; natural number, but one singular
<NaturalNot1> = <Less1000000000000000Not>
<NaturalNot1> = <Less1000000000000Not>
<NaturalNot1> = <Less1000000000Not>
<NaturalNot1> = <Less1000000Not>
<NaturalNot1> = <Less1000Not>
<NaturalNot1> = <Less100Not>
<NaturalNot1> = <2..9>
<NaturalNot1> = <DoubleDigit>
<NaturalNot1> = zero "0"

// Natural, except for X million, X billion, and X trillion
<NaturalNotZillions> = <Less1000000000000000Not19>
<NaturalNotZillions> = <Less1000000000000Not19>
<NaturalNotZillions> = <Less1000000000Not19>
<NaturalNotZillions> = <Less1000000Not>
<NaturalNotZillions> = <Less1000Not>
<NaturalNotZillions> = <Less100Not>

// Ordinal Numbers, written WITHOUT ENDING
<Ordinal> = <OrdinalLess1000000000000000Not>
<Ordinal> = <OrdinalLess1000000000000Not>
<Ordinal> = <OrdinalLess1000000000Not>
<Ordinal> = <OrdinalLess1000000Not>
<Ordinal> = <OrdinalLess1000Not>
<Ordinal> = <OrdinalLess100Not>
<Orindal> = <Less100Not> hundredth "00"

// Ordinal Numbers, written WITH ENDING
<OrdinalEnd> = <OrdinalEndLess1000000000000000Not>
<OrdinalEnd> = <OrdinalEndLess1000000000000Not>
<OrdinalEnd> = <OrdinalEndLess1000000000Not>
<OrdinalEnd> = <OrdinalEndLess1000000Not>
<OrdinalEnd> = <OrdinalEndLess1000Not>
<OrdinalEnd> = <OrdinalEndLess100Not>
<OrindalEnd> = <Less100Not> hundredth "00th"

// Natural Numbers, zero through 19 are written out whole
// Also, fifty six million to 56 million
<Natural19> = <Less1000000000000000Not19>
<Natural19> = <Less1000000000000Not19>
<Natural19> = <Less1000000000Not19>
<Natural19> = <Less1000000Not19>
<Natural19> = <Less1000Not>
<Natural19> = <Less100Not19>

// Ordinal Numbers, zero through 19 are written out whole, written WITH ENDING
<OrdinalEnd19> = <OrdinalEndLess1000000000000000Not>
<OrdinalEnd19> = <OrdinalEndLess1000000000000Not>
<OrdinalEnd19> = <OrdinalEndLess1000000000Not>
<OrdinalEnd19> = <OrdinalEndLess1000000Not>
<OrdinalEnd19> = <OrdinalEndLess1000Not>
<OrdinalEnd19> = <OrdinalEndLess100Not19>
<OrindalEnd19> = <Less100Not> hundredth "00th"


// Integer
<Integer> = <Natural>
<Integer> = <MinusNegative> "-" <Natural>
<MinusNegative> = minus
<MinusNegative> = negative

// Integer, 0..19 not included
<Integer19> = <Natural19>
<Integer19> = <MinusNegative> "-" <Natural19>

// Floating point
<Float> = <Integer>
<Float> = <FloatOnly>

<FloatOnly> = <Integer> <Point> "." <RepDigits1>
<FloatOnly> = <Point> "0." <RepDigits1>
<Point> = point
<Point> = .

// Floating point, 0..19 are not included
<Float19> = <Integer19>
<Float19> = <Integer> <Point> "." <RepDigits1>
<Float19> = <Point> "0." <RepDigits1>
<Float19> = <Digits> <Point> "." <RepDigits1>

// Double-number cominations, like "ninteen sixty"
<DoubleNumber> = <Less100Not> <DoubleDigit>
<DoubleNumber> = <Less100Not> oh "0" <1..9>
<DoubleNumber> = <Less100Not> hundred "00"

// Plural number, like 1980's
<PluralNumber> = <Less100Not> <PluralNumber2>
<PluralNumber> = <DoubleDigitPlural> "'s"
<PluralNumber> = <SingleDigitPluralWithoutOne> "'s"
<PluralNumber2> = <DoubleDigitPlural> "'s"
<PluralNumber2> = oh <SingleDigitPlural> "'s"
<PluralNumber2> = hundreds "00's"

<SingleDigitPlural> = ones "1"
<SingleDigitPlural> = one's "1"
<SingleDigitPlural> = <SingleDigitPluralWithoutOne>

<SingleDigitPluralWithoutOne> = twos "2"
<SingleDigitPluralWithoutOne> = two's "2"
<SingleDigitPluralWithoutOne> = threes "3"
<SingleDigitPluralWithoutOne> = three's "3"
<SingleDigitPluralWithoutOne> = fours "4"
<SingleDigitPluralWithoutOne> = four's "4"
<SingleDigitPluralWithoutOne> = fives "5"
<SingleDigitPluralWithoutOne> = five's "5"
<SingleDigitPluralWithoutOne> = sixes "6"
<SingleDigitPluralWithoutOne> = six's "6"
<SingleDigitPluralWithoutOne> = sevens "7"
<SingleDigitPluralWithoutOne> = seven's "7"
<SingleDigitPluralWithoutOne> = eights "8"
<SingleDigitPluralWithoutOne> = eight's "8"
<SingleDigitPluralWithoutOne> = nines "9"
<SingleDigitPluralWithoutOne> = nine's "9"

<DoubleDigitPlural> = tens "10"
<DoubleDigitPlural> = ten's "10"
<DoubleDigitPlural> = elevens "11"
<DoubleDigitPlural> = eleven's "11"
<DoubleDigitPlural> = twelves "12"
<DoubleDigitPlural> = twelve's "12"
<DoubleDigitPlural> = thirteens "13"
<DoubleDigitPlural> = thirteen's "13"
<DoubleDigitPlural> = fourteens "14"
<DoubleDigitPlural> = fourteen's "14"
<DoubleDigitPlural> = fifteens "15"
<DoubleDigitPlural> = fifteen's "15"
<DoubleDigitPlural> = sixteens "16"
<DoubleDigitPlural> = sixteen's "16"
<DoubleDigitPlural> = seventeens "17"
<DoubleDigitPlural> = seventeen's "17"
<DoubleDigitPlural> = eighteens "18"
<DoubleDigitPlural> = eighteen's "18"
<DoubleDigitPlural> = nineteens "19"
<DoubleDigitPlural> = nineteen's "19"
<DoubleDigitPlural> = twenties "20"
<DoubleDigitPlural> = twenty's "20"
<DoubleDigitPlural> = twenty "2" <SingleDigitPlural>
<DoubleDigitPlural> = thirties "30"
<DoubleDigitPlural> = thirty's "30"
<DoubleDigitPlural> = thirty "3" <SingleDigitPlural>
<DoubleDigitPlural> = forties "40"
<DoubleDigitPlural> = forty's "40"
<DoubleDigitPlural> = forty "4" <SingleDigitPlural>
<DoubleDigitPlural> = fifties "50"
<DoubleDigitPlural> = fifty's "50"
<DoubleDigitPlural> = fifty "5" <SingleDigitPlural>
<DoubleDigitPlural> = sixties "60"
<DoubleDigitPlural> = sixty's "60"
<DoubleDigitPlural> = sixty "6" <SingleDigitPlural>
<DoubleDigitPlural> = seventies "70"
<DoubleDigitPlural> = seventy's "70"
<DoubleDigitPlural> = seventy "7" <SingleDigitPlural>
<DoubleDigitPlural> = eighties "80"
<DoubleDigitPlural> = eighty's "80"
<DoubleDigitPlural> = eighty "8" <SingleDigitPlural>
<DoubleDigitPlural> = nineties "90"
<DoubleDigitPlural> = ninety's "90"
<DoubleDigitPlural> = ninety "9" <SingleDigitPlural>

// Repeating digits, 1 or more times
// BUGBUG: Because no repeat, do a hack
<RepDigits1> = [1+] <0..9>
//<RepDigits1> = <0..9>
//<RepDigits1> = <0..9> <RepDigits1>

// 1..9
<1..9> = <2..9>
<1..9> = one "1"
<2..9> = two "2"
<2..9> = three "3"
<2..9> = four "4"
<2..9> = five "5"
<2..9> = six "6"
<2..9> = seven "7"
<2..9> = eight "8"
<2..9> = nine "9"

// 1..9, ordinal without ending
<Ordinal1..9> = first "1"
<Ordinal1..9> = second "2"
<Ordinal1..9> = third "3"
<Ordinal1..9> = fourth "4"
<Ordinal1..9> = fifth "5"
<Ordinal1..9> = sixth "6"
<Ordinal1..9> = seventh "7"
<Ordinal1..9> = eighth "8"
<Ordinal1..9> = ninth "9"

// 1..9, ordinal WITh ending
<OrdinalEnd1..9> = first "1st"
<OrdinalEnd1..9> = second "2nd"
<OrdinalEnd1..9> = third "3rd"
<OrdinalEnd1..9> = fourth "4th"
<OrdinalEnd1..9> = fifth "5th"
<OrdinalEnd1..9> = sixth "6th"
<OrdinalEnd1..9> = seventh "7th"
<OrdinalEnd1..9> = eighth "8th"
<OrdinalEnd1..9> = ninth "9th"

// Zero through nine
<0..9> = zero "0"
<0..9> = oh "0"
<0..9> = <1..9>

// Ordinal Zero through nine, without ending
<Ordinal0..9> = zeroth "0"
<Ordinal0..9> = <Ordinal1..9>

// Ordinal Zero through nine, WITH ending
<OrdinalEnd0..9> = zeroth "0th"
<OrdinalEnd0..9> = <OrdinalEnd1..9>

// 10.19
<10.19> = ten "10"
<10.19> = eleven "11"
<10.19> = twelve "12"
<10.19> = thirteen "13"
<10.19> = fourteen "14"
<10.19> = fifteen "15"
<10.19> = sixteen "16"
<10.19> = seventeen "17"
<10.19> = eighteen "18"
<10.19> = nineteen "19"

// Ordinal 10.19, without ending
<Ordinal10.19> = tenth "10"
<Ordinal10.19> = eleventh "11"
<Ordinal10.19> = twelfth "12"
<Ordinal10.19> = thirteenth "13"
<Ordinal10.19> = fourteenth "14"
<Ordinal10.19> = fifteenth "15"
<Ordinal10.19> = sixteenth "16"
<Ordinal10.19> = seventeenth "17"
<Ordinal10.19> = eighteenth "18"
<Ordinal10.19> = nineteenth "19"

// Ordinal 10.19, with ending
<OrdinalEnd10.19> = <Ordinal10.19> "th"

// 20..99
<20.99> = <20.31>
<20.99> = <32.99>
<20.31> = twenty "20"
<20.31> = twenty-one "21"
<20.31> = twenty-two "22"
<20.31> = twenty-three "23"
<20.31> = twenty-four "24"
<20.31> = twenty-five "25"
<20.31> = twenty-six "26"
<20.31> = twenty-seven "27"
<20.31> = twenty-eight "28"
<20.31> = twenty-nine "29"
<20.31> = twenty "2" <1..9>
//<20.31> = twenty "2" <SingleOrdinal>
<20.31> = thirty "30"
<20.31> = thirty-one "31"
<20.31> = thirty one "31"
<32.99> = thirty-two "32"
<32.99> = thirty-three "33"
<32.99> = thirty-four "34"
<32.99> = thirty-five "35"
<32.99> = thirty-six "36"
<32.99> = thirty-seven "37"
<32.99> = thirty-eight "38"
<32.99> = thirty-nine "39"
<32.99> = thirty "3" <1..9>
//<32.99> = thirty "3" <SingleOrdinal>
<32.99> = forty "40"
<32.99> = forty-one "41"
<32.99> = forty-two "42"
<32.99> = forty-three "43"
<32.99> = forty-four "44"
<32.99> = forty-five "45"
<32.99> = forty-six "46"
<32.99> = forty-seven "47"
<32.99> = forty-eight "48"
<32.99> = forty-nine "49"
<32.99> = forty "4" <1..9>
//<32.99> = forty "4" <SingleOrdinal>
<32.99> = fifty "50"
<32.99> = fifty-one "51"
<32.99> = fifty-two "52"
<32.99> = fifty-three "53"
<32.99> = fifty-four "54"
<32.99> = fifty-five "55"
<32.99> = fifty-six "56"
<32.99> = fifty-seven "57"
<32.99> = fifty-eight "58"
<32.99> = fifty-nine "59"
<32.99> = fifty "5" <1..9>
//<32.99> = fifty "5" <SingleOrdinal>
<32.99> = sixty "60"
<32.99> = sixty-one "61"
<32.99> = sixty-two "62"
<32.99> = sixty-three "63"
<32.99> = sixty-four "64"
<32.99> = sixty-five "65"
<32.99> = sixty-six "66"
<32.99> = sixty-seven "67"
<32.99> = sixty-eight "68"
<32.99> = sixty-nine "69"
<32.99> = sixty "6" <1..9>
//<32.99> = sixty "6" <SingleOrdinal>
<32.99> = seventy "70"
<32.99> = seventy-one "71"
<32.99> = seventy-two "72"
<32.99> = seventy-three "73"
<32.99> = seventy-four "74"
<32.99> = seventy-five "75"
<32.99> = seventy-six "76"
<32.99> = seventy-seven "77"
<32.99> = seventy-eight "78"
<32.99> = seventy-nine "79"
<32.99> = seventy "7" <1..9>
//<32.99> = seventy "7" <SingleOrdinal>
<32.99> = eighty "80"
<32.99> = eighty-one "81"
<32.99> = eighty-two "82"
<32.99> = eighty-three "83"
<32.99> = eighty-four "84"
<32.99> = eighty-five "85"
<32.99> = eighty-six "86"
<32.99> = eighty-seven "87"
<32.99> = eighty-eight "88"
<32.99> = eighty-nine "89"
<32.99> = eighty "8" <1..9>
//<32.99> = eighty "8" <SingleOrdinal>
<32.99> = ninety "90"
<32.99> = ninety-one "91"
<32.99> = ninety-two "92"
<32.99> = ninety-three "93"
<32.99> = ninety-four "94"
<32.99> = ninety-five "95"
<32.99> = ninety-six "96"
<32.99> = ninety-seven "97"
<32.99> = ninety-eight "98"
<32.99> = ninety-nine "99"
<32.99> = ninety "9" <1..9>
//<32.99> = ninety "9" <SingleOrdinal>

// Ordinal, 20..99 without ending
<Ordinal20.99> = twentieth "20"
<Ordinal20.99> = twenty "2" <Ordinal1..9>
<Ordinal20.99> = thirtieth "30"
<Ordinal20.99> = thirty "3" <Ordinal1..9>
<Ordinal20.99> = fortieth "40"
<Ordinal20.99> = forty "4" <Ordinal1..9>
<Ordinal20.99> = fiftieth "50"
<Ordinal20.99> = fifty "5" <Ordinal1..9>
<Ordinal20.99> = sixtieth "60"
<Ordinal20.99> = sixty "6" <Ordinal1..9>
<Ordinal20.99> = seventieth "70"
<Ordinal20.99> = seventy "7" <Ordinal1..9>
<Ordinal20.99> = eightieth "80"
<Ordinal20.99> = eighty "8" <Ordinal1..9>
<Ordinal20.99> = ninetieth "90"
<Ordinal20.99> = ninety "9" <Ordinal1..9>

// Ordinal, 20..99 with ending
<OrdinalEnd20.99> = twentieth "20th"
<OrdinalEnd20.99> = twenty "2" <OrdinalEnd1..9>
<OrdinalEnd20.99> = thirtieth "30th"
<OrdinalEnd20.99> = thirty "3" <OrdinalEnd1..9>
<OrdinalEnd20.99> = fortieth "40th"
<OrdinalEnd20.99> = forty "4" <OrdinalEnd1..9>
<OrdinalEnd20.99> = fiftieth "50th"
<OrdinalEnd20.99> = fifty "5" <OrdinalEnd1..9>
<OrdinalEnd20.99> = sixtieth "60th"
<OrdinalEnd20.99> = sixty "6" <OrdinalEnd1..9>
<OrdinalEnd20.99> = seventieth "70th"
<OrdinalEnd20.99> = seventy "7" <OrdinalEnd1..9>
<OrdinalEnd20.99> = eightieth "80th"
<OrdinalEnd20.99> = eighty "8" <OrdinalEnd1..9>
<OrdinalEnd20.99> = ninetieth "90th"
<OrdinalEnd20.99> = ninety "9" <OrdinalEnd1..9>

// Double digit
<DoubleDigit> = <20.99>
<DoubleDigit> = <10.19>

// Ordinal Double digit, no ending
<OrdinalDoubleDigit> = <Ordinal20.99>
<OrdinalDoubleDigit> = <Ordinal10.19>

// Ordinal Double digit, with ending
<OrdinalEndDoubleDigit> = <OrdinalEnd20.99>
<OrdinalEndDoubleDigit> = <OrdinalEnd10.19>

// Three digit number
<TripleDigit> = hundred "1" <Less100Pad>
<TripleDigit> = <1..9> hundred [opt] and <Less100Pad>
<TripleDigit> = <1..9> hundred "00"

// Ordinal Three digit number, whithout ending
<OrdinalTripleDigit> = hundred "1" <OrdinalLess100Pad>
<OrdinalTripleDigit> = <1..9> hundred [opt] and <OrdinalLess100Pad>
<OrdinalTripleDigit> = <1..9> hundredth "00"

// Ordinal Three digit number, whith ending
<OrdinalEndTripleDigit> = hundred "1" <OrdinalEndLess100Pad>
<OrdinalEndTripleDigit> = <1..9> hundred [opt] and <OrdinalEndLess100Pad>
<OrdinalEndTripleDigit> = <1..9> hundredth "00th"

// Less that 100, not padded with zeros
<Less100Not> = <1..9>
<Less100Not> = <DoubleDigit>
<Less100Not> = zero "0"

// Ordinal, Less that 100, not padded with zeros, without ending
<OrdinalLess100Not> = <Ordinal1..9>
<OrdinalLess100Not> = <OrdinalDoubleDigit>
<OrdinalLess100Not> = zeroeth "0"

// Ordinal, Less that 100, not padded with zeros, with ending
<OrdinalEndLess100Not> = <OrdinalEnd1..9>
<OrdinalEndLess100Not> = <OrdinalEndDoubleDigit>
<OrdinalEndLess100Not> = zeroeth "0th"

// Less that 100, not padded with zeros, don't do 0..19
<Less100Not19> = <20.99>

// Ordinal Less that 100, not padded with zeros, don't do 0..19, without ending
<OrdinalLess100Not19> = <Ordinal20.99>

// Ordinal Less that 100, not padded with zeros, don't do 0..19, with ending
<OrdinalEndLess100Not19> = <OrdinalEnd20.99>

// Less that 100, padded with zeros
<Less100Pad> = "0" <1..9>
<Less100Pad> = <DoubleDigit>
<Less100Pad> = zero "00"

// Ordinal Less that 100, padded with zeros, without ending
<OrdinalLess100Pad> = "0" <Ordinal1..9>
<OrdinalLess100Pad> = <OrdinalDoubleDigit>
<OrdinalLess100Pad> = zeroeth "00"

// Ordinal Less that 100, padded with zeros, with ending
<OrdinalEndLess100Pad> = "0" <OrdinalEnd1..9>
<OrdinalEndLess100Pad> = <OrdinalEndDoubleDigit>
<OrdinalEndLess100Pad> = zeroeth "00th"

// Less than 1000, not padded with zeros
<Less1000Not> = <TripleDigit>

// Ordinal Less than 1000, not padded with zeros, without ending
<OrdinalLess1000Not> = <OrdinalTripleDigit>

// Ordinal Less than 1000, not padded with zeros, with ending
<OrdinalEndLess1000Not> = <OrdinalEndTripleDigit>

// Less than 1000, padded with zeros
//<Less1000Pad> = "000"
<Less1000Pad> = "0" <Less100Pad>
<Less1000Pad> = <TripleDigit>

// Ordinal Less than 1000, padded with zeros, without ending
<OrdinalLess1000Pad> = "0" <OrdinalLess100Pad>
<OrdinalLess1000Pad> = <OrdinalTripleDigit>

// Ordinal Less than 1000, padded with zeros, with ending
<OrdinalEndLess1000Pad> = "0" <OrdinalEndLess100Pad>
<OrdinalEndLess1000Pad> = <OrdinalEndTripleDigit>

// Less than 1,000,000, not padded with zeros
<Less1000000Not> = <1..9> thousand "000"
<Less1000000Not> = <1..9> thousand [opt] and <Less1000Pad>
<Less1000000Not> = <DoubleDigit> thousand ",000"
<Less1000000Not> = <DoubleDigit> thousand [opt] and "," <Less1000Pad>
<Less1000000Not> = <TripleDigit> thousand ",000"
<Less1000000Not> = <TripleDigit> thousand [opt] and "," <Less1000Pad>

// Less than 1,000,000, not padded with zeros
// if just thousand then don't convert
// <Less1000000Not19> = <1..9> thousand "000"
<Less1000000Not19> = <1..9> thousand [opt] and <Less1000Pad>
// <Less1000000Not19> = <DoubleDigit> thousand ",000"
<Less1000000Not19> = <DoubleDigit> thousand [opt] and "," <Less1000Pad>
// <Less1000000Not19> = <TripleDigit> thousand ",000"
<Less1000000Not19> = <TripleDigit> thousand [opt] and "," <Less1000Pad>

// Ordinal Less than 1,000,000, not padded with zeros, without ending
<OrdinalLess1000000Not> = <1..9> thousandth ",000"
<OrdinalLess1000000Not> = <1..9> thousand [opt] and "," <OrdinalLess1000Pad>
<OrdinalLess1000000Not> = <DoubleDigit> thousandth ",000"
<OrdinalLess1000000Not> = <DoubleDigit> thousand [opt] and "," <OrdinalLess1000Pad>
<OrdinalLess1000000Not> = <TripleDigit> thousandth ",000"
<OrdinalLess1000000Not> = <TripleDigit> thousand [opt] and "," <OrdinalLess1000Pad>

// Ordinal Less than 1,000,000, not padded with zeros, with ending
<OrdinalEndLess1000000Not> = <1..9> thousandth ",000th"
<OrdinalEndLess1000000Not> = <1..9> thousand [opt] and "," <OrdinalEndLess1000Pad>
<OrdinalEndLess1000000Not> = <DoubleDigit> thousandth ",000th"
<OrdinalEndLess1000000Not> = <DoubleDigit> thousand [opt] and "," <OrdinalEndLess1000Pad>
<OrdinalEndLess1000000Not> = <TripleDigit> thousandth ",000th"
<OrdinalEndLess1000000Not> = <TripleDigit> thousand [opt] and "," <OrdinalEndLess1000Pad>

// Less than 1,000,000, padded with zeros
<Less1000000Pad> = "000," <Less1000Pad>
<Less1000000Pad> = thousand [opt] and "001," <Less1000Pad>
<Less1000000Pad> = <Less1000Pad> thousand ",000"
<Less1000000Pad> = <Less1000Pad> thousand [opt] and "," <Less1000Pad>

// Ordinal Less than 1,000,000, padded with zeros, without ending
<OrdinalLess1000000Pad> = "000," <OrdinalLess1000Pad>
<OrdinalLess1000000Pad> = thousand [opt] and "001," <OrdinalLess1000Pad>
<OrdinalLess1000000Pad> = <Less1000Pad> thousandth ",000"
<OrdinalLess1000000Pad> = <Less1000Pad> thousand [opt] and "," <OrdinalLess1000Pad>

// Ordinal Less than 1,000,000, padded with zeros, with ending
<OrdinalEndLess1000000Pad> = "000," <OrdinalEndLess1000Pad>
<OrdinalEndLess1000000Pad> = thousand [opt] and "001," <OrdinalEndLess1000Pad>
<OrdinalEndLess1000000Pad> = <Less1000Pad> thousandth ",000th"
<OrdinalEndLess1000000Pad> = <Less1000Pad> thousand [opt] and "," <OrdinalEndLess1000Pad>

// Less than 1,000,000,000, not padded with zeros
// Disable cause revamp natural: <Less1000000000Not> = <Less1000000Not>
// "million" by itself is not converted - <Less1000000000Not> = million "1,000,000"
// "million" by itself is not converted - <Less1000000000Not> = million [opt] and "1," <Less1000000Pad>
<Less1000000000Not> = <Less100Not> million ",000,000"
<Less1000000000Not> = <Less100Not> million [opt] and "," <Less1000000Pad>
<Less1000000000Not> = <Less1000Not> million ",000,000"
<Less1000000000Not> = <Less1000Not> million [opt] and "," <Less1000000Pad>

// Less than 1,000,000,000, not padded with zeros
// Disable cause revamp natural: <Less1000000000Not> = <Less1000000Not>
// "million" by itself is not converted - left as word
// "million" by itself is not converted - <Less1000000000Not> = million [opt] and "1," <Less1000000Pad>
// <Less1000000000Not19> = <Less100Not> million ",000,000"
<Less1000000000Not19> = <Less100Not> million [opt] and "," <Less1000000Pad>
// <Less1000000000Not19> = <Less1000Not> million ",000,000"
<Less1000000000Not19> = <Less1000Not> million [opt] and "," <Less1000000Pad>

// Ordinal Less than 1,000,000,000, not padded with zeros, without ending
// Disable cause revamp natural: <Less1000000000Not> = <Less1000000Not>
// "million" by itself is not converted - <Less1000000000Not> = million "1,000,000"
// "million" by itself is not converted - <Less1000000000Not> = million [opt] and "1," <Less1000000Pad>
<OrdinalLess1000000000Not> = <Less100Not> millionth ",000,000"
<OrdinalLess1000000000Not> = <Less100Not> million [opt] and "," <OrdinalLess1000000Pad>
<OrdinalLess1000000000Not> = <Less1000Not> millionth ",000,000"
<OrdinalLess1000000000Not> = <Less1000Not> million [opt] and "," <OrdinalLess1000000Pad>

// Ordinal Less than 1,000,000,000, not padded with zeros, with ending
// Disable cause revamp natural: <Less1000000000Not> = <Less1000000Not>
// "million" by itself is not converted - <Less1000000000Not> = million "1,000,000"
// "million" by itself is not converted - <Less1000000000Not> = million [opt] and "1," <Less1000000Pad>
<OrdinalEndLess1000000000Not> = <Less100Not> millionth ",000,000th"
<OrdinalEndLess1000000000Not> = <Less100Not> million [opt] and "," <OrdinalEndLess1000000Pad>
<OrdinalEndLess1000000000Not> = <Less1000Not> millionth ",000,000th"
<OrdinalEndLess1000000000Not> = <Less1000Not> million [opt] and "," <OrdinalEndLess1000000Pad>

// Less than 1,000,000,000, padded with zeros
<Less1000000000Pad> = "000," <Less1000000Pad>
<Less1000000000Pad> = million [opt] and "001," <Less1000000Pad>
<Less1000000000Pad> = <Less1000Pad> million ",000,000"
<Less1000000000Pad> = <Less1000Pad> million [opt] and "," <Less1000000Pad>

// Ordinal, Less than 1,000,000,000, padded with zeros, without ending
<OrdinalLess1000000000Pad> = "000," <OrdinalLess1000000Pad>
<OrdinalLess1000000000Pad> = million [opt] and "001," <OrdinalLess1000000Pad>
<OrdinalLess1000000000Pad> = <Less1000Pad> millionth ",000,000"
<OrdinalLess1000000000Pad> = <Less1000Pad> million [opt] and "," <OrdinalLess1000000Pad>

// Ordinal, Less than 1,000,000,000, padded with zeros, with ending
<OrdinalEndLess1000000000Pad> = "000," <OrdinalEndLess1000000Pad>
<OrdinalEndLess1000000000Pad> = million [opt] and "001," <OrdinalEndLess1000000Pad>
<OrdinalEndLess1000000000Pad> = <Less1000Pad> millionth ",000,000th"
<OrdinalEndLess1000000000Pad> = <Less1000Pad> million [opt] and "," <OrdinalEndLess1000000Pad>

// Less than 1,000,000,000,000, not padded with zeros
// Disable cause revamp natural: <Less1000000000000Not> = <Less1000000000Not>
// "billion" by itself is not converted - <Less1000000000000Not> = billion "1,000,000,000"
// "billion" by itself is not converted - <Less1000000000000Not> = billion [opt] and "1," <Less1000000000Pad>
<Less1000000000000Not> = <Less100Not> billion ",000,000,000"
<Less1000000000000Not> = <Less100Not> billion [opt] and "," <Less1000000000Pad>
<Less1000000000000Not> = <Less1000Not> billion ",000,000,000"
<Less1000000000000Not> = <Less1000Not> billion [opt] and "," <Less1000000000Pad>

// Less than 1,000,000,000,000, not padded with zeros
// Disable cause revamp natural: <Less1000000000000Not> = <Less1000000000Not>
// "billion" by itself is not converted - left as word
// "billion" by itself is not converted - <Less1000000000000Not> = billion [opt] and "1," <Less1000000000Pad>
// <Less1000000000000Not19> = <Less100Not> billion ",000,000,000"
<Less1000000000000Not19> = <Less100Not> billion [opt] and "," <Less1000000000Pad>
// <Less1000000000000Not19> = <Less1000Not> billion ",000,000,000"
<Less1000000000000Not19> = <Less1000Not> billion [opt] and "," <Less1000000000Pad>

// Ordinal, Less than 1,000,000,000,000, not padded with zeros, without ending
// Disable cause revamp natural: <Less1000000000000Not> = <Less1000000000Not>
// "billion" by itself is not converted - <Less1000000000000Not> = billion "1,000,000,000"
// "billion" by itself is not converted - <Less1000000000000Not> = billion [opt] and "1," <Less1000000000Pad>
<OrdinalLess1000000000000Not> = <Less100Not> billionth ",000,000,000"
<OrdinalLess1000000000000Not> = <Less100Not> billion [opt] and "," <OrdinalLess1000000000Pad>
<OrdinalLess1000000000000Not> = <Less1000Not> billionth ",000,000,000"
<OrdinalLess1000000000000Not> = <Less1000Not> billion [opt] and "," <OrdinalLess1000000000Pad>

// Ordinal, Less than 1,000,000,000,000, not padded with zeros, with ending
// Disable cause revamp natural: <Less1000000000000Not> = <Less1000000000Not>
// "billion" by itself is not converted - <Less1000000000000Not> = billion "1,000,000,000"
// "billion" by itself is not converted - <Less1000000000000Not> = billion [opt] and "1," <Less1000000000Pad>
<OrdinalEndLess1000000000000Not> = <Less100Not> billionth ",000,000,000th"
<OrdinalEndLess1000000000000Not> = <Less100Not> billion [opt] and "," <OrdinalLess1000000000Pad>
<OrdinalEndLess1000000000000Not> = <Less1000Not> billionth ",000,000,000th"
<OrdinalEndLess1000000000000Not> = <Less1000Not> billion [opt] and "," <OrdinalLess1000000000Pad>

// Less than 1,000,000,000,000, padded with zeros
<Less1000000000000Pad> = "000," <Less1000000000Pad>
<Less1000000000000Pad> = billion [opt] and "001," <Less1000000000Pad>
<Less1000000000000Pad> = <Less1000Pad> billion ",000,000,000"
<Less1000000000000Pad> = <Less1000Pad> billion [opt] and "," <Less1000000000Pad>

// Ordinal, Less than 1,000,000,000,000, padded with zeros, withouth ending
<OrdinalLess1000000000000Pad> = "000," <OrdinalLess1000000000Pad>
<OrdinalLess1000000000000Pad> = billion [opt] and "001," <OrdinalLess1000000000Pad>
<OrdinalLess1000000000000Pad> = <Less1000Pad> billionth ",000,000,000"
<OrdinalLess1000000000000Pad> = <Less1000Pad> billion [opt] and "," <OrdinalLess1000000000Pad>

// Ordinal, Less than 1,000,000,000,000, padded with zeros, with ending
<OrdinalEndLess1000000000000Pad> = "000," <OrdinalEndLess1000000000Pad>
<OrdinalEndLess1000000000000Pad> = billion [opt] and "001," <OrdinalEndLess1000000000Pad>
<OrdinalEndLess1000000000000Pad> = <Less1000Pad> billionth ",000,000,000th"
<OrdinalEndLess1000000000000Pad> = <Less1000Pad> billion [opt] and "," <OrdinalEndLess1000000000Pad>


// Less than 1,000,000,000,000,000, not padded with zeros
// Disable cause revamp natural: <Less1000000000000000Not> = <Less1000000000000Not>
// "trillion" by itself is not converted - <Less1000000000000000Not> = trillion "1,000,000,000,000"
// "trillion" by itself is not converted - <Less1000000000000000Not> = trillion [opt] and "1," <Less1000000000000Pad>
<Less1000000000000000Not> = <Less100Not> trillion ",000,000,000,000"
<Less1000000000000000Not> = <Less100Not> trillion [opt] and "," <Less1000000000000Pad>
<Less1000000000000000Not> = <Less1000Not> trillion ",000,000,000,000"
<Less1000000000000000Not> = <Less1000Not> trillion [opt] and "," <Less1000000000000Pad>

// Less than 1,000,000,000,000,000, not padded with zeros
// Disable cause revamp natural: <Less1000000000000000Not> = <Less1000000000000Not>
// "trillion" by itself is not converted - left as word
// "trillion" by itself is not converted - <Less1000000000000000Not> = trillion [opt] and "1," <Less1000000000000Pad>
// <Less1000000000000000Not19> = <Less100Not> trillion ",000,000,000,000"
<Less1000000000000000Not19> = <Less100Not> trillion [opt] and "," <Less1000000000000Pad>
// <Less1000000000000000Not19> = <Less1000Not> trillion ",000,000,000,000"
<Less1000000000000000Not19> = <Less1000Not> trillion [opt] and "," <Less1000000000000Pad>

// Ordinal ,Less than 1,000,000,000,000,000, not padded with zeros, without ending
// Disable cause revamp natural: <Less1000000000000000Not> = <Less1000000000000Not>
// "trillion" by itself is not converted - <Less1000000000000000Not> = trillion "1,000,000,000,000"
// "trillion" by itself is not converted - <Less1000000000000000Not> = trillion [opt] and "1," <Less1000000000000Pad>
<OrdinalLess1000000000000000Not> = <Less100Not> trillionth ",000,000,000,000"
<OrdinalLess1000000000000000Not> = <Less100Not> trillion [opt] and "," <OrdinalLess1000000000000Pad>
<OrdinalLess1000000000000000Not> = <Less1000Not> trillionth ",000,000,000,000"
<OrdinalLess1000000000000000Not> = <Less1000Not> trillion [opt] and "," <OrdinalLess1000000000000Pad>

// Ordinal ,Less than 1,000,000,000,000,000, not padded with zeros, with ending
// Disable cause revamp natural: <Less1000000000000000Not> = <Less1000000000000Not>
// "trillion" by itself is not converted - <Less1000000000000000Not> = trillion "1,000,000,000,000"
// "trillion" by itself is not converted - <Less1000000000000000Not> = trillion [opt] and "1," <Less1000000000000Pad>
<OrdinalEndLess1000000000000000Not> = <Less100Not> trillionth ",000,000,000,000th"
<OrdinalEndLess1000000000000000Not> = <Less100Not> trillion [opt] and "," <OrdinalEndLess1000000000000Pad>
<OrdinalEndLess1000000000000000Not> = <Less1000Not> trillionth ",000,000,000,000th"
<OrdinalEndLess1000000000000000Not> = <Less1000Not> trillion [opt] and "," <OrdinalEndLess1000000000000Pad>

// Less than 1,000,000,000,000,000, padded with zeros
<Less1000000000000000Pad> = "000," <Less1000000000000Pad>
<Less1000000000000000Pad> = trillion [opt] and "001," <Less1000000000000Pad>
<Less1000000000000000Pad> = <Less1000Pad> trillion ",000,000,000,000"
<Less1000000000000000Pad> = <Less1000Pad> trillion [opt] and "," <Less1000000000000Pad>

// Ordinal, Less than 1,000,000,000,000,000, padded with zeros, without ending
<OrdinalLess1000000000000000Pad> = "000," <OrdinalLess1000000000000Pad>
<OrdinalLess1000000000000000Pad> = trillion [opt] and "001," <OrdinalLess1000000000000Pad>
<OrdinalLess1000000000000000Pad> = <Less1000Pad> trillionth ",000,000,000,000"
<OrdinalLess1000000000000000Pad> = <Less1000Pad> trillion [opt] and "," <OrdinalLess1000000000000Pad>

// Ordinal, Less than 1,000,000,000,000,000, padded with zeros, with ending
<OrdinalEndLess1000000000000000Pad> = "000," <OrdinalEndLess1000000000000Pad>
<OrdinalEndLess1000000000000000Pad> = trillion [opt] and "001," <OrdinalEndLess1000000000000Pad>
<OrdinalEndLess1000000000000000Pad> = <Less1000Pad> trillionth ",000,000,000,000th"
<OrdinalEndLess1000000000000000Pad> = <Less1000Pad> trillion [opt] and "," <OrdinalEndLess1000000000000Pad>