// ***************************************************************************
// *
// *   Copyright (C) 1997-2002, International Business Machines
// *   Corporation and others.  All Rights Reserved.
// *
// ***************************************************************************

en {
    Version { "1.0" }
    NumberPatterns { 
        "#,##0.###;-#,##0.###",
        "\u00A4#,##0.00;-\u00A4#,##0.00",
        "#,##0%",
        "#E0",
    }

    // Format for the display name of a Transliterator.
    // This is the English form of this resource.
    TransliteratorNamePattern { "{0,choice,0#|1#{1}|2#{1} to {2}}" }

    zoneStrings { 
        {
            "PST",
            "Pacific Standard Time",
            "PST",
            "Pacific Daylight Time",
            "PDT",
            "Los Angeles",
        }
        {
            "America/Los_Angeles",
            "Pacific Standard Time",
            "PST",
            "Pacific Daylight Time",
            "PDT",
            "Los Angeles",
        }
        {
            "MST",
            "Mountain Standard Time",
            "MST",
            "Mountain Daylight Time",
            "MDT",
            "Denver",
        }
        {
            "America/Denver",
            "Mountain Standard Time",
            "MST",
            "Mountain Daylight Time",
            "MDT",
            "Denver",
        }
        {
            "PNT",
            "Mountain Standard Time",
            "MST",
            "Mountain Standard Time",
            "MST",
            "Phoenix",
        }
        {
            "America/Phoenix",
            "Mountain Standard Time",
            "MST",
            "Mountain Standard Time",
            "MST",
            "Phoenix",
        }
        {
            "CST",
            "Central Standard Time",
            "CST",
            "Central Daylight Time",
            "CDT",
            "Chicago",
        }
        {
            "America/Chicago",
            "Central Standard Time",
            "CST",
            "Central Daylight Time",
            "CDT",
            "Chicago",
        }
        {
            "EST",
            "Eastern Standard Time",
            "EST",
            "Eastern Daylight Time",
            "EDT",
            "New York",
        }
        {
            "America/New_York",
            "Eastern Standard Time",
            "EST",
            "Eastern Daylight Time",
            "EDT",
            "New York",
        }
        {
            "IET",
            "Eastern Standard Time",
            "EST",
            "Eastern Standard Time",
            "EST",
            "Indianapolis",
        }
        {
            "America/Indianapolis",
            "Eastern Standard Time",
            "EST",
            "Eastern Standard Time",
            "EST",
            "Indianapolis",
        }
        {
            "HST",
            "Hawaii Standard Time",
            "HST",
            "Hawaii Standard Time",
            "HST",
            "Honolulu",
        }
        {
            "Pacific/Honolulu",
            "Hawaii Standard Time",
            "HST",
            "Hawaii Standard Time",
            "HST",
            "Honolulu",
        }
        {
            "AST",
            "Alaska Standard Time",
            "AST",
            "Alaska Daylight Time",
            "ADT",
            "Anchorage"
        }
        {
            "America/Anchorage",
            "Alaska Standard Time",
            "AST",
            "Alaska Daylight Time",
            "ADT",
            "Anchorage",
        }
        {
            "America/Halifax",
            "Atlantic Standard Time",
            "AST",
            "Atlantic Daylight Time",
            "ADT",
            "Halifax"
        }
        {
            "CNT",
            "Newfoundland Standard Time",
            "CNT",
            "Newfoundland Daylight Time",
            "CDT",
            "St. Johns",
        }
        {
            "America/St_Johns",
            "Newfoundland Standard Time",
            "CNT",
            "Newfoundland Daylight Time",
            "CDT",
            "St. Johns",
        }
        {
            "ECT",
            "Central European Standard Time",
            "CET",
            "Central European Daylight Time",
            "CEST",
            "Paris",
        }
        {
            "Europe/Paris",
            "Central European Standard Time",
            "CET",
            "Central European Daylight Time",
            "CEST",
            "Paris",
        }
        {
            "GMT",
            "Greenwich Mean Time",
            "GMT",
            "Greenwich Mean Time",
            "GMT",
            "London",
        }
        {
            "Africa/Casablanca",
            "Greenwich Mean Time",
            "GMT",
            "Greenwich Mean Time",
            "GMT",
            "Casablanca",
        }
        {
            "Asia/Jerusalem",
            "Israel Standard Time",
            "IST",
            "Israel Daylight Time",
            "IDT",
            "Jerusalem",
        }
        {
            "JST",
            "Japan Standard Time",
            "JST",
            "Japan Standard Time",
            "JST",
            "Tokyo",
        }
        {
            "Asia/Tokyo",
            "Japan Standard Time",
            "JST",
            "Japan Standard Time",
            "JST",
            "Tokyo",
        }
        {
            "Europe/Bucharest",
            "Eastern European Standard Time",
            "EET",
            "Eastern European Daylight Time",
            "EEST",
            "Bucharest",
        }
        {
            "CTT",
            "China Standard Time",
            "CTT",
            "China Standard Time",
            "CDT",
            "Shanghai",
        }
        {
            "Asia/Shanghai",
            "China Standard Time",
            "CTT",
            "China Standard Time",
            "CDT",
            "Shanghai",
        }
    }
    LocaleID:int { 0x09 }
//    LocaleScript{ 
//        "Latn",  // ISO 15924 Name 
//    }

    //------------------------------------------------------------
    // Rule Based Number Format Support
    //------------------------------------------------------------

//         * Spellout rules for U.S. English.  This rule set has two variants:
//         * %simplified is a set of rules showing the simple method of spelling
//         * out numbers in English: 289 is formatted as "two hundred eighty-nine".
//         * %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.

     SpelloutRules {
        // 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"

        // %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 have 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"
        "   &\u0000 << ' ' << ',' << '-'; \n"
    }


//         * 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.
    OrdinalRules {
        // 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 rule set formats a number of seconds in sexagesimal notation
//         * (i.e., hours, minutes, and seconds).  %with-words formats it with
//         * words (3,740 is "1 hour, 2 minutes, 20 seconds") and %in-numerals
//         * formats it entirely in numerals (3,740 is "1:02:20").
    DurationRules {
        // 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" 
    }
}