/*
 *******************************************************************************
 * Copyright (C) 1996-2000, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 *
 * $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/icu/dev/demo/rbnf/RbnfSampleRuleSets.java,v $ 
 * $Date: 2003/05/14 18:35:53 $ 
 * $Revision: 1.4 $
 *
 *****************************************************************************************
 */
package com.ibm.icu.dev.demo.rbnf;

import java.util.Locale;

/**
 * A collection of example rule sets for use with RuleBasedNumberFormat.
 * These examples are intended to serve both as demonstrations of what can
 * be done with this framework, and as starting points for designing new
 * rule sets.
 *
 * For those that claim to represent number-spellout rules for languages
 * other than U.S. English, we make no claims of either accuracy or
 * completeness.  In fact, we know them to be incomplete, and suspect
 * most have mistakes in them.  If you see something that you know is wrong,
 * please tell us!
 *
 * @author Richard Gillam
 * @version $Version$ $Date: 2003/05/14 18:35:53 $
 */
public class RbnfSampleRuleSets {
    /**
     * Puts a copyright in the .class file
     */
    private static final String copyrightNotice
        = "Copyright \u00a91997-1998 IBM Corp.  All rights reserved.";

    //========================================================================
    // Spellout rules for various languages
    //
    // The following RuleBasedNumberFormat descriptions show the rules for
    // spelling out numeric values in various languages.  As mentioned
    // before, we cannot vouch for the accuracy or completeness of this
    // data, although we believe it's pretty close.  Basically, this
    // represents one day's worth of Web-surfing.  If you can supply the
    // missing information in any of these rule sets, or if you find errors,
    // or if you can supply spellout rules for languages that aren't shown
    // here, we want to hear from you!
    //========================================================================

    /**
     * Spellout rules for U.S. English.  This demonstration version of the
     * U.S. English spellout rules has four variants: 1) %simplified is a
     * set of rules showing the simple method of spelling out numbers in
     * English: 289 is formatted as "two hundred eighty-nine".  2) %alt-teens
     * is the same as %simplified, except that values between 1,000 and 9,999
     * whose hundreds place isn't zero are formatted in hundreds.  For example,
     * 1,983 is formatted as "nineteen hundred eighty-three," and 2,183 is
     * formatted as "twenty-one hundred eighty-three," but 2,083 is still
     * formatted as "two thousand eighty-three."  3) %ordinal formats the
     * values as ordinal numbers in English (e.g., 289 is "two hundred eighty-
     * ninth").  4) %default uses a more complicated algorithm to format
     * numbers in a more natural way: 289 is formatted as "two hundred AND
     * eighty-nine" and commas are inserted between the thousands groups for
     * values above 100,000.
     */
    public static final String usEnglish =
        // This rule set shows the normal simple formatting rules for English
        "%simplified:\n"
               // negative number rule.  This rule is used to format negative
               // numbers.  The result of formatting the number's absolute
               // value is placed where the >> is.
        + "    -x: minus >>;\n"
               // faction rule.  This rule is used for formatting numbers
               // with fractional parts.  The result of formatting the
               // number's integral part is substituted for the <<, and
               // the result of formatting the number's fractional part
               // (one digit at a time, e.g., 0.123 is "zero point one two
               // three") replaces the >>.
        + "    x.x: << point >>;\n"
               // the rules for the values from 0 to 19 are simply the
               // words for those numbers
        + "    zero; one; two; three; four; five; six; seven; eight; nine;\n"
        + "    ten; eleven; twelve; thirteen; fourteen; fifteen; sixteen;\n"
        + "        seventeen; eighteen; nineteen;\n"
               // beginning at 20, we use the >> to mark the position where
               // the result of formatting the number's ones digit.  Thus,
               // we only need a new rule at every multiple of 10.  Text in
               // backets is omitted if the value being formatted is an
               // even multiple of 10.
        + "    20: twenty[->>];\n"
        + "    30: thirty[->>];\n"
        + "    40: forty[->>];\n"
        + "    50: fifty[->>];\n"
        + "    60: sixty[->>];\n"
        + "    70: seventy[->>];\n"
        + "    80: eighty[->>];\n"
        + "    90: ninety[->>];\n"
               // beginning at 100, we can use << to mark the position where
               // the result of formatting the multiple of 100 is to be
               // inserted.  Notice also that the meaning of >> has shifted:
               // here, it refers to both the ones place and the tens place.
               // The meanings of the << and >> tokens depend on the base value
               // of the rule.  A rule's divisor is (usually) the highest
               // power of 10 that is less than or equal to the rule's base
               // value.  The value being formatted is divided by the rule's
               // divisor, and the integral quotient is used to get the text
               // for <<, while the remainder is used to produce the text
               // for >>.  Again, text in brackets is omitted if the value
               // being formatted is an even multiple of the rule's divisor
               // (in this case, an even multiple of 100)
        + "    100: << hundred[ >>];\n"
               // The rules for the higher numbers work the same way as the
               // rule for 100: Again, the << and >> tokens depend on the
               // rule's divisor, which for all these rules is also the rule's
               // base value.  To group by thousand, we simply don't have any
               // rules between 1,000 and 1,000,000.
        + "    1000: << thousand[ >>];\n"
        + "    1,000,000: << million[ >>];\n"
        + "    1,000,000,000: << billion[ >>];\n"
        + "    1,000,000,000,000: << trillion[ >>];\n"
               // overflow rule.  This rule specifies that values of a
               // quadrillion or more are shown in numerals rather than words.
               // The == token means to format (with new rules) the value
               // being formatted by this rule and place the result where
               // the == is.  The #,##0 inside the == signs is a
               // DecimalFormat pattern.  It specifies that the value should
               // be formatted with a DecimalFormat object, and that it
               // should be formatted with no decimal places, at least one
               // digit, and a thousands separator.
        + "    1,000,000,000,000,000: =#,##0=;\n"

        // This rule set formats numbers between 1,000 and 9,999 somewhat
        // differently: If the hundreds digit is not zero, the first two
        // digits are treated as a number of hundreds.  For example, 2,197
        // would come out as "twenty-one hundred ninety-seven."
        + "%alt-teens:\n"
               // just use %simplified to format values below 1,000
        + "    =%simplified=;\n"
               // values between 1,000 and 9,999 are delegated to %%alt-hundreds
               // for formatting.  The > after "1000" decreases the exponent
               // of the rule's radix by one, causing the rule's divisor
               // to be 100 instead of 1,000.  This causes the first TWO
               // digits of the number, instead of just the first digit,
               // to be sent to %%alt-hundreds
        + "    1000>: <%%alt-hundreds<[ >>];\n"
               // for values of 10,000 and more, we again just use %simplified
        + "    10,000: =%simplified=;\n"
        // This rule set uses some obscure voodoo of the description language
        // to format the first two digits of a value in the thousands.
        // The rule at 10 formats the first two digits as a multiple of 1,000
        // and the rule at 11 formats the first two digits as a multiple of
        // 100.  This works because of something known as the "rollback rule":
        // if the rule applicable to the value being formatted has two
        // substitutions, the value being formatted is an even multiple of
        // the rule's divisor, and the rule's base value ISN'T an even multiple
        // if the rule's divisor, then the rule that precedes this one in the
        // list is used instead.  (The [] notation is implemented internally
        // using this notation: a rule containing [] is split into two rules,
        // and the right one is chosen using the rollback rule.) In this case,
        // it means that if the first two digits are an even multiple of 10,
        // they're formatted with the 10 rule (containing "thousand"), and if
        // they're not, they're formatted with the 11 rule (containing
        // "hundred").  %%empty is a hack to cause the rollback rule to be
        // invoked: it makes the 11 rule have two substitutions, even though
        // the second substitution (calling %%empty) doesn't actually do
        // anything.
        + "%%alt-hundreds:\n"
        + "    0: SHOULD NEVER GET HERE!;\n"
        + "    10: <%simplified< thousand;\n"
        + "    11: =%simplified= hundred>%%empty>;\n"
        + "%%empty:\n"
        + "    0:;"

        // this rule set is the same as %simplified, except that it formats
        // the value as an ordinal number: 234 is formatted as "two hundred
        // thirty-fourth".  Notice the calls to ^simplified: we have to
        // call %simplified to avoid getting "second hundred thirty-fourth."
        + "%ordinal:\n"
        + "    zeroth; first; second; third; fourth; fifth; sixth; seventh;\n"
        + "        eighth; ninth;\n"
        + "    tenth; eleventh; twelfth; thirteenth; fourteenth;\n"
        + "        fifteenth; sixteenth; seventeenth; eighteenth;\n"
        + "        nineteenth;\n"
        + "    twentieth; twenty->>;\n"
        + "    30: thirtieth; thirty->>;\n"
        + "    40: fortieth; forty->>;\n"
        + "    50: fiftieth; fifty->>;\n"
        + "    60: sixtieth; sixty->>;\n"
        + "    70: seventieth; seventy->>;\n"
        + "    80: eightieth; eighty->>;\n"
        + "    90: ninetieth; ninety->>;\n"
        + "    100: <%simplified< hundredth; <%simplified< hundred >>;\n"
        + "    1000: <%simplified< thousandth; <%simplified< thousand >>;\n"
        + "    1,000,000: <%simplified< millionth; <%simplified< million >>;\n"
        + "    1,000,000,000: <%simplified< billionth;\n"
        + "        <%simplified< billion >>;\n"
        + "    1,000,000,000,000: <%simplified< trillionth;\n"
        + "        <%simplified< trillion >>;\n"
        + "    1,000,000,000,000,000: =#,##0=;"

        // %default is a more elaborate form of %simplified;  It is basically
        // the same, except that it introduces "and" before the ones digit
        // when appropriate (basically, between the tens and ones digits) and
        // separates the thousands groups with commas in values over 100,000.
        + "%default:\n"
               // negative-number and fraction rules.  These are the same
               // as those for %simplified, but ave to be stated here too
               // because this is an entry point
        + "    -x: minus >>;\n"
        + "    x.x: << point >>;\n"
               // just use %simplified for values below 100
        + "    =%simplified=;\n"
               // for values from 100 to 9,999 use %%and to decide whether or
               // not to interpose the "and"
        + "    100: << hundred[ >%%and>];\n"
        + "    1000: << thousand[ >%%and>];\n"
               // for values of 100,000 and up, use %%commas to interpose the
               // commas in the right places (and also to interpose the "and")
        + "    100,000>>: << thousand[>%%commas>];\n"
        + "    1,000,000: << million[>%%commas>];\n"
        + "    1,000,000,000: << billion[>%%commas>];\n"
        + "    1,000,000,000,000: << trillion[>%%commas>];\n"
        + "    1,000,000,000,000,000: =#,##0=;\n"
        // if the value passed to this rule set is greater than 100, don't
        // add the "and"; if it's less than 100, add "and" before the last
        // digits
        + "%%and:\n"
        + "    and =%default=;\n"
        + "    100: =%default=;\n"
        // this rule set is used to place the commas
        + "%%commas:\n"
               // for values below 100, add "and" (the apostrophe at the
               // beginning is ignored, but causes the space that follows it
               // to be significant: this is necessary because the rules
               // calling %%commas don't put a space before it)
        + "    ' and =%default=;\n"
               // put a comma after the thousands (or whatever preceded the
               // hundreds)
        + "    100: , =%default=;\n"
               // put a comma after the millions (or whatever precedes the
               // thousands)
        + "    1000: , <%default< thousand, >%default>;\n"
               // and so on...
        + "    1,000,000: , =%default=;"
        // %%lenient-parse isn't really a set of number formatting rules;
        // it's a set of collation rules.  Lenient-parse mode uses a Collator
        // object to compare fragments of the text being parsed to the text
        // in the rules, allowing more leeway in the matching text.  This set
        // of rules tells the formatter to ignore commas when parsing (it
        // already ignores spaces, which is why we refer to the space; it also
        // ignores hyphens, making "twenty one" and "twenty-one" parse
        // identically)
        + "%%lenient-parse:\n"
        + "    & ' ' , ',' ;\n";

    /**
     * Spellout rules for U.K. English.  U.K. English has one significant
     * difference from U.S. English: the names for values of 1,000,000,000
     * and higher.  In American English, each successive "-illion" is 1,000
     * times greater than the preceding one: 1,000,000,000 is "one billion"
     * and 1,000,000,000,000 is "one trillion."  In British English, each
     * successive "-illion" is one million times greater than the one before:
     * "one billion" is 1,000,000,000,000 (or what Americans would call a
     * "trillion"), and "one trillion" is 1,000,000,000,000,000,000.
     * 1,000,000,000 in British English is "one thousand million."  (This
     * value is sometimes called a "milliard," but this word seems to have
     * fallen into disuse.)
     */
    public static final String ukEnglish =
        "%simplified:\n"
        + "    -x: minus >>;\n"
        + "    x.x: << point >>;\n"
        + "    zero; one; two; three; four; five; six; seven; eight; nine;\n"
        + "    ten; eleven; twelve; thirteen; fourteen; fifteen; sixteen;\n"
        + "        seventeen; eighteen; nineteen;\n"
        + "    20: twenty[->>];\n"
        + "    30: thirty[->>];\n"
        + "    40: forty[->>];\n"
        + "    50: fifty[->>];\n"
        + "    60: sixty[->>];\n"
        + "    70: seventy[->>];\n"
        + "    80: eighty[->>];\n"
        + "    90: ninety[->>];\n"
        + "    100: << hundred[ >>];\n"
        + "    1000: << thousand[ >>];\n"
        + "    1,000,000: << million[ >>];\n"
        + "    1,000,000,000,000: << billion[ >>];\n"
        + "    1,000,000,000,000,000: =#,##0=;\n"
        + "%alt-teens:\n"
        + "    =%simplified=;\n"
        + "    1000>: <%%alt-hundreds<[ >>];\n"
        + "    10,000: =%simplified=;\n"
        + "    1,000,000: << million[ >%simplified>];\n"
        + "    1,000,000,000,000: << billion[ >%simplified>];\n"
        + "    1,000,000,000,000,000: =#,##0=;\n"
        + "%%alt-hundreds:\n"
        + "    0: SHOULD NEVER GET HERE!;\n"
        + "    10: <%simplified< thousand;\n"
        + "    11: =%simplified= hundred>%%empty>;\n"
        + "%%empty:\n"
        + "    0:;"
        + "%ordinal:\n"
        + "    zeroth; first; second; third; fourth; fifth; sixth; seventh;\n"
        + "        eighth; ninth;\n"
        + "    tenth; eleventh; twelfth; thirteenth; fourteenth;\n"
        + "        fifteenth; sixteenth; seventeenth; eighteenth;\n"
        + "        nineteenth;\n"
        + "    twentieth; twenty->>;\n"
        + "    30: thirtieth; thirty->>;\n"
        + "    40: fortieth; forty->>;\n"
        + "    50: fiftieth; fifty->>;\n"
        + "    60: sixtieth; sixty->>;\n"
        + "    70: seventieth; seventy->>;\n"
        + "    80: eightieth; eighty->>;\n"
        + "    90: ninetieth; ninety->>;\n"
        + "    100: <%simplified< hundredth; <%simplified< hundred >>;\n"
        + "    1000: <%simplified< thousandth; <%simplified< thousand >>;\n"
        + "    1,000,000: <%simplified< millionth; <%simplified< million >>;\n"
        + "    1,000,000,000,000: <%simplified< billionth;\n"
        + "        <%simplified< billion >>;\n"
        + "    1,000,000,000,000,000: =#,##0=;"
        + "%default:\n"
        + "    -x: minus >>;\n"
        + "    x.x: << point >>;\n"
        + "    =%simplified=;\n"
        + "    100: << hundred[ >%%and>];\n"
        + "    1000: << thousand[ >%%and>];\n"
        + "    100,000>>: << thousand[>%%commas>];\n"
        + "    1,000,000: << million[>%%commas>];\n"
        + "    1,000,000,000,000: << billion[>%%commas>];\n"
        + "    1,000,000,000,000,000: =#,##0=;\n"
        + "%%and:\n"
        + "    and =%default=;\n"
        + "    100: =%default=;\n"
        + "%%commas:\n"
        + "    ' and =%default=;\n"
        + "    100: , =%default=;\n"
        + "    1000: , <%default< thousand, >%default>;\n"
        + "    1,000,000: , =%default=;"
        + "%%lenient-parse:\n"
        + "    & ' ' , ',' ;\n";
    // Could someone please correct me if I'm wrong about "milliard" falling
    // into disuse, or have missed any other details of how large numbers
    // are rendered.  Also, could someone please provide me with information
    // on which other English-speaking countries use which system?  Right now,
    // I'm assuming that the U.S. system is used in Canada and that all the
    // other English-speaking countries follow the British system.  Can
    // someone out there confirm this?

    /**
     * Spellout rules for Spanish.  The Spanish rules are quite similar to
     * the English rules, but there are some important differences:
     * First, we have to provide separate rules for most of the twenties
     * because the ones digit frequently picks up an accent mark that it
     * doesn't have when standing alone.  Second, each multiple of 100 has
     * to be specified separately because the multiplier on 100 very often
     * changes form in the contraction: 500 is "quinientos," not
     * "cincocientos."  In addition, the word for 100 is "cien" when
     * standing alone, but changes to "ciento" when followed by more digits.
     * There also some other differences.
     */
    public static final String spanish =
        // negative-number and fraction rules
        "-x: menos >>;\n"
        + "x.x: << punto >>;\n"
        // words for values from 0 to 19
        + "cero; uno; dos; tres; cuatro; cinco; seis; siete; ocho; nueve;\n"
        + "diez; once; doce; trece; catorce; quince; diecis\u00e9is;\n"
        + "    diecisiete; dieciocho; diecinueve;\n"
        // words for values from 20 to 29 (necessary because the ones digit
        // often picks up an accent mark it doesn't have when standing alone)
        + "veinte; veintiuno; veintid\u00f3s; veintitr\u00e9s; veinticuatro;\n"
        + "    veinticinco; veintis\u00e9is; veintisiete; veintiocho;\n"
        + "    veintinueve;\n"
        // words for multiples of 10 (notice that the tens digit is separated
        // from the ones digit by the word "y".)
        + "30: treinta[ y >>];\n"
        + "40: cuarenta[ y >>];\n"
        + "50: cincuenta[ y >>];\n"
        + "60: sesenta[ y >>];\n"
        + "70: setenta[ y >>];\n"
        + "80: ochenta[ y >>];\n"
        + "90: noventa[ y >>];\n"
        // 100 by itself is "cien," but 100 followed by something is "cineto"
        + "100: cien;\n"
        + "101: ciento >>;\n"
        // words for multiples of 100 (must be stated because they're
        // rarely simple concatenations)
        + "200: doscientos[ >>];\n"
        + "300: trescientos[ >>];\n"
        + "400: cuatrocientos[ >>];\n"
        + "500: quinientos[ >>];\n"
        + "600: seiscientos[ >>];\n"
        + "700: setecientos[ >>];\n"
        + "800: ochocientos[ >>];\n"
        + "900: novecientos[ >>];\n"
        // for 1,000, the multiplier on "mil" is omitted: 2,000 is "dos mil,"
        // but 1,000 is just "mil."
        + "1000: mil[ >>];\n"
        + "2000: << mil[ >>];\n"
        // 1,000,000 is "un millon," not "uno millon"
        + "1,000,000: un mill\u00f3n[ >>];\n"
        + "2,000,000: << mill\u00f3n[ >>];\n"
        // overflow rule
        + "1,000,000,000: =#,##0= (incomplete data);";
    // The Spanish rules are incomplete.  I'm missing information on negative
    // numbers and numbers with fractional parts.  I also don't have
    // information on numbers higher than the millions

    /**
     * Spellout rules for French.  French adds some interesting quirks of its
     * own: 1) The word "et" is interposed between the tens and ones digits,
     * but only if the ones digit if 1: 20 is "vingt," and 2 is "vingt-deux,"
     * but 21 is "vingt-et-un."  2)  There are no words for 70, 80, or 90.
     * "quatre-vingts" ("four twenties") is used for 80, and values proceed
     * by score from 60 to 99 (e.g., 73 is "soixante-treize" ["sixty-thirteen"]).
     * Numbers from 1,100 to 1,199 are rendered as hundreds rather than
     * thousands: 1,100 is "onze cents" ("eleven hundred"), rather than
     * "mille cent" ("one thousand one hundred")
     */
    public static final String french =
        // the main rule set
        "%main:\n"
               // negative-number and fraction rules
        + "    -x: moins >>;\n"
        + "    x.x: << virgule >>;\n"
               // words for numbers from 0 to 10
        + "    z\u00e9ro; un; deux; trois; quatre; cinq; six; sept; huit; neuf;\n"
        + "    dix; onze; douze; treize; quatorze; quinze; seize;\n"
        + "        dix-sept; dix-huit; dix-neuf;\n"
               // ords for the multiples of 10: %%alt-ones inserts "et"
               // when needed
        + "    20: vingt[->%%alt-ones>];\n"
        + "    30: trente[->%%alt-ones>];\n"
        + "    40: quarante[->%%alt-ones>];\n"
        + "    50: cinquante[->%%alt-ones>];\n"
               // rule for 60.  The /20 causes this rule's multiplier to be
               // 20 rather than 10, allowinhg us to recurse for all values
               // from 60 to 79...
        + "    60/20: soixante[->%%alt-ones>];\n"
               // ...except for 71, which must be special-cased
        + "    71: soixante et onze;\n"
               // at 72, we have to repeat the rule for 60 to get us to 79
        + "    72/20: soixante->%%alt-ones>;\n"
               // at 80, we state a new rule with the phrase for 80.  Since
               // it changes form when there's a ones digit, we need a second
               // rule at 81.  This rule also includes "/20," allowing it to
               // be used correctly for all values up to 99
        + "    80: quatre-vingts; 81/20: quatre-vingt->>;\n"
               // "cent" becomes plural when preceded by a multiplier, and
               // the multiplier is omitted from the singular form
        + "    100: cent[ >>];\n"
        + "    200: << cents[ >>];\n"
        + "    1000: mille[ >>];\n"
               // values from 1,100 to 1,199 are rendered as "onze cents..."
               // instead of "mille cent..."  The > after "1000" decreases
               // the rule's exponent, causing its multiplier to be 100 instead
               // of 1,000.  This prevents us from getting "onze cents cent
               // vingt-deux" ("eleven hundred one hundred twenty-two").
        + "    1100>: onze cents[ >>];\n"
               // at 1,200, we go back to formating in thousands, so we
               // repeat the rule for 1,000
        + "    1200: mille >>;\n"
               // at 2,000, the multiplier is added
        + "    2000: << mille[ >>];\n"
        + "    1,000,000: << million[ >>];\n"
        + "    1,000,000,000: << milliarde[ >>];\n"
        + "    1,000,000,000,000: << billion[ >>];\n"
        + "    1,000,000,000,000,000: =#,##0=;\n"
        // %%alt-ones is used to insert "et" when the ones digit is 1
        + "%%alt-ones:\n"
        + "    ; et-un; =%main=;";

    /**
     * Spellout rules for Swiss French.  Swiss French differs from French French
     * in that it does have words for 70, 80, and 90.  This rule set shows them,
     * and is simpler as a result.
     */
    public static final String swissFrench =
        "%main:\n"
        + "    -x: moins >>;\n"
        + "    x.x: << virgule >>;\n"
        + "    z\u00e9ro; un; deux; trois; quatre; cinq; six; sept; huit; neuf;\n"
        + "    dix; onze; douze; treize; quatorze; quinze; seize;\n"
        + "        dix-sept; dix-huit; dix-neuf;\n"
        + "    20: vingt[->%%alt-ones>];\n"
        + "    30: trente[->%%alt-ones>];\n"
        + "    40: quarante[->%%alt-ones>];\n"
        + "    50: cinquante[->%%alt-ones>];\n"
        + "    60: soixante[->%%alt-ones>];\n"
               // notice new words for 70, 80, and 90
        + "    70: septante[->%%alt-ones>];\n"
        + "    80: octante[->%%alt-ones>];\n"
        + "    90: nonante[->%%alt-ones>];\n"
        + "    100: cent[ >>];\n"
        + "    200: << cents[ >>];\n"
        + "    1000: mille[ >>];\n"
        + "    1100>: onze cents[ >>];\n"
        + "    1200: mille >>;\n"
        + "    2000: << mille[ >>];\n"
        + "    1,000,000: << million[ >>];\n"
        + "    1,000,000,000: << milliarde[ >>];\n"
        + "    1,000,000,000,000: << billion[ >>];\n"
        + "    1,000,000,000,000,000: =#,##0=;\n"
        + "%%alt-ones:\n"
        + "    ; et-un; =%main=;";
    // I'm not 100% sure about Swiss French.  Is
    // this correct?  Is "onze cents" commonly used for 1,100 in both France
    // and Switzerland?  Can someone fill me in on the rules for the other
    // French-speaking countries?  I've heard conflicting opinions on which
    // version is used in Canada, and I understand there's an alternate set
    // of words for 70, 80, and 90 that is used somewhere, but I don't know
    // what those words are or where they're used.

    /**
     * Spellout rules for German.  German also adds some interesting
     * characteristics.  For values below 1,000,000, numbers are customarily
     * written out as a single word.  And the ones digit PRECEDES the tens
     * digit (e.g., 23 is "dreiundzwanzig," not "zwanzigunddrei").
     */
    public static final String german =
        // 1 is "eins" when by itself, but turns into "ein" in most
        // combinations
        "%alt-ones:\n"
        + "    null; eins; =%%main=;\n"
        + "%%main:\n"
               // words for numbers from 0 to 12.  Notice that the values
               // from 13 to 19 can derived algorithmically, unlike in most
               // other languages
        + "    null; ein; zwei; drei; vier; f\u00fcnf; sechs; sieben; acht; neun;\n"
        + "    zehn; elf; zw\u00f6lf; >>zehn;\n"
               // rules for the multiples of 10.  Notice that the ones digit
               // goes on the front
        + "    20: [>>und]zwanzig;\n"
        + "    30: [>>und]drei\u00dfig;\n"
        + "    40: [>>und]vierzig;\n"
        + "    50: [>>und]f\u00fcnfzig;\n"
        + "    60: [>>und]sechzig;\n"
        + "    70: [>>und]siebzig;\n"
        + "    80: [>>und]achtzig;\n"
        + "    90: [>>und]neunzig;\n"
        + "    100: hundert[>%alt-ones>];\n"
        + "    200: <<hundert[>%alt-ones>];\n"
        + "    1000: tausend[>%alt-ones>];\n"
        + "    2000: <<tausend[>%alt-ones>];\n"
        + "    1,000,000: eine Million[ >%alt-ones>];\n"
        + "    2,000,000: << Millionen[ >%alt-ones>];\n"
        + "    1,000,000,000: eine Milliarde[ >%alt-ones>];\n"
        + "    2,000,000,000: << Milliarden[ >%alt-ones>];\n"
        + "    1,000,000,000,000: eine Billion[ >%alt-ones>];\n"
        + "    2,000,000,000,000: << Billionen[ >%alt-ones>];\n"
        + "    1,000,000,000,000,000: =#,##0=;";
    // again, I'm not 100% sure of these rules.  I think both "hundert" and
    // "einhundert" are correct or 100, but I'm not sure which is preferable
    // in situations where this framework is likely to be used.  Also, is it
    // really true that numbers are run together into compound words all the
    // time?  And again, I'm missing information on negative numbers and
    // decimas.

    /**
     * Spellout rules for Italian.  Like German, most Italian numbers are
     * written as single words.  What makes these rules complicated is the rule
     * that says that when a word ending in a vowel and a word beginning with
     * a vowel are combined into a compound, the vowel is dropped from the
     * end of the first word: 180 is "centottanta," not "centoottanta."
     * The complexity of this rule set is to produce this behavior.
     */
    public static final String italian =
        // main rule set.  Follows the patterns of the preceding rule sets,
        // except that the final vowel is omitted from words ending in
        // vowels when they are followed by another word; instead, we have
        // separate rule sets that are identical to this one, except that
        // all the words that don't begin with a vowel have a vowel tacked
        // onto them at the front.  A word ending in a vowel calls a
        // substitution that will supply that vowel, unless that vowel is to
        // be elided.
        "%main:\n"
        + "    -x: meno >>;\n"
        + "    x.x: << virgola >>;\n"
        + "    zero; uno; due; tre; quattro; cinque; sei; sette; otto;\n"
        + "        nove;\n"
        + "    dieci; undici; dodici; tredici; quattordici; quindici; sedici;\n"
        + "        diciasette; diciotto; diciannove;\n"
        + "    20: venti; vent>%%with-i>;\n"
        + "    30: trenta; trent>%%with-i>;\n"
        + "    40: quaranta; quarant>%%with-a>;\n"
        + "    50: cinquanta; cinquant>%%with-a>;\n"
        + "    60: sessanta; sessant>%%with-a>;\n"
        + "    70: settanta; settant>%%with-a>;\n"
        + "    80: ottanta; ottant>%%with-a>;\n"
        + "    90: novanta; novant>%%with-a>;\n"
        + "    100: cento; cent[>%%with-o>];\n"
        + "    200: <<cento; <<cent[>%%with-o>];\n"
        + "    1000: mille; mill[>%%with-i>];\n"
        + "    2000: <<mila; <<mil[>%%with-a>];\n"
        + "    100,000>>: <<mila[ >>];\n"
        + "    1,000,000: =#,##0= (incomplete data);\n"
        + "%%with-a:\n"
        + "    azero; uno; adue; atre; aquattro; acinque; asei; asette; otto;\n"
        + "        anove;\n"
        + "    adieci; undici; adodici; atredici; aquattordici; aquindici; asedici;\n"
        + "        adiciasette; adiciotto; adiciannove;\n"
        + "    20: aventi; avent>%%with-i>;\n"
        + "    30: atrenta; atrent>%%with-i>;\n"
        + "    40: aquaranta; aquarant>%%with-a>;\n"
        + "    50: acinquanta; acinquant>%%with-a>;\n"
        + "    60: asessanta; asessant>%%with-a>;\n"
        + "    70: asettanta; asettant>%%with-a>;\n"
        + "    80: ottanta; ottant>%%with-a>;\n"
        + "    90: anovanta; anovant>%%with-a>;\n"
        + "    100: acento; acent[>%%with-o>];\n"
        + "    200: <%%with-a<cento; <%%with-a<cent[>%%with-o>];\n"
        + "    1000: amille; amill[>%%with-i>];\n"
        + "    2000: <%%with-a<mila; <%%with-a<mil[>%%with-a>];\n"
        + "    100,000: =%main=;\n"
        + "%%with-i:\n"
        + "    izero; uno; idue; itre; iquattro; icinque; isei; isette; otto;\n"
        + "        inove;\n"
        + "    idieci; undici; idodici; itredici; iquattordici; iquindici; isedici;\n"
        + "        idiciasette; idiciotto; idiciannove;\n"
        + "    20: iventi; ivent>%%with-i>;\n"
        + "    30: itrenta; itrent>%%with-i>;\n"
        + "    40: iquaranta; iquarant>%%with-a>;\n"
        + "    50: icinquanta; icinquant>%%with-a>;\n"
        + "    60: isessanta; isessant>%%with-a>;\n"
        + "    70: isettanta; isettant>%%with-a>;\n"
        + "    80: ottanta; ottant>%%with-a>;\n"
        + "    90: inovanta; inovant>%%with-a>;\n"
        + "    100: icento; icent[>%%with-o>];\n"
        + "    200: <%%with-i<cento; <%%with-i<cent[>%%with-o>];\n"
        + "    1000: imille; imill[>%%with-i>];\n"
        + "    2000: <%%with-i<mila; <%%with-i<mil[>%%with-a>];\n"
        + "    100,000: =%main=;\n"
        + "%%with-o:\n"
        + "    ozero; uno; odue; otre; oquattro; ocinque; osei; osette; otto;\n"
        + "        onove;\n"
        + "    odieci; undici; ododici; otredici; oquattordici; oquindici; osedici;\n"
        + "        odiciasette; odiciotto; odiciannove;\n"
        + "    20: oventi; ovent>%%with-i>;\n"
        + "    30: otrenta; otrent>%%with-i>;\n"
        + "    40: oquaranta; oquarant>%%with-a>;\n"
        + "    50: ocinquanta; ocinquant>%%with-a>;\n"
        + "    60: osessanta; osessant>%%with-a>;\n"
        + "    70: osettanta; osettant>%%with-a>;\n"
        + "    80: ottanta; ottant>%%with-a>;\n"
        + "    90: onovanta; onovant>%%with-a>;\n"
        + "    100: ocento; ocent[>%%with-o>];\n"
        + "    200: <%%with-o<cento; <%%with-o<cent[>%%with-o>];\n"
        + "    1000: omille; omill[>%%with-i>];\n"
        + "    2000: <%%with-o<mila; <%%with-o<mil[>%%with-a>];\n"
        + "    100,000: =%main=;\n";
    // Can someone confirm that I did the vowel-eliding thing right?  I'm
    // not 100% sure I'm doing it in all the right places, or completely
    // correctly.  Also, I don't have information for negatives and decimals,
    // and I lack words fror values from 1,000,000 on up.

    /**
     * Spellout rules for Swedish.
     */
    public static final String swedish =
        "noll; ett; tv\u00e5; tre; fyra; fem; sex; sjo; \u00e5tta; nio;\n"
        + "tio; elva; tolv; tretton; fjorton; femton; sexton; sjutton; arton; nitton;\n"
        + "20: tjugo[>>];\n"
        + "30: trettio[>>];\n"
        + "40: fyrtio[>>];\n"
        + "50: femtio[>>];\n"
        + "60: sextio[>>];\n"
        + "70: sjuttio[>>];\n"
        + "80: \u00e5ttio[>>];\n"
        + "90: nittio[>>];\n"
        + "100: hundra[>>];\n"
        + "200: <<hundra[>>];\n"
        + "1000: tusen[ >>];\n"
        + "2000: << tusen[ >>];\n"
        + "1,000,000: en miljon[ >>];\n"
        + "2,000,000: << miljon[ >>];\n"
        + "1,000,000,000: en miljard[ >>];\n"
        + "2,000,000,000: << miljard[ >>];\n"
        + "1,000,000,000,000: en biljon[ >>];\n"
        + "2,000,000,000,000: << biljon[ >>];\n"
        + "1,000,000,000,000,000: =#,##0=";
    // can someone supply me with information on negatives and decimals?

    /**
     * Spellout rules for Dutch.  Notice that in Dutch, as in German,
     * the ones digit precedes the tens digit.
     */
    public static final String dutch =
        " -x: min >>;\n"
        + "x.x: << komma >>;\n"
        + "(zero?); een; twee; drie; vier; vijf; zes; zeven; acht; negen;\n"
        + "tien; elf; twaalf; dertien; veertien; vijftien; zestien;\n"
        + "zeventien; achtien; negentien;\n"
        + "20: [>> en ]twintig;\n"
        + "30: [>> en ]dertig;\n"
        + "40: [>> en ]veertig;\n"
        + "50: [>> en ]vijftig;\n"
        + "60: [>> en ]zestig;\n"
        + "70: [>> en ]zeventig;\n"
        + "80: [>> en ]tachtig;\n"
        + "90: [>> en ]negentig;\n"
        + "100: << honderd[ >>];\n"
        + "1000: << duizend[ >>];\n"
        + "1,000,000: << miljoen[ >>];\n"
        + "1,000,000,000: << biljoen[ >>];\n"
        + "1,000,000,000,000: =#,##0=";

    /**
     * Spellout rules for Japanese.  In Japanese, there really isn't any
     * distinction between a number written out in digits and a number
     * written out in words: the ideographic characters are both digits
     * and words.  This rule set provides two variants:  %traditional
     * uses the traditional CJK numerals (which are also used in China
     * and Korea).  %financial uses alternate ideographs for many numbers
     * that are harder to alter than the traditional numerals (one could
     * fairly easily change a one to
     * a three just by adding two strokes, for example).  This is also done in
     * the other countries using Chinese idographs, but different ideographs
     * are used in those places.
     */
    public static final String japanese =
        "%financial:\n"
        + "    \u96f6; \u58f1; \u5f10; \u53c2; \u56db; \u4f0d; \u516d; \u4e03; \u516b; \u4e5d;\n"
        + "    \u62fe[>>];\n"
        + "    20: <<\u62fe[>>];\n"
        + "    100: <<\u767e[>>];\n"
        + "    1000: <<\u5343[>>];\n"
        + "    10,000: <<\u4e07[>>];\n"
        + "    100,000,000: <<\u5104[>>];\n"
        + "    1,000,000,000,000: <<\u5146[>>];\n"
        + "    10,000,000,000,000,000: =#,##0=;\n"
        + "%traditional:\n"
        + "    \u96f6; \u4e00; \u4e8c; \u4e09; \u56db; \u4e94; \u516d; \u4e03; \u516b; \u4e5d;\n"
        + "    \u5341[>>];\n"
        + "    20: <<\u5341[>>];\n"
        + "    100: <<\u767e[>>];\n"
        + "    1000: <<\u5343[>>];\n"
        + "    10,000: <<\u4e07[>>];\n"
        + "    100,000,000: <<\u5104[>>];\n"
        + "    1,000,000,000,000: <<\u5146[>>];\n"
        + "    10,000,000,000,000,000: =#,##0=;";
    // Can someone supply me with the right fraud-proof ideographs for
    // Simplified and Traditional Chinese, and for Korean?  Can someone
    // supply me with information on negatives and decimals?

    /**
     * Spellout rules for Greek.  Again in Greek we have to supply the words
     * for the multiples of 100 because they can't be derived algorithmically.
     * Also, the tens dgit changes form when followed by a ones digit: an
     * accent mark disappears from the tens digit and moves to the ones digit.
     * Therefore, instead of using the [] notation, we actually have to use
     * two separate rules for each multiple of 10 to show the two forms of
     * the word.
     */
    public static final String greek =
        "zero (incomplete data); \u03ad\u03bd\u03b1; \u03b4\u03cd\u03bf; \u03b4\u03c1\u03af\u03b1; "
        + "\u03c4\u03ad\u03c3\u03c3\u03b5\u03c1\u03b1; \u03c0\u03ad\u03bd\u03c4\u03b5; "
        + "\u03ad\u03be\u03b9; \u03b5\u03c0\u03c4\u03ac; \u03bf\u03ba\u03c4\u03ce; "
        + "\u03b5\u03bd\u03bd\u03ad\u03b1;\n"
        + "10: \u03b4\u03ad\u03ba\u03b1; "
        + "\u03ad\u03bd\u03b4\u03b5\u03ba\u03b1; \u03b4\u03ce\u03b4\u03b5\u03ba\u03b1; "
        + "\u03b4\u03b5\u03ba\u03b1>>;\n"
        + "20: \u03b5\u03af\u03ba\u03bf\u03c3\u03b9; \u03b5\u03b9\u03ba\u03bf\u03c3\u03b9>>;\n"
        + "30: \u03c4\u03c1\u03b9\u03ac\u03bd\u03c4\u03b1; \u03c4\u03c1\u03b9\u03b1\u03bd\u03c4\u03b1>>;\n"
        + "40: \u03c3\u03b1\u03c1\u03ac\u03bd\u03c4\u03b1; \u03c3\u03b1\u03c1\u03b1\u03bd\u03c4\u03b1>>;\n"
        + "50: \u03c0\u03b5\u03bd\u03ae\u03bd\u03c4\u03b1; \u03c0\u03b5\u03bd\u03b7\u03bd\u03c4\u03b1>>;\n"
        + "60: \u03b5\u03be\u03ae\u03bd\u03c4\u03b1; \u03b5\u03be\u03b7\u03bd\u03c4\u03b1>>;\n"
        + "70: \u03b5\u03b2\u03b4\u03bf\u03bc\u03ae\u03bd\u03c4\u03b1; "
        + "\u03b5\u03b2\u03b4\u03bf\u03bc\u03b7\u03bd\u03c4\u03b1>>;\n"
        + "80: \u03bf\u03b3\u03b4\u03cc\u03bd\u03c4\u03b1; \u03bf\u03b3\u03b4\u03bf\u03bd\u03c4\u03b1>>;\n"
        + "90: \u03b5\u03bd\u03bd\u03b5\u03bd\u03ae\u03bd\u03c4\u03b1; "
        + "\u03b5\u03bd\u03bd\u03b5\u03bd\u03b7\u03bd\u03c4\u03b1>>;\n"
        + "100: \u03b5\u03ba\u03b1\u03c4\u03cc[\u03bd >>];\n"
        + "200: \u03b4\u03b9\u03b1\u03ba\u03cc\u03c3\u03b9\u03b1[ >>];\n"
        + "300: \u03c4\u03c1\u03b9\u03b1\u03ba\u03cc\u03c3\u03b9\u03b1[ >>];\n"
        + "400: \u03c4\u03b5\u03c4\u03c1\u03b1\u03ba\u03cc\u03c3\u03b9\u03b1[ >>];\n"
        + "500: \u03c0\u03b5\u03bd\u03c4\u03b1\u03ba\u03cc\u03c3\u03b9\u03b1[ >>];\n"
        + "600: \u03b5\u03be\u03b1\u03ba\u03cc\u03c3\u03b9\u03b1[ >>];\n"
        + "700: \u03b5\u03c0\u03c4\u03b1\u03ba\u03cc\u03c3\u03b9\u03b1[ >>];\n"
        + "800: \u03bf\u03ba\u03c4\u03b1\u03ba\u03cc\u03c3\u03b9\u03b1[ >>];\n"
        + "900: \u03b5\u03bd\u03bd\u03b9\u03b1\u03ba\u03cc\u03c3\u03b9\u03b1[ >>];\n"
        + "1000: \u03c7\u03af\u03bb\u03b9\u03b1[ >>];\n"
        + "2000: << \u03c7\u03af\u03bb\u03b9\u03b1[ >>];\n"
        + "1,000,000: << \u03b5\u03ba\u03b1\u03c4\u03bf\u03bc\u03bc\u03b9\u03cc\u03c1\u03b9\u03bf[ >>];\n"
        + "1,000,000,000: << \u03b4\u03b9\u03c3\u03b5\u03ba\u03b1\u03c4\u03bf\u03bc\u03bc\u03b9\u03cc\u03c1\u03b9\u03bf[ >>];\n"
        + "1,000,000,000,000: =#,##0=";
    // Can someone supply me with information on negatives and decimals?
    // I'm also missing the word for zero.  Can someone clue me in?

    /**
     * Spellout rules for Russian.
     */
    public static final String russian =
        "\u043d\u043e\u043b\u044c; \u043e\u0434\u0438\u043d; \u0434\u0432\u0430; \u0442\u0440\u0438; "
        + "\u0447\u0435\u0442\u044b\u0440\u0435; \u043f\u044f\u0442; \u0448\u0435\u0441\u0442; "
        + "\u0441\u0435\u043c\u044c; \u0432\u043e\u0441\u0435\u043c\u044c; \u0434\u0435\u0432\u044f\u0442;\n"
        + "10: \u0434\u0435\u0441\u044f\u0442; "
        + "\u043e\u0434\u0438\u043d\u043d\u0430\u0434\u0446\u0430\u0442\u044c;\n"
        + "\u0434\u0432\u0435\u043d\u043d\u0430\u0434\u0446\u0430\u0442\u044c; "
        + "\u0442\u0440\u0438\u043d\u0430\u0434\u0446\u0430\u0442\u044c; "
        + "\u0447\u0435\u0442\u044b\u0440\u043d\u0430\u0434\u0446\u0430\u0442\u044c;\n"
        + "15: \u043f\u044f\u0442\u043d\u0430\u0434\u0446\u0430\u0442\u044c; "
        + "\u0448\u0435\u0441\u0442\u043d\u0430\u0434\u0446\u0430\u0442\u044c; "
        + "\u0441\u0435\u043c\u043d\u0430\u0434\u0446\u0430\u0442\u044c; "
        + "\u0432\u043e\u0441\u0435\u043c\u043d\u0430\u0434\u0446\u0430\u0442\u044c; "
        + "\u0434\u0435\u0432\u044f\u0442\u043d\u0430\u0434\u0446\u0430\u0442\u044c;\n"
        + "20: \u0434\u0432\u0430\u0434\u0446\u0430\u0442\u044c[ >>];\n"
        + "30: \u0442\u0440\u043b\u0434\u0446\u0430\u0442\u044c[ >>];\n"
        + "40: \u0441\u043e\u0440\u043e\u043a[ >>];\n"
        + "50: \u043f\u044f\u0442\u044c\u0434\u0435\u0441\u044f\u0442[ >>];\n"
        + "60: \u0448\u0435\u0441\u0442\u044c\u0434\u0435\u0441\u044f\u0442[ >>];\n"
        + "70: \u0441\u0435\u043c\u044c\u0434\u0435\u0441\u044f\u0442[ >>];\n"
        + "80: \u0432\u043e\u0441\u0435\u043c\u044c\u0434\u0435\u0441\u044f\u0442[ >>];\n"
        + "90: \u0434\u0435\u0432\u044f\u043d\u043e\u0441\u0442\u043e[ >>];\n"
        + "100: \u0441\u0442\u043e[ >>];\n"
        + "200: << \u0441\u0442\u043e[ >>];\n"
        + "1000: \u0442\u044b\u0441\u044f\u0447\u0430[ >>];\n"
        + "2000: << \u0442\u044b\u0441\u044f\u0447\u0430[ >>];\n"
        + "1,000,000: \u043c\u0438\u043b\u043b\u0438\u043e\u043d[ >>];\n"
        + "2,000,000: << \u043c\u0438\u043b\u043b\u0438\u043e\u043d[ >>];\n"
        + "1,000,000,000: =#,##0=;";
    // Can someone supply me with information on negatives and decimals?
    // How about words for billions and trillions?

    /**
     * Spellout rules for Hebrew.  Hebrew actually has inflected forms for
     * most of the lower-order numbers.  The masculine forms are shown
     * here.
     */
    public static final String hebrew =
        "zero (incomplete data); \u05d0\u05d4\u05d3; \u05e9\u05d2\u05d9\u05d9\u05dd; \u05e9\u05dc\u05d5\u05e9\u05d4;\n"
        + "4: \u05d0\u05d3\u05d1\u05e6\u05d4; \u05d7\u05d2\u05d5\u05d9\u05e9\u05d4; \u05e9\u05e9\u05d4;\n"
        + "7: \u05e9\u05d1\u05e6\u05d4; \u05e9\u05de\u05d5\u05d2\u05d4; \u05ea\u05e9\u05e6\u05d4;\n"
        + "10: \u05e6\u05e9\u05d3\u05d4[ >>];\n"
        + "20: \u05e6\u05e9\u05d3\u05d9\u05dd[ >>];\n"
        + "30: \u05e9\u05dc\u05d5\u05e9\u05d9\u05dd[ >>];\n"
        + "40: \u05d0\u05d3\u05d1\u05e6\u05d9\u05dd[ >>];\n"
        + "50: \u05d7\u05de\u05d9\u05e9\u05d9\u05dd[ >>];\n"
        + "60: \u05e9\u05e9\u05d9\u05dd[ >>];\n"
        + "70: \u05e9\u05d1\u05e6\u05d9\u05dd[ >>];\n"
        + "80: \u05e9\u05de\u05d5\u05d2\u05d9\u05dd[ >>];\n"
        + "90: \u05ea\u05e9\u05e6\u05d9\u05dd[ >>];\n"
        + "100: \u05de\u05d0\u05d4[ >>];\n"
        + "200: << \u05de\u05d0\u05d4[ >>];\n"
        + "1000: \u05d0\u05dc\u05e3[ >>];\n"
        + "2000: << \u05d0\u05dc\u05e3[ >>];\n"
        + "1,000,000: =#,##0= (incomplete data);";
    // This data is woefully incomplete.  Can someone fill me in on the
    // various inflected forms of the numbers, which seem to be necessary
    // to do Hebrew correctly?  Can somone supply me with data for values
    // from 1,000,000 on up?  What about the word for zero?  What about
    // information on negatives and decimals?

    //========================================================================
    // Simple examples
    //========================================================================

    /**
     * This rule set adds an English ordinal abbreviation to the end of a
     * number.  For example, 2 is formatted as "2nd".  Parsing doesn't work with
     * this rule set.  To parse, use DecimalFormat on the numeral.
     */
    public static final String ordinal =
        // this rule set formats the numeral and calls %%abbrev to
        // supply the abbreviation
        "%main:\n"
        + "    =#,##0==%%abbrev=;\n"
        // this rule set supplies the abbreviation
        + "%%abbrev:\n"
               // the abbreviations.  Everything from 4 to 19 ends in "th"
        + "    th; st; nd; rd; th;\n"
               // at 20, we begin repeating the cycle every 10 (13 is "13th",
               // but 23 and 33 are "23rd" and "33rd")  We do this by
               // ignoring all bug the ones digit in selecting the abbreviation
        + "    20: >>;\n"
               // at 100, we repeat the whole cycle by considering only the
               // tens and ones digits in picking an abbreviation
        + "    100: >>;\n";

    /**
     * This is a simple message-formatting example.  Normally one would
     * use ChoiceFormat and MessageFormat to do something this simple,
     * but this shows it could be done with RuleBasedNumberFormat too.
     * A message-formatting example that might work better with
     * RuleBasedNumberFormat appears later.
     */
    public static final String message1 =
        // this rule surrounds whatever the other rules produce with the
        // rest of the sentence
        "x.0: The search found <<.;\n"
        // use words for values below 10 (and change to "file" for 1)
        + "no files; one file; two files; three files; four files; five files;\n"
        + "    six files; seven files; eight files; nine files;\n"
        // use numerals for values higher than 10
        + "=#,##0= files;";

    //========================================================================
    // Fraction handling
    //
    // The next few examples show how RuleBasedNumberFormat can be used for
    // more flexible handling of fractions
    //========================================================================

    /**
     * This example formats a number in one of the two styles often used
     * on checks.  %dollars-and-hundredths formats cents as hundredths of
     * a dollar (23.40 comes out as "twenty-three and 40/100 dollars").
     * %dollars-and-cents formats in dollars and cents (23.40 comes out as
     * "twenty-three dollars and forty cents")
     */
    public static final String dollarsAndCents =
        // this rule set formats numbers as dollars and cents
        "%dollars-and-cents:\n"
               // if the value is 1 or more, put "xx dollars and yy cents".
               // the "and y cents" part is suppressed if the value is an
               // even number of dollars
        + "    x.0: << [and >%%cents>];\n"
               // if the value is between 0 and 1, put "xx cents"
        + "    0.x: >%%cents>;\n"
               // these three rules take care of the singular and plural
               // forms of "dollar" and use %%main to format the number
        + "    0: zero dollars; one dollar; =%%main= dollars;\n"
        // these are the regular U.S. English number spellout rules
        + "%%main:\n"
        + "    zero; one; two; three; four; five; six; seven; eight; nine;\n"
        + "    ten; eleven; twelve; thirteen; fourteen; fifteen; sixteen;\n"
        + "        seventeen; eighteen; nineteen;\n"
        + "    20: twenty[->>];\n"
        + "    30: thirty[->>];\n"
        + "    40: forty[->>];\n"
        + "    50: fifty[->>];\n"
        + "    60: sixty[->>];\n"
        + "    70: seventy[->>];\n"
        + "    80: eighty[->>];\n"
        + "    90: ninety[->>];\n"
        + "    100: << hundred[ >>];\n"
        + "    1000: << thousand[ >>];\n"
        + "    1,000,000: << million[ >>];\n"
        + "    1,000,000,000: << billion[ >>];\n"
        + "    1,000,000,000,000: << trillion[ >>];\n"
        + "    1,000,000,000,000,000: =#,##0=;\n"
        // this rule takes care of the fractional part of the value.  It
        // multiplies the fractional part of the number being formatted by
        // 100, formats it with %%main, and then addes the word "cent" or
        // "cents" to the end.  (The text in brackets is omitted if the
        // numerator of the fraction is 1.)
        + "%%cents:\n"
        + "    100: <%%main< cent[s];\n"

        // this rule set formats numbers as dollars and hundredths of dollars
        + "%dollars-and-hundredths:\n"
               // this rule takes care of the general shell of the output
               // string.  We always show the cents, even when there aren't
               // any.  Because of this, the word is always "dollars"--
               // we don't have to worry about the singular form.  We use
               // %%main to format the number of dollars and %%hundredths to
               // format the number of cents
        + "    x.0: <%%main< and >%%hundredths>/100 dollars;\n"
        // this rule set formats the cents for %dollars-and-hundredths.
        // It multiplies the fractional part of the number by 100 and formats
        // the result using a DecimalFormat ("00" tells the DecimalFormat to
        // always use two digits, even for numbers under 10)
        + "%%hundredths:\n"
        + "    100: <00<;\n";

    /**
     * This rule set shows the fractional part of the number as a fraction
     * with a power of 10 as the denominator.  Some languages don't spell
     * out the fractional part of a number as "point one two three," but
     * always render it as a fraction.  If we still want to treat the fractional
     * part of the number as a decimal, then the fraction's denominator
     * is always a power of 10.  This example does that: 23.125 is formatted
     * as "twenty-three and one hundred twenty-five thousandths" (as opposed
     * to "twenty-three point one two five" or "twenty-three and one eighth").
     */
    public static final String decimalAsFraction =
        // the regular U.S. English spellout rules, with one difference
        "%main:\n"
        + "    -x: minus >>;\n"
               // the difference.  This rule uses %%frac to show the fractional
               // part of the number.  Text in brackets is omitted when the
               // value is between 0 and 1 (causing 0.3 to come out as "three
               // tenths" instead of "zero and three tenths").
        + "    x.x: [<< and ]>%%frac>;\n"
        + "    zero; one; two; three; four; five; six; seven; eight; nine;\n"
        + "    ten; eleven; twelve; thirteen; fourteen; fifteen; sixteen;\n"
        + "        seventeen; eighteen; nineteen;\n"
        + "    twenty[->>];\n"
        + "    30: thirty[->>];\n"
        + "    40: forty[->>];\n"
        + "    50: fifty[->>];\n"
        + "    60: sixty[->>];\n"
        + "    70: seventy[->>];\n"
        + "    80: eighty[->>];\n"
        + "    90: ninety[->>];\n"
        + "    100: << hundred[ >>];\n"
        + "    1000: << thousand[ >>];\n"
        + "    1,000,000: << million[ >>];\n"
        + "    1,000,000,000: << billion[ >>];\n"
        + "    1,000,000,000,000: << trillion[ >>];\n"
        + "    1,000,000,000,000,000: =#,##0=;\n"
        // the rule set that formats the fractional part of the number.
        // The rule that is used is the one that, when its baase value is
        // multiplied by the fractional part of the number being formatted,
        // produces the result closest to zero.  Thus, the base values are
        // prospective denominators of the fraction.  The << marks the place
        // where the numerator of the fraction (the result of multiplying the
        // fractional part of the number by the rule's base value) is
        // placed.  Text in brackets is omitted when the numerator is 1, giving
        // us the singular and plural forms of the words.
        // [In languages where the singular and plural are completely different
        // words, the rule can just be stated twice: the second time with
        // the plural form.]
        + "%%frac:\n"
        + "    10: << tenth[s];\n"
        + "    100: << hundredth[s];\n"
        + "    1000: << thousandth[s];\n"
        + "    10,000: << ten-thousandth[s];\n"
        + "    100,000: << hundred-thousandth[s];\n"
        + "    1,000,000: << millionth[s];";

    /**
     * Number with closest fraction.  This example formats a value using
     * numerals, but shows the fractional part as a ratio (fraction) rather
     * than a decimal.  The fraction always has a denominator between 2 and 10.
     */
    public static final String closestFraction =
        "%main:\n"
               // this rule formats the number if it's 1 or more.  It formats
               // the integral part using a DecimalFormat ("#,##0" puts
               // thousands separators in the right places) and the fractional
               // part using %%frac.  If there is no fractional part, it
               // just shows the integral part.
        + "    x.0: <#,##0<[ >%%frac>];\n"
               // this rule formats the number if it's between 0 and 1.  It
               // shows only the fractional part (0.5 shows up as "1/2," not
               // "0 1/2")
        + "    0.x: >%%frac>;\n"
        // the fraction rule set.  This works the same way as the one in the
        // preceding example: We multiply the fractional part of the number
        // being formatted by each rule's base value and use the rule that
        // produces the result closest to 0 (or the first rule that produces 0).
        // Since we only provide rules for the numbers from 2 to 10, we know
        // we'll get a fraction with a denominator between 2 and 10.
        // "<0<" causes the numerator of the fraction to be formatted
        // using numerals
        + "%%frac:\n"
        + "    2: 1/2;\n"
        + "    3: <0</3;\n"
        + "    4: <0</4;\n"
        + "    5: <0</5;\n"
        + "    6: <0</6;\n"
        + "    7: <0</7;\n"
        + "    8: <0</8;\n"
        + "    9: <0</9;\n"
        + "    10: <0</10;\n";

    /**
     * American stock-price formatting.  Non-integral stock prices are still
     * generally shown in eighths or sixteenths of dollars instead of dollars
     * and cents.  This example formats stock prices in this way if possible,
     * and in dollars and cents if not.
     */
    public static final String stock =
        "%main:\n"
               // this rule formats the integral part of the number in numerals
               // and (if necessary) the fractional part using %%frac1
        + "    x.0: <#,##0<[>%%frac1>];\n"
               // this rule is used for values between 0 and 1 and omits the
               // integral part
        + "    0.x: >%%frac2>;\n"
        // this rule set is used to format the fractional part of the number when
        // there's an integral part before it (again, we try all denominators
        // and use the "best" one)
        + "%%frac1:\n"
               // for even multiples of 1/4, format the fraction using the
               // typographer's fractions
        + "    4: <%%quarters<;\n"
               // format the value as a number of eighths, sixteenths, or
               // thirty-seconds, whichever produces the most accurate value.
               // The apostrophe at the front of these rules is ignored, but
               // it makes the space that follows it significant.  This puts a
               // space between the value's integral and fractional parts so
               // you can read it
        + "    8: ' <0</8;\n"
        + "    16: ' <0</16;\n"
        + "    32: ' <0</32;\n"
               // if we can't reasonably format the number in powers of 2,
               // then show it as dollars and cents
        + "    100: .<00<;\n"
        // this rule set is used when the fractional part of the value stands
        // alone
        + "%%frac2:\n"
        + "    4: <%%quarters<;\n"
               // for fractions that we can't show using typographer's fractions,
               // we don't have to put a space before the fraction
        + "    8: <0</8;\n"
        + "    16: <0</16;\n"
        + "    32: <0</32;\n"
               // but dollars and cents look better with a leading 0
        + "    100: 0.<00<;\n"
        // this rule set formats 1/4, 1/2, and 3/4 using typographer's fractions
        + "%%quarters:\n"
        + "    ; \u00bc; \u00bd; \u00be;\n"
        // there are the lenient-parse rules.  These allow the user to type
        // "1/4," "1/2," and "3/4" instead of their typographical counterparts
        // and still have them be understood by the formatter
        + "%%lenient-parse:\n"
        + "    & '1/4' , \u00bc\n"
        + "    & '1/2' , \u00bd\n"
        + "    & '3/4' , \u00be\n;";

    //========================================================================
    // Changing dimensions
    //
    // The next few examples demonstrate using a RuleBasedNumberFormat to
    // change the units a value is denominated in depending on its magnitude
    //========================================================================

    /**
     * The example shows large numbers the way they often appear is nwespapers:
     * 1,200,000 is formatted as "1.2 million".
     */
    public static final String abbEnglish =
        "=#,##0=;\n"
        // this is fairly self-explanatory, but note that the << substitution
        // can show the fractional part of the substitution value if the user
        // wants it
        + "1,000,000: <##0.###< million;\n"
        + "1,000,000,000: <##0.###< billion;\n"
        + "1,000,000,000,000: <##0.###< trillion;\n";

    /**
     * This example takes a number of meters and formats it in whatever unit
     * will produce a number with from one to three digits before the decimal
     * point.  For example, 230,000 is formatted as "230 km".
     */
    public static final String units =
        "%main:\n"
               // for values between 0 and 1, delegate to %%small
        + "    0.x: >%%small>;\n"
               // otherwise, show between 3 and 6 significant digits of the value
               // along with the most appropriate unit
        + "    0: =##0.###= m;\n"
        + "    1,000: <##0.###< km;\n"
        + "    1,000,000: <##0.###< Mm;\n"
        + "    1,000,000,000: <##0.###< Gm;\n"
        + "    1,000,000,000,000: <#,##0.###< Tm;\n"
        // %%small formats the number when it's less then 1.  It multiplies the
        // value by one billion, and then uses %%small2 to actually do the
        // formatting.
        + "%%small:\n"
        + "    1,000,000,000,000: <%%small2<;\n"
        // this rule set actually formats small values.  %%small passes this
        // rule set a number of picometers, and it takes care of scaling up as
        // appropriate in exactly the same way %main does (we can't normally
        // handle fractional values this way: here, we're concerned about
        // magnitude; most of the time, we're concerned about precsion)
        + "%%small2:\n"
        + "    0: =##0= pm;\n"
        + "    1,000: <##0.###< nm;\n"
        + "    1,000,000: <##0.###< \u00b5m;\n"
        + "    1,000,000,000: <##0.###< mm;\n";

    /**
     * A more complicated message-formatting example.  Here, in addition to
     * handling the singular and plural versions of the word, the value is
     * denominated in bytes, kilobytes, or megabytes depending on its magnitude.
     * Also notice that it correctly treats a kilobyte as 1,024 bytes (not 1,000),
     * and a megabyte as 1,024 kilobytes (not 1,000).
     */
    public static final String message2 =
        // this rule supplies the shell of the sentence
        "x.0: There << free space on the disk.;\n"
        // handle singular and plural forms of "byte" (and format 0 as
        // "There is no free space...")
        + "0: is no;\n"
        + "is one byte of;\n"
        + "are =0= bytes of;\n"
        // for values above 1,024, format the number in K (since "K" is usually
        // promounced "K" regardless of whether it's singular or plural, we
        // don't worry about the plural form).  The "/1024" here causes us to
        // treat a K as 1,024 bytes rather than 1,000 bytes.
        + "1024/1024: is <0<K of;\n"
        // for values about 1,048,576, format the number in Mb.  Since "Mb" is
        // usually promounced "meg" in singular and "megs" in plural, we do have
        // both singular and plural forms.  Again, notice we treat a megabyte
        // as 1,024 kilobytes.
        + "1,048,576/1024: is 1 Mb of;\n"
        + "2,097,152/1024: are <0< Mb of;";

    //========================================================================
    // Alternate radices
    //========================================================================

    /**
     * This example formats a number in dozens and gross.  This is intended to
     * demonstrate how this rule set can be used to format numbers in systems
     * other than base 10.  The "/12" after the rules' base values controls this.
     * Also notice that the base doesn't have to be consistent throughout the
     * whole rule set: we go back to base 10 for values over 1,000.
     */
    public static final String dozens =
        // words for numbers...
        "zero; one; two; three; four; five; six;\n"
        + "seven; eight; nine; ten; eleven;\n"
        // format values over 12 in dozens
        + "12/12: << dozen[ and >>];\n"
        // format values over 144 in gross
        + "144/12: << gross[, >>];\n"
        // format values over 1,000 in thousands
        + "1000: << thousand[, >>];\n"
        // overflow rule.  Format values over 10,000 in numerals
        + "10,000: =#,##0=;\n";

    //========================================================================
    // Major and minor units
    //
    // These examples show how a single value can be divided up into major
    // and minor units that don't relate to each other by a factor of 10.
    //========================================================================

    /**
     * This example formats a number of seconds in sexagesimal notation
     * (i.e., hours, minutes, and seconds).  %with-words formats it with
     * words (3740 is "1 hour, 2 minutes, 20 seconds") and %in-numerals
     * formats it entirely in numerals (3740 is "1:02:20").
     */
    public static final String durationInSeconds =
        // main rule set for formatting with words
        "%with-words:\n"
               // take care of singular and plural forms of "second"
        + "    0 seconds; 1 second; =0= seconds;\n"
               // use %%min to format values greater than 60 seconds
        + "    60/60: <%%min<[, >>];\n"
               // use %%hr to format values greater than 3,600 seconds
               // (the ">>>" below causes us to see the number of minutes
               // when when there are zero minutes)
        + "    3600/60: <%%hr<[, >>>];\n"
        // this rule set takes care of the singular and plural forms
        // of "minute"
        + "%%min:\n"
        + "    0 minutes; 1 minute; =0= minutes;\n"
        // this rule set takes care of the singular and plural forms
        // of "hour"
        + "%%hr:\n"
        + "    0 hours; 1 hour; =0= hours;\n"

        // main rule set for formatting in numerals
        + "%in-numerals:\n"
               // values below 60 seconds are shown with "sec."
        + "    =0= sec.;\n"
               // higher values are shown with colons: %%min-sec is used for
               // values below 3,600 seconds...
        + "    60: =%%min-sec=;\n"
               // ...and %%hr-min-sec is used for values of 3,600 seconds
               // and above
        + "    3600: =%%hr-min-sec=;\n"
        // this rule causes values of less than 10 minutes to show without
        // a leading zero
        + "%%min-sec:\n"
        + "    0: :=00=;\n"
        + "    60/60: <0<>>;\n"
        // this rule set is used for values of 3,600 or more.  Minutes are always
        // shown, and always shown with two digits
        + "%%hr-min-sec:\n"
        + "    0: :=00=;\n"
        + "    60/60: <00<>>;\n"
        + "    3600/60: <#,##0<:>>>;\n"
        // the lenient-parse rules allow several different characters to be used
        // as delimiters between hours, minutes, and seconds
        + "%%lenient-parse:\n"
        + "    & : = . = ' ' = -;\n";

    /**
     * This example formats a number of hours in sexagesimal notation (i.e.,
     * hours, minutes, and seconds).  %with-words formats the value using
     * words for the units, and %in-numerals formats the value using only
     * numerals.
     */
    public static final String durationInHours =
        // main entry point for formatting with words
        "%with-words:\n"
               // this rule omits minutes and seconds when the value is
               // an even number of hours
        + "    x.0: <<[, >%%min-sec>];\n"
               // these rules take care of the singular and plural forms
               // of hours
        + "    0 hours; 1 hour; =#,##0= hours;\n"
        // this rule set takes the fractional part of the number and multiplies
        // it by 3,600 (turning it into a number of seconds).  Then it delegates
        // to %%min-sec-implementation to format the resulting value
        + "%%min-sec:\n"
        + "    3600: =%%min-sec-implementation=;\n"
        // this rule set formats the seconds as either seconds or minutes and
        // seconds, and takes care of the singular and plural forms of
        // "minute" and "second"
        + "%%min-sec-implementation:\n"
        + "    0 seconds; 1 second; =0= seconds;\n"
        + "    60/60: 1 minute[, >>];\n"
        + "    120/60: <0< minutes[, >>];\n"

        // main entry point for formatting in numerals
        + "%in-numerals:\n"
               // show minutes even for even numbers of hours
        + "    x.0: <#,##0<:00;\n"
               // delegate to %%min-sec2 to format minutes and seconds
        + "    x.x: <#,##0<:>%%min-sec2>;\n"
        // this rule set formats minutes when there is an even number of
        // minutes, and delegates to %%min-sec2-implementation when there
        // are seconds
        + "%%min-sec2:\n"
        + "    60: <00<;\n"
        + "    3600: <%%min-sec2-implementation<;\n"
        // these two rule sets are used to format the minutes and seconds
        + "%%min-sec2-implementation:\n"
               // if there are fewer than 60 seconds, show the minutes anyway
        + "    0: 00:=00=;\n"
               // if there are minutes, format them too, and always use 2 digits
               // for both minutes and seconds
        + "    60: =%%min-sec3=;\n"
        + "%%min-sec3:\n"
        + "    0: :=00=;\n"
        + "    60/60: <00<>>;\n"
        // the lenient-parse rules allow the user to use any of several
        // characters as delimiters between hours, minutes, and seconds
        + "%%lenient-parse:\n"
        + "    & : = . = ' ' = -;\n";

    /**
     * This rule set formats a number of pounds as pounds, shillings, and
     * pence in the old English system of currency.
     */
    public static final String poundsShillingsAndPence =
        // for values of 1 or more, format the integral part with a pound
        // sign in front, and show shillings and pence if necessary
        "%main:\n"
        + "    x.0: \u00a3<#,##0<[ >%%shillings-and-pence>];\n"
        // for values between 0 and 1, omit the number of pounds
        + "    0.x: >%%pence-alone>;\n"
        // this rule set is used to show shillings and pence.  It multiplies
        // the fractional part of the number by 240 (the number of pence in a
        // pound) and uses %%shillings-and-pence-implementation to format
        // the result
        + "%%shillings-and-pence:\n"
        + "    240: <%%shillings-and-pence-implementation<;\n"
        // this rule set is used to show shillings and pence when there are
        // no pounds.  It also multiplies the value by 240, and then it uses
        // %%pence-alone-implementation to format the result.
        + "%%pence-alone:\n"
        + "    240: <%%pence-alone-implementation<;\n"
        // this rule set formats a number of pence when we know we also
        // have pounds.  We always show shillings (with a 0 if necessary),
        // but only show pence if the value isn't an even number of shillings
        + "%%shillings-and-pence-implementation:\n"
        + "    0/; 0/=0=;\n"
        + "    12/12: <0</[>0>];\n"
        // this rule set formats a number of pence when we know there are
        // no pounds.  Values less than a shilling are shown with "d." (the
        // abbreviation for pence), and values greater than a shilling are
        // shown with a shilling bar (and without pence when the value is
        // an even number of shillings)
        + "%%pence-alone-implementation:\n"
        + "    =0= d.;\n"
        + "    12/12: <0</[>0>];\n";

    //========================================================================
    // Alternate numeration systems
    //
    // These examples show how RuleBasedNumberFormat can be used to format
    // numbers using non-positional numeration systems.
    //========================================================================

    /**
     * Arabic digits.  This example formats numbers in Arabic numerals.
     * Normally, you'd do this with DecimalFormat, but this shows that
     * RuleBasedNumberFormat can handle it too.
     */
    public static final String arabicNumerals =
        "0; 1; 2; 3; 4; 5; 6; 7; 8; 9;\n"
        + "10: <<>>;\n"
        + "100: <<>>>;\n"
        + "1000: <<,>>>;\n"
        + "1,000,000: <<,>>>;\n"
        + "1,000,000,000: <<,>>>;\n"
        + "1,000,000,000,000: <<,>>>;\n"
        + "1,000,000,000,000,000: =#,##0=;\n"
        + "-x: ->>;\n"
        + "x.x: <<.>>;";

    /**
     * Words for digits.  Follows the same pattern as the Arabic-numerals
     * example above, but uses words for the various digits (e.g., 123 comes
     * out as "one two three").
     */
    public static final String wordsForDigits =
        "-x: minus >>;\n"
        + "x.x: << point >>;\n"
        + "zero; one; two; three; four; five; six;\n"
        + "    seven; eight; nine;\n"
        + "10: << >>;\n"
        + "100: << >>>;\n"
        + "1000: <<, >>>;\n"
        + "1,000,000: <<, >>>;\n"
        + "1,000,000,000: <<, >>>;\n"
        + "1,000,000,000,000: <<, >>>;\n"
        + "1,000,000,000,000,000: =#,##0=;\n";

    /**
     * This example formats numbers using Chinese characters in the Arabic
     * place-value method.  This was used historically in China for a while.
     */
    public static final String chinesePlaceValue =
        "\u3007; \u4e00; \u4e8c; \u4e09; \u56db; \u4e94; \u516d; \u4e03; \u516b; \u4e5d;\n"
        + "10: <<>>;\n"
        + "100: <<>>>;\n"
        + "1000: <<>>>;\n"
        + "1,000,000: <<>>>;\n"
        + "1,000,000,000: <<>>>;\n"
        + "1,000,000,000,000: <<>>>;\n"
        + "1,000,000,000,000,000: =#,##0=;\n";

    /**
     * Roman numerals.  This example has two variants: %modern shows how large
     * numbers are usually handled today; %historical ses the older symbols for
     * thousands.
     */
    public static final String romanNumerals =
        "%historical:\n"
        + "    =%modern=;\n"
               // in early Roman numerals, 1,000 was shown with a circle
               // bisected by a vertical line.  Additional thousands were
               // shown by adding more concentric circles, and fives were
               // shown by cutting the symbol for next-higher power of 10
               // in half (the letter D for 500 evolved from this).
               // We could go beyond 40,000, but Unicode doesn't encode
               // the symbols for higher numbers/
        + "    1000: \u2180[>>]; 2000: \u2180\u2180[>>]; 3000: \u2180\u2180\u2180[>>]; 4000: \u2180\u2181[>>];\n"
        + "    5000: \u2181[>>]; 6000: \u2181\u2180[>>]; 7000: \u2181\u2180\u2180[>>];\n"
        + "    8000: \u2181\u2180\u2180\u2180[>>]; 9000: \u2180\u2182[>>];\n"
        + "    10,000: \u2182[>>]; 20,000: \u2182\u2182[>>]; 30,000: \u2182\u2182\u2182[>>];\n"
        + "    40,000: =#,##0=;\n"
        + "%modern:\n"
        + "    ; I; II; III; IV; V; VI; VII; VIII; IX;\n"
        + "    10: X[>>]; 20: XX[>>]; 30: XXX[>>]; 40: XL[>>]; 50: L[>>];\n"
        + "    60: LX[>>]; 70: LXX[>>]; 80: LXXX[>>]; 90: XC[>>];\n"
        + "    100: C[>>]; 200: CC[>>]; 300: CCC[>>]; 400: CD[>>]; 500: D[>>];\n"
        + "    600: DC[>>]; 700: DCC[>>]; 800: DCCC[>>]; 900: CM[>>];\n"
               // in modern Roman numerals, high numbers are generally shown
               // by placing a bar over the letters for the lower numbers:
               // the bar multiplied a letter's value by 1,000
        + "    1000: M[>>]; 2000: MM[>>]; 3000: MMM[>>]; 4000: MV\u0306[>>];\n"
        + "    5000: V\u0306[>>]; 6000: V\u0306M[>>]; 7000: V\u0306MM[>>];\n"
        + "    8000: V\u0306MMM[>>]; 9000: MX\u0306[>>];\n"
        + "    10,000: X\u0306[>>]; 20,000: X\u0306X\u0306[>>]; 30,000: X\u0306X\u0306X\u0306[>>];\n"
        + "    40,000: X\u0306L\u0306[>>]; 50,000: L\u0306[>>]; 60,000: L\u0306X\u0306[>>];\n"
        + "    70,000: L\u0306X\u0306X\u0306[>>]; 80,000: L\u0306X\u0306X\u0306X\u0306[>>];\n"
        + "    90,000: X\u0306C\u0306[>>];\n"
        + "    100,000: C\u0306[>>]; 200,000: C\u0306C\u0306[>>]; 300,000: C\u0306C\u0306[>>];\n"
        + "    400,000: C\u0306D\u0306[>>]; 500,000: D\u0306[>>]; 600,000: D\u0306C\u0306[>>];\n"
        + "    700,000: D\u0306C\u0306C\u0306[>>]; 800,000: D\u0306C\u0306C\u0306C\u0306[>>];\n"
        + "    900,000: =#,##0=;\n";

    /**
     * Hebrew alphabetic numerals.  Before adoption of Arabic numerals, Hebrew speakers
     * used the letter of their alphabet as numerals.  The first nine letters of
     * the alphabet repesented the values from 1 to 9, the second nine letters the
     * multiples of 10, and the remaining letters the multiples of 100.  Since they
     * ran out of letters at 400, the remaining multiples of 100 were represented
     * using combinations of the existing letters for the hundreds.  Numbers were
     * distinguished from words in a number of different ways: the way shown here
     * uses a single mark after a number consisting of one letter, and a double
     * mark between the last two letters of a number consisting of two or more
     * letters.  Two dots over a letter multiplied its value by 1,000.  Also, since
     * the letter for 10 is the first letter of God's name and the letters for 5 and 6
     * are letters in God's name, which wasn't supposed to be written or spoken, 15 and
     * 16 were usually written as 9 + 6 and 9 + 7 instead of 10 + 5 and 10 + 6.
     */
    public static final String hebrewAlphabetic =
        // letters for the ones
        "%%ones:\n"
        + "    (no zero); \u05d0; \u05d1; \u05d2; \u05d3; \u05d4; \u05d5; \u05d6; \u05d7; \u05d8;\n"
        // letters for the tens
        + "%%tens:\n"
        + "    ; \u05d9; \u05db; \u05dc; \u05de; \u05e0; \u05e1; \u05e2; \u05e4; \u05e6;\n"
        // letters for the first four hundreds
        + "%%hundreds:\n"
        + "    ; \u05e7; \u05e8; \u05e9; \u05ea;\n"
        // this rule set is used to write the combination of the tens and ones digits
        // when we know that no other digits precede them: they put the numeral marks
        // in the right place and properly handle 15 and 16 (I'm using the mathematical
        // prime characters for the numeral marks because my Unicode font doesn't
        // include the real Hebrew characters, which look just like the prime marks)
        + "%%tens-and-ones:\n"
               // for values less than 10, just use %%ones and put the numeral mark
               // afterward
        + "    =%%ones=\u2032;\n"
               // put the numeral mark at the end for 10, but in the middle for
               // 11 through 14
        + "    10: <%%tens<\u2032; <%%tens<\u2033>%%ones>;\n"
               // special-case 15 and 16
        + "    15: \u05d8\u2033\u05d5; 16: \u05d8\u2033\u05d6;\n"
               // go back to the normal method at 17
        + "    17: <%%tens<\u2033>%%ones>;\n"
               // repeat the rules for 10 and 11 to cover the values from 20 to 99
        + "    20: <%%tens<\u2032; <%%tens<\u2033>%%ones>;\n"
        // this rule set is used to format numbers below 1,000.  It relies on
        // %%tens-and-ones to format the tens and ones places, and adds logic
        // to handle the high hundreds and the numeral marks when there is no
        // tens digit.  Notice how the rules are paired: all of these pairs of
        // rules take advantage of the rollback rule: if the value (between 100
        // and 499) is an even multiple of 100, the rule for 100 is used; otherwise,
        // the rule for 101 (the following rule) is used.  The first rule in each
        // pair (the one for the even multiple) places the numeral mark in a different
        // spot than the second rule in each pair (which knows there are more digits
        // and relies on the rule supplying them to also supply the numeral mark).
        // The call to %%null in line 10 is there simply to invoke the rollback
        // rule.
        + "%%low-order:\n"
               // this rule is only called when there are other characters before.
               // It places the numeral mark before the last digit
        + "    \u2033=%%ones=;\n"
               // the rule for 10 places the numeral mark before the 10 character
               // (because we know it's the last character); the rule for 11 relies
               // on %%tens-and-ones to place the numeral mark
        + "    10: \u2033<%%tens<; =%%tens-and-ones=>%%null>;\n"
               // the rule for 100 places the numeral mark before the 100 character
               // (we know it's the last character); the rule for 101 recurses to
               // fill in the remaining digits and the numeral mark
        + "    100: <%%hundreds<\u2032; <%%hundreds<>>;\n"
               // special-case the hundreds from 500 to 900 because they consist of
               // more than one character
        + "    500: \u05ea\u2033\u05e7; \u05ea\u05e7>>;\n"
        + "    600: \u05ea\u2033\u05e8; \u05ea\u05e8>>;\n"
        + "    700: \u05ea\u2033\u05e9; \u05ea\u05e9>>;\n"
        + "    800: \u05ea\u2033\u05ea; \u05ea\u05ea>>;\n"
        + "    900: \u05ea\u05ea\u2033\u05e7; \u05ea\u05ea\u05e7>>;\n"
        // this rule set is used to format values of 1,000 or more.  Here, we don't
        // worry about the numeral mark, and we add two dots (the Unicode combining
        // diaeresis character) to ever letter
        + "%%high-order:\n"
               // put the ones digit, followed by the diaeresis
        + "    =%%ones=\u0308;\n"
               // the tens can be handled with recursion
        + "    10: <%%tens<\u0308[>>];\n"
               // still have to special-case 15 and 16
        + "    15: \u05d8\u0308\u05d5\u0308; 16: \u05d8\u003078\u05d6\u0308;\n"
               // back to the regular rules at 17
        + "    17: <%%tens<\u0308[>>];\n"
               // the hundreds with the dots added (and without worrying about
               // placing the numeral mark)
        + "    100: <%%hundreds<\u0308[>>];\n"
        + "    500: \u05ea\u0308\u05e7\u0308[>>];\n"
        + "    600: \u05ea\u0308\u05e8\u0308[>>];\n"
        + "    700: \u05ea\u0308\u05e9\u0308[>>];\n"
        + "    800: \u05ea\u0308\u05ea\u0308[>>];\n"
        + "    900: \u05ea\u0308\u05ea\u0308\u05e7\u0308[>>];\n"
        // this rule set doesn't do anything; it's used by some other rules to
        // invoke the rollback rule
        + " %%null:\n"
        + "    ;\n"
        // the main rule set.
        + "%main:\n"
               // for values below 10, just output the letter and the numeral mark
        + "    =%%ones=\u2032;\n"
               // for values from 10 to 99, use %%tens-and-ones to do the formatting
        + "    10: =%%tens-and-ones=;\n"
               // for values from 100 to 999, use %%low-order to do the formatting
        + "    100: =%%low-order=;\n"
               // for values of 1,000 and over, use %%high-order to do the formatting
        + "    1000: <%%high-order<[>%%low-order>];\n";

    /**
     * Greek alphabetic numerals.  The Greeks, before adopting the Arabic numerals,
     * also used the letters of their alphabet as numerals.  There are three now-
     * obsolete Greek letters that are used as numerals; many fonts don't have them.
     * Large numbers were handled many different ways; the way shown here divides
     * large numbers into groups of four letters (factors of 10,000), and separates
     * the groups with the capital letter mu (for myriad).  Capital letters are used
     * for values below 10,000; small letters for higher numbers (to make the capital
     * mu stand out).
     */
    public static final String greekAlphabetic =
        // this rule set is used for formatting numbers below 10,000.  It uses
        // capital letters.
        "%%low-order:\n"
        + "    (no zero); \u0391; \u0392; \u0393; \u0394; \u0395; \u03dc; \u0396; \u0397; \u0398;\n"
        + "    10: \u0399[>>]; 20: \u039a[>>]; 30: \u039b[>>]; 40: \u039c[>>]; 50: \u039d[>>];\n"
        + "    60: \u039e[>>]; 70: \u039f[>>]; 80: \u03a0[>>]; 90: \u03de[>>];\n"
        + "    100: \u03a1[>>]; 200: \u03a3[>>]; 300: \u03a4[>>]; 400: \u03a5[>>];\n"
        + "    500: \u03a6[>>]; 600: \u03a7[>>]; 700: \u03a8[>>]; 800: \u03a9[>>];\n"
        + "    900: \u03e0[>>];\n"
               // the thousands are represented by the same numbers as the ones, but
               // with a comma-like mark added to their left shoulder
        + "    1000: \u0391\u0313[>>]; 2000: \u0392\u0313[>>]; 3000: \u0393\u0313[>>];\n"
        + "    4000: \u0394\u0313[>>]; 5000: \u0395\u0313[>>]; 6000: \u03dc\u0313[>>];\n"
        + "    7000: \u0396\u0313[>>]; 8000: \u0397\u0313[>>]; 9000: \u0398\u0313[>>];\n"
        // this rule set is the same as above, but uses lowercase letters.  It is used
        // for formatting the groups in numbers above 10,000.
        + "%%high-order:\n"
        + "    (no zero); \u03b1; \u03b2; \u03b3; \u03b4; \u03b5; \u03dc; \u03b6; \u03b7; \u03b8;\n"
        + "    10: \u03b9[>>]; 20: \u03ba[>>]; 30: \u03bb[>>]; 40: \u03bc[>>]; 50: \u03bd[>>];\n"
        + "    60: \u03be[>>]; 70: \u03bf[>>]; 80: \u03c0[>>]; 90: \u03de[>>];\n"
        + "    100: \u03c1[>>]; 200: \u03c3[>>]; 300: \u03c4[>>]; 400: \u03c5[>>];\n"
        + "    500: \u03c6[>>]; 600: \u03c7[>>]; 700: \u03c8[>>]; 800: \u03c9[>>];\n"
        + "    900: \u03c0[>>];\n"
        + "    1000: \u03b1\u0313[>>]; 2000: \u03b2\u0313[>>]; 3000: \u03b3\u0313[>>];\n"
        + "    4000: \u03b4\u0313[>>]; 5000: \u03b5\u0313[>>]; 6000: \u03dc\u0313[>>];\n"
        + "    7000: \u03b6\u0313[>>]; 8000: \u03b7\u0313[>>]; 9000: \u03b8\u0313[>>];\n"
        // the main rule set
        + "%main:\n"
               // for values below 10,000, just use %%low-order
        + "    =%%low-order=;\n"
               // for values above 10,000, split into two groups of four digits
               // and format each with %%high-order (putting an M in betwen)
        + "    10,000: <%%high-order<\u039c>%%high-order>;\n"
               // for values above 100,000,000, add another group onto the front
               // and another M
        + "    100,000,000: <%%high-order<\u039c>>\n";

    /**
     * A list of all the sample rule sets, used by the demo program.
     */
    public static final String[] sampleRuleSets =
        { usEnglish,
          ukEnglish,
          spanish,
          french,
          swissFrench,
          german,
          italian,
          swedish,
          dutch,
          japanese,
          greek,
          russian,
          hebrew,
          ordinal,
          message1,
          dollarsAndCents,
          decimalAsFraction,
          closestFraction,
          stock,
          abbEnglish,
          units,
          message2,
          dozens,
          durationInSeconds,
          durationInHours,
          poundsShillingsAndPence,
          arabicNumerals,
          wordsForDigits,
          chinesePlaceValue,
          romanNumerals,
          hebrewAlphabetic,
          greekAlphabetic };

    /**
     * The displayable names for all the sample rule sets, in the same order as
     * the preceding array.
     */
    public static final String[] sampleRuleSetNames =
        { "English (US)",
          "English (UK)",
          "Spanish",
          "French (France)",
          "French (Switzerland)",
          "German",
          "Italian",
          "Swedish",
          "Dutch",
          "Japanese",
          "Greek",
          "Russian",
          "Hebrew",
          "English ordinal abbreviations",
          "Simple message formatting",
          "Dollars and cents",
          "Decimals as fractions",
          "Closest fraction",
          "Stock prices",
          "Abbreviated US English",
          "Changing dimensions",
          "Complex message formatting",
          "Dozens",
          "Duration (value in seconds)",
          "Duration (value in hours)",
          "Pounds, shillings, and pence",
          "Arabic numerals",
          "Words for digits",
          "Chinese place-value notation",
          "Roman numerals",
          "Hebrew ahlphabetic numerals",
          "Greek alphabetic numerals" };

    /**
     * The base locale for each of the sample rule sets.  The locale is used to
     * determine DecimalFormat behavior, lenient-parse behavior, and text-display
     * selection (we have a hack in here to allow display of non-Latin scripts).
     * Null means the locale setting is irrelevant and the default can be used.
     */
    public static final Locale[] sampleRuleSetLocales =
        { Locale.US,
          Locale.UK,
          new Locale("es", "", ""),
          Locale.FRANCE,
          new Locale("fr", "CH", ""),
          Locale.GERMAN,
          Locale.ITALIAN,
          new Locale("sv", "", ""),
          new Locale("nl", "", ""),
          Locale.JAPANESE,
          new Locale("el", "", ""),
          new Locale("ru", "", ""),
          new Locale("iw", "", ""),
          Locale.ENGLISH,
          Locale.ENGLISH,
          Locale.US,
          Locale.ENGLISH,
          null,
          null,
          Locale.ENGLISH,
          null,
          Locale.ENGLISH,
          Locale.ENGLISH,
          null,
          null,
          Locale.UK,
          null,
          Locale.ENGLISH,
          new Locale("zh", "", ""),
          null,
          new Locale("iw", "", ""),
          new Locale("el", "", ""),
          null };

        public static final String[] sampleRuleSetCommentary = {
            "This demonstration version of the "
            + "U.S. English spellout rules has four variants: 1) %simplified is a "
            + "set of rules showing the simple method of spelling out numbers in "
            + "English: 289 is formatted as \"two hundred eighty-nine\".  2) %alt-teens "
            + "is the same as %simplified, except that values between 1,000 and 9,999 "
            + "whose hundreds place isn't zero are formatted in hundreds.  For example, "
            + "1,983 is formatted as \"nineteen hundred eighty-three,\" and 2,183 is "
            + "formatted as \"twenty-one hundred eighty-three,\" but 2,083 is still "
            + "formatted as \"two thousand eighty-three.\"  3) %ordinal formats the "
            + "values as ordinal numbers in English (e.g., 289 is \"two hundred eighty-"
            + "ninth\").  4) %default uses a more complicated algorithm to format "
            + "numbers in a more natural way: 289 is formatted as \"two hundred AND "
            + "eighty-nine\" and commas are inserted between the thousands groups for "
            + "values above 100,000.",

            "U.K. English has one significant "
            + "difference from U.S. English: the names for values of 1,000,000,000 "
            + "and higher.  In American English, each successive \"-illion\" is 1,000 "
            + "times greater than the preceding one: 1,000,000,000 is \"one billion\" "
            + "and 1,000,000,000,000 is \"one trillion.\"  In British English, each "
            + "successive \"-illion\" is one million times greater than the one before: "
            + "\"one billion\" is 1,000,000,000,000 (or what Americans would call a "
            + "\"trillion\"), and \"one trillion\" is 1,000,000,000,000,000,000.  "
            + "1,000,000,000 in British English is \"one thousand million.\"  (This "
            + "value is sometimes called a \"milliard,\" but this word seems to have "
            + "fallen into disuse.)",

            "The Spanish rules are quite similar to "
            + "the English rules, but there are some important differences: "
            + "First, we have to provide separate rules for most of the twenties "
            + "because the ones digit frequently picks up an accent mark that it "
            + "doesn't have when standing alone.  Second, each multiple of 100 has "
            + "to be specified separately because the multiplier on 100 very often "
            + "changes form in the contraction: 500 is \"quinientos,\" not "
            + "\"cincocientos.\"  In addition, the word for 100 is \"cien\" when "
            + "standing alone, but changes to \"ciento\" when followed by more digits.  "
            + "There also some other differences.",

            "French adds some interesting quirks of its "
            + "own: 1) The word \"et\" is interposed between the tens and ones digits, "
            + "but only if the ones digit if 1: 20 is \"vingt,\" and 2 is \"vingt-deux,\" "
            + "but 21 is \"vingt-et-un.\"  2)  There are no words for 70, 80, or 90.  "
            + "\"quatre-vingts\" (\"four twenties\") is used for 80, and values proceed "
            + "by score from 60 to 99 (e.g., 73 is \"soixante-treize\" [\"sixty-thirteen\"]).  "
            + "Numbers from 1,100 to 1,199 are rendered as hundreds rather than "
            + "thousands: 1,100 is \"onze cents\" (\"eleven hundred\"), rather than "
            + "\"mille cent\" (\"one thousand one hundred\")",

            "Swiss French differs from French French "
            + "in that it does have words for 70, 80, and 90.  This rule set shows them, "
            + "and is simpler as a result.",

            "German also adds some interesting "
            + "characteristics.  For values below 1,000,000, numbers are customarily "
            + "written out as a single word.  And the ones digit PRECEDES the tens "
            + "digit (e.g., 23 is \"dreiundzwanzig,\" not \"zwanzigunddrei\").",

            "Like German, most Italian numbers are "
            + "written as single words.  What makes these rules complicated is the rule "
            + "that says that when a word ending in a vowel and a word beginning with "
            + "a vowel are combined into a compound, the vowel is dropped from the "
            + "end of the first word: 180 is \"centottanta,\" not \"centoottanta.\"  "
            + "The complexity of this rule set is to produce this behavior.",

            "Spellout rules for Swedish.",

            "Spellout rules for Dutch.  Notice that in Dutch, as in German,"
            + "the ones digit precedes the tens digit.",

            "In Japanese, there really isn't any "
            + "distinction between a number written out in digits and a number "
            + "written out in words: the ideographic characters are both digits "
            + "and words.  This rule set provides two variants:  %traditional "
            + "uses the traditional CJK numerals (which are also used in China "
            + "and Korea).  %financial uses alternate ideographs for many numbers "
            + "that are harder to alter than the traditional numerals (one could "
            + "fairly easily change a one to "
            + "a three just by adding two strokes, for example).  This is also done in "
            + "the other countries using Chinese idographs, but different ideographs "
            + "are used in those places.",

            "Again in Greek we have to supply the words "
            + "for the multiples of 100 because they can't be derived algorithmically.  "
            + "Also, the tens dgit changes form when followed by a ones digit: an "
            + "accent mark disappears from the tens digit and moves to the ones digit.  "
            + "Therefore, instead of using the [] notation, we actually have to use "
            + "two separate rules for each multiple of 10 to show the two forms of "
            + "the word.",

            "Spellout rules for Russian.",

            "Spellout rules for Hebrew.  Hebrew actually has inflected forms for "
            + "most of the lower-order numbers.  The masculine forms are shown "
            + "here.",

            "This rule set adds an English ordinal abbreviation to the end of a "
            + "number.  For example, 2 is formatted as \"2nd\".  Parsing doesn't work with "
            + "this rule set.  To parse, use DecimalFormat on the numeral.",

            "This is a simple message-formatting example.  Normally one would "
            + "use ChoiceFormat and MessageFormat to do something this simple, "
            + "but this shows it could be done with RuleBasedNumberFormat too.  "
            + "A message-formatting example that might work better with "
            + "RuleBasedNumberFormat appears later.",

            "The next few examples demonstrate fraction handling.  "
            + "This example formats a number in one of the two styles often used "
            + "on checks.  %dollars-and-hundredths formats cents as hundredths of "
            + "a dollar (23.40 comes out as \"twenty-three and 40/100 dollars\").  "
            + "%dollars-and-cents formats in dollars and cents (23.40 comes out as "
            + "\"twenty-three dollars and forty cents\")",

            "This rule set shows the fractional part of the number as a fraction "
            + "with a power of 10 as the denominator.  Some languages don't spell "
            + "out the fractional part of a number as \"point one two three,\" but "
            + "always render it as a fraction.  If we still want to treat the fractional "
            + "part of the number as a decimal, then the fraction's denominator "
            + "is always a power of 10.  This example does that: 23.125 is formatted "
            + "as \"twenty-three and one hundred twenty-five thousandths\" (as opposed "
            + "to \"twenty-three point one two five\" or \"twenty-three and one eighth\").",

            "Number with closest fraction.  This example formats a value using "
            + "numerals, but shows the fractional part as a ratio (fraction) rather "
            + "than a decimal.  The fraction always has a denominator between 2 and 10.",

            "American stock-price formatting.  Non-integral stock prices are still "
            + "generally shown in eighths or sixteenths of dollars instead of dollars "
            + "and cents.  This example formats stock prices in this way if possible, "
            + "and in dollars and cents if not.",

            "The next few examples demonstrate using a RuleBasedNumberFormat to "
            + "change the units a value is denominated in depending on its magnitude.  "
            + "The example shows large numbers the way they often appear is nwespapers: "
            + "1,200,000 is formatted as \"1.2 million\".",

            "This example takes a number of meters and formats it in whatever unit "
            + "will produce a number with from one to three digits before the decimal "
            + "point.  For example, 230,000 is formatted as \"230 km\".",

            "A more complicated message-formatting example.  Here, in addition to "
            + "handling the singular and plural versions of the word, the value is "
            + "denominated in bytes, kilobytes, or megabytes depending on its magnitude.  "
            + "Also notice that it correctly treats a kilobyte as 1,024 bytes (not 1,000), "
            + "and a megabyte as 1,024 kilobytes (not 1,000).",

            "This example formats a number in dozens and gross.  This is intended to "
            + "demonstrate how this rule set can be used to format numbers in systems "
            + "other than base 10.  The \"/12\" after the rules' base values controls this.  "
            + "Also notice that the base doesn't have to be consistent throughout the "
            + "whole rule set: we go back to base 10 for values over 1,000.",

            "The next few examples show how a single value can be divided up into major "
            + "and minor units that don't relate to each other by a factor of 10.  "
            + "This example formats a number of seconds in sexagesimal notation "
            + "(i.e., hours, minutes, and seconds).  %with-words formats it with "
            + "words (3740 is \"1 hour, 2 minutes, 20 seconds\") and %in-numerals "
            + "formats it entirely in numerals (3740 is \"1:02:20\").",

            "This example formats a number of hours in sexagesimal notation (i.e., "
            + "hours, minutes, and seconds).  %with-words formats the value using "
            + "words for the units, and %in-numerals formats the value using only "
            + "numerals.",

            "This rule set formats a number of pounds as pounds, shillings, and "
            + "pence in the old English system of currency.",

            "These examples show how RuleBasedNumberFormat can be used to format "
            + "numbers using non-positional numeration systems.  "
            + "This example formats numbers in Arabic numerals.  "
            + "Normally, you'd do this with DecimalFormat, but this shows that "
            + "RuleBasedNumberFormat can handle it too.",

            "This example follows the same pattern as the Arabic-numerals "
            + "example, but uses words for the various digits (e.g., 123 comes "
            + "out as \"one two three\").",

            "This example formats numbers using Chinese characters in the Arabic "
            + "place-value method.  This was used historically in China for a while.",

            "Roman numerals.  This example has two variants: %modern shows how large "
            + "numbers are usually handled today; %historical ses the older symbols for "
            + "thousands.  Not all of the characters are displayable with most fonts.",

            "Hebrew alphabetic numerals.  Before adoption of Arabic numerals, Hebrew speakers "
            + "used the letter of their alphabet as numerals.  The first nine letters of "
            + "the alphabet repesented the values from 1 to 9, the second nine letters the "
            + "multiples of 10, and the remaining letters the multiples of 100.  Since they "
            + "ran out of letters at 400, the remaining multiples of 100 were represented "
            + "using combinations of the existing letters for the hundreds.  Numbers were "
            + "distinguished from words in a number of different ways: the way shown here "
            + "uses a single mark after a number consisting of one letter, and a double "
            + "mark between the last two letters of a number consisting of two or more "
            + "letters.  Two dots over a letter multiplied its value by 1,000.  Also, since "
            + "the letter for 10 is the first letter of God's name and the letters for 5 and 6 "
            + "are letters in God's name, which wasn't supposed to be written or spoken, 15 and "
            + "16 were usually written as 9 + 6 and 9 + 7 instead of 10 + 5 and 10 + 6.",

            "Greek alphabetic numerals.  The Greeks, before adopting the Arabic numerals, "
            + "also used the letters of their alphabet as numerals.  There are three now-"
            + "obsolete Greek letters that are used as numerals; many fonts don't have them.  "
            + "Large numbers were handled many different ways; the way shown here divides "
            + "large numbers into groups of four letters (factors of 10,000), and separates "
            + "the groups with the capital letter mu (for myriad).  Capital letters are used "
            + "for values below 10,000; small letters for higher numbers (to make the capital "
            + "mu stand out).",

            "This is a custom (user-defined) rule set."
        };
}