Refactoring

lib/composer/vendor/gettext/languages/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Michele Locati
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

lib/composer/vendor/gettext/languages/UNICODE-LICENSE.txt

@@ -0,0 +1,50 @@
+UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
+
+    Unicode Data Files include all data files under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/, and
+http://www.unicode.org/cldr/data/. Unicode Data Files do not include PDF
+online code charts under the directory http://www.unicode.org/Public/.
+Software includes any source code published in the Unicode Standard or under
+the directories http://www.unicode.org/Public/,
+http://www.unicode.org/reports/, and http://www.unicode.org/cldr/data/.
+
+    NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S DATA FILES
+("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"), YOU UNEQUIVOCALLY ACCEPT, AND
+AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS OF THIS AGREEMENT. IF
+YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA
+FILES OR SOFTWARE.
+
+    COPYRIGHT AND PERMISSION NOTICE
+
+    Copyright © 1991-2014 Unicode, Inc. All rights reserved. Distributed under
+the Terms of Use in http://www.unicode.org/copyright.html.
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+copy of the Unicode data files and any associated documentation (the "Data
+Files") or Unicode software and any associated documentation (the "Software")
+to deal in the Data Files or Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute, and/or
+sell copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that (a) the above
+copyright notice(s) and this permission notice appear with all copies of the
+Data Files or Software, (b) both the above copyright notice(s) and this
+permission notice appear in associated documentation, and (c) there is clear
+notice in each modified Data File or in the Software as well as in the
+documentation associated with the Data File(s) or Software that the data or
+software has been modified.
+
+    THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD
+PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
+THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE
+DATA FILES OR SOFTWARE.
+
+    Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written authorization
+of the copyright holder.

lib/composer/vendor/gettext/languages/bin/export.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+php "%~dpn0.php" %*

lib/composer/vendor/gettext/languages/bin/export.php

@@ -0,0 +1,234 @@
+<?php
+use Gettext\Languages\Exporter\Exporter;
+use Gettext\Languages\Language;
+
+// Let's start by imposing that we don't accept any error or warning.
+// This is a really life-saving approach.
+error_reporting(E_ALL);
+set_error_handler(function ($errno, $errstr, $errfile, $errline) {
+    Enviro::echoErr("$errstr\nFile: $errfile\nLine: $errline\nCode: $errno\n");
+    die(5);
+});
+
+require_once dirname(__DIR__).'/src/autoloader.php';
+
+// Parse the command line options
+Enviro::initialize();
+
+try {
+    if (isset(Enviro::$languages)) {
+        $languages = array();
+        foreach (Enviro::$languages as $languageId) {
+            $language = Language::getById($languageId);
+            if (!isset($language)) {
+                throw new Exception("Unable to find the language with id '$languageId'");
+            }
+            $languages[] = $language;
+        }
+    } else {
+        $languages = Language::getAll();
+    }
+    if (Enviro::$reduce) {
+        $languages = Enviro::reduce($languages);
+    }
+    if (isset(Enviro::$outputFilename)) {
+        echo call_user_func(array(Exporter::getExporterClassName(Enviro::$outputFormat), 'toFile'), $languages, Enviro::$outputFilename, array('us-ascii' => Enviro::$outputUSAscii));
+    } else {
+        echo call_user_func(array(Exporter::getExporterClassName(Enviro::$outputFormat), 'toString'), $languages, array('us-ascii' => Enviro::$outputUSAscii));
+    }
+} catch (Exception $x) {
+    Enviro::echoErr($x->getMessage()."\n");
+    Enviro::echoErr("Trace:\n");
+    Enviro::echoErr($x->getTraceAsString()."\n");
+    die(4);
+}
+
+die(0);
+
+/**
+ * Helper class to handle command line options.
+ */
+class Enviro
+{
+    /**
+     * Shall the output contain only US-ASCII characters?
+     * @var bool
+     */
+    public static $outputUSAscii;
+    /**
+     * The output format.
+     * @var string
+     */
+    public static $outputFormat;
+    /**
+     * Output file name.
+     * @var string
+     */
+    public static $outputFilename;
+    /**
+     * List of wanted language IDs; it not set: all languages will be returned.
+     * @var array|null
+     */
+    public static $languages;
+    /**
+     * Reduce the language list to the minimum common denominator.
+     * @var bool
+     */
+    public static $reduce;
+    /**
+     * Parse the command line options.
+     */
+    public static function initialize()
+    {
+        global $argv;
+        self::$outputUSAscii = false;
+        self::$outputFormat = null;
+        self::$outputFilename = null;
+        self::$languages = null;
+        self::$reduce = null;
+        $exporters = Exporter::getExporters();
+        if (isset($argv) && is_array($argv)) {
+            foreach ($argv as $argi => $arg) {
+                if ($argi === 0) {
+                    continue;
+                }
+                if (is_string($arg)) {
+                    $argLC = trim(strtolower($arg));
+                    switch ($argLC) {
+                        case '--us-ascii':
+                            self::$outputUSAscii = true;
+                            break;
+                        case '--reduce=yes':
+                            self::$reduce = true;
+                            break;
+                        case '--reduce=no':
+                            self::$reduce = false;
+                            break;
+                        default:
+                            if (preg_match('/^--output=.+$/', $argLC)) {
+                                if (isset(self::$outputFilename)) {
+                                    self::echoErr("The output file name has been specified more than once!\n");
+                                    self::showSyntax();
+                                    die(3);
+                                }
+                                list(, self::$outputFilename) = explode('=', $arg, 2);
+                                self::$outputFilename = trim(self::$outputFilename);
+                            } elseif (preg_match('/^--languages?=.+$/', $argLC)) {
+                                list(, $s) = explode('=', $arg, 2);
+                                $list = explode(',', $s);
+                                if (is_array(self::$languages)) {
+                                    self::$languages = array_merge(self::$languages, $list);
+                                } else {
+                                    self::$languages = $list;
+                                }
+                            } elseif (isset($exporters[$argLC])) {
+                                if (isset(self::$outputFormat)) {
+                                    self::echoErr("The output format has been specified more than once!\n");
+                                    self::showSyntax();
+                                    die(3);
+                                }
+                                self::$outputFormat = $argLC;
+                            } else {
+                                self::echoErr("Unknown option: $arg\n");
+                                self::showSyntax();
+                                die(2);
+                            }
+                            break;
+                    }
+                }
+            }
+        }
+        if (!isset(self::$outputFormat)) {
+            self::showSyntax();
+            die(1);
+        }
+        if (isset(self::$languages)) {
+            self::$languages = array_values(array_unique(self::$languages));
+        }
+        if (!isset(self::$reduce)) {
+            self::$reduce = isset(self::$languages) ? false : true;
+        }
+    }
+
+    /**
+     * Write out the syntax.
+     */
+    public static function showSyntax()
+    {
+        $exporters = array_keys(Exporter::getExporters(true));
+        self::echoErr("Syntax: php ".basename(__FILE__)." [--us-ascii] [--languages=<LanguageId>[,<LanguageId>,...]] [--reduce=yes|no] [--output=<file name>] <".implode('|', $exporters).">\n");
+        self::echoErr("Where:\n");
+        self::echoErr("--us-ascii : if specified, the output will contain only US-ASCII characters.\n");
+        self::echoErr("--languages: (or --language) export only the specified language codes.\n");
+        self::echoErr("             Separate languages with commas; you can also use this argument\n");
+        self::echoErr("             more than once; it's case insensitive and accepts both '_' and\n");
+        self::echoErr("             '-' as locale chunks separator (eg we accept 'it_IT' as well as\n");
+        self::echoErr("            'it-it').\n");
+        self::echoErr("--reduce   : if set to yes the output won't contain languages with the same\n");
+        self::echoErr("             base language and rules.\n For instance nl_BE ('Flemish') will be\n");
+        self::echoErr("             omitted because it's the same as nl ('Dutch').\n");
+        self::echoErr("             Defaults to 'no' --languages is specified, to 'yes' otherwise.\n");
+        self::echoErr("--output   : if specified, the output will be saved to <file name>. If not\n");
+        self::echoErr("             specified we'll output to standard output.\n");
+        self::echoErr("Output formats\n");
+        $len = max(array_map('strlen', $exporters));
+        foreach ($exporters as $exporter) {
+            self::echoErr(str_pad($exporter, $len).": ".Exporter::getExporterDescription($exporter)."\n");
+        }
+    }
+    /**
+     * Print a string to stderr.
+     * @param string $str The string to be printed out.
+     */
+    public static function echoErr($str)
+    {
+        $hStdErr = @fopen('php://stderr', 'a');
+        if ($hStdErr === false) {
+            echo $str;
+        } else {
+            fwrite($hStdErr, $str);
+            fclose($hStdErr);
+        }
+    }
+    /**
+     * Reduce a language list to the minimum common denominator.
+     * @param Language[] $languages
+     * @return Language[]
+     */
+    public static function reduce($languages)
+    {
+        for ($numChunks = 3; $numChunks >= 2; $numChunks--) {
+            $filtered = array();
+            foreach ($languages as $language) {
+                $chunks = explode('_', $language->id);
+                $compatibleFound = false;
+                if (count($chunks) === $numChunks) {
+                    $categoriesHash = serialize($language->categories);
+                    $otherIds = array();
+                    $otherIds[] = $chunks[0];
+                    for ($k = 2; $k < $numChunks; $k++) {
+                        $otherIds[] = $chunks[0].'_'.$chunks[$numChunks - 1];
+                    }
+
+                    foreach ($languages as $check) {
+                        foreach ($otherIds as $otherId) {
+                            if (($check->id === $otherId) && ($check->formula === $language->formula) && (serialize($check->categories) === $categoriesHash)) {
+                                $compatibleFound = true;
+                                break;
+                            }
+                        }
+                        if ($compatibleFound === true) {
+                            break;
+                        }
+                    }
+                }
+                if (!$compatibleFound) {
+                    $filtered[] = $language;
+                }
+            }
+            $languages = $filtered;
+        }
+
+        return $languages;
+    }
+}

lib/composer/vendor/gettext/languages/bin/export.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+php "$(dirname -- "$0")/export.php" $@

lib/composer/vendor/gettext/languages/composer.json

@@ -0,0 +1,38 @@
+
+{
+    "name": "gettext/languages",
+    "description": "gettext languages with plural rules",
+    "keywords": [
+        "localization",
+        "l10n",
+        "internationalization",
+        "i18n",
+        "translations",
+        "translate",
+        "php",
+        "unicode",
+        "cldr",
+        "language",
+        "languages",
+        "plural",
+        "plurals",
+		  "plural rules"
+    ],
+    "homepage": "https://github.com/mlocati/cldr-to-gettext-plural-rules",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Michele Locati",
+            "email": "mlocati@gmail.com",
+            "role": "Developer"
+        }
+    ],
+    "autoload": {
+        "psr-4": {
+            "Gettext\\Languages\\": "src/"
+        }
+    },
+    "require": {
+        "php": ">=5.3"
+    }
+}

lib/composer/vendor/gettext/languages/src/Category.php

@@ -0,0 +1,108 @@
+<?php
+namespace Gettext\Languages;
+
+use Exception;
+
+/**
+ * A helper class that handles a single category rules (eg 'zero', 'one', ...) and its formula and examples.
+ */
+class Category
+{
+    /**
+     * The category identifier (eg 'zero', 'one', ..., 'other').
+     * @var string
+     */
+    public $id;
+    /**
+     * The gettext formula that identifies this category (null if and only if the category is 'other').
+     * @var string|null
+     */
+    public $formula;
+    /**
+     * The CLDR representation of some exemplar numeric ranges that satisfy this category.
+     * @var string|null
+     */
+    public $examples;
+    /**
+     * Initialize the instance and parse the formula.
+     * @param string $cldrCategoryId The CLDR category identifier (eg 'pluralRule-count-one').
+     * @param string $cldrFormulaAndExamples The CLDR formula and examples (eg 'i = 1 and v = 0 @integer 1').
+     * @throws Exception
+     */
+    public function __construct($cldrCategoryId, $cldrFormulaAndExamples)
+    {
+        $matches = array();
+        if (!preg_match('/^pluralRule-count-(.+)$/', $cldrCategoryId, $matches)) {
+            throw new Exception("Invalid CLDR category: '$cldrCategoryId'");
+        }
+        if (!in_array($matches[1], CldrData::$categories)) {
+            throw new Exception("Invalid CLDR category: '$cldrCategoryId'");
+        }
+        $this->id = $matches[1];
+        $cldrFormulaAndExamplesNormalized = trim(preg_replace('/\s+/', ' ', $cldrFormulaAndExamples));
+        if (!preg_match('/^([^@]*)(?:@integer([^@]+))?(?:@decimal(?:[^@]+))?$/', $cldrFormulaAndExamplesNormalized, $matches)) {
+            throw new Exception("Invalid CLDR category rule: $cldrFormulaAndExamples");
+        }
+        $cldrFormula = trim($matches[1]);
+        $s = isset($matches[2]) ? trim($matches[2]) : '';
+        $this->examples = ($s === '') ? null : $s;
+        switch ($this->id) {
+            case CldrData::OTHER_CATEGORY:
+                if ($cldrFormula !== '') {
+                    throw new Exception("The '".CldrData::OTHER_CATEGORY."' category should not have any formula, but it has '$cldrFormula'");
+                }
+                $this->formula = null;
+                break;
+            default:
+                if ($cldrFormula === '') {
+                    throw new Exception("The '{$this->id}' category does not have a formula");
+                }
+                $this->formula = FormulaConverter::convertFormula($cldrFormula);
+                break;
+        }
+    }
+    /**
+     * Return a list of numbers corresponding to the $examples value.
+     * @throws Exception Throws an Exception if we weren't able to expand the examples.
+     * @return int[]
+     */
+    public function getExampleIntegers()
+    {
+        return self::expandExamples($this->examples);
+    }
+    /**
+     * Expand a list of examples as defined by CLDR.
+     * @param string $examples A string like '1, 2, 5...7, …'.
+     * @throws Exception Throws an Exception if we weren't able to expand $examples.
+     * @return int[]
+     */
+    public static function expandExamples($examples)
+    {
+        $result = array();
+        $m = null;
+        if (substr($examples, -strlen(', …')) === ', …') {
+            $examples = substr($examples, 0, strlen($examples) -strlen(', …'));
+        }
+        foreach (explode(',', str_replace(' ', '', $examples)) as $range) {
+            if (preg_match('/^\d+$/', $range)) {
+                $result[] = intval($range);
+            } elseif (preg_match('/^(\d+)~(\d+)$/', $range, $m)) {
+                $from = intval($m[1]);
+                $to = intval($m[2]);
+                $delta = $to - $from;
+                $step = (int) max(1, $delta / 100);
+                for ($i = $from; $i < $to; $i += $step) {
+                    $result[] = $i;
+                }
+                $result[] = $to;
+            } else {
+                throw new Exception("Unhandled test range '$range' in '$examples'");
+            }
+        }
+        if (empty($result)) {
+            throw new Exception("No test numbers from '$examples'");
+        }
+
+        return $result;
+    }
+}

lib/composer/vendor/gettext/languages/src/CldrData.php

@@ -0,0 +1,320 @@
+<?php
+namespace Gettext\Languages;
+
+use Exception;
+
+/**
+ * Holds the CLDR data.
+ */
+class CldrData
+{
+    /**
+     * Super-special plural category: this should always be present for any language.
+     * @var string
+     */
+    const OTHER_CATEGORY = 'other';
+    /**
+     * The list of the plural categories, sorted from 'zero' to 'other'.
+     * @var string[]
+     */
+    public static $categories = array('zero', 'one', 'two', 'few', 'many', self::OTHER_CATEGORY);
+    /**
+     * The loaded CLDR data
+     * @var array
+     */
+    private static $data;
+    /**
+     * Returns the loaded CLDR data.
+     * @param string $key Can be 'languages', 'territories', 'plurals', 'supersededLanguages', 'scripts', 'standAloneScripts'
+     */
+    private static function getData($key)
+    {
+        if (!isset(self::$data)) {
+            $fixKeys = function ($list, &$standAlone = null) {
+                $result = array();
+                $standAlone = array();
+                $match = null;
+                foreach ($list as $key => $value) {
+                    $variant = '';
+                    if (preg_match('/^(.+)-alt-(short|variant|stand-alone)$/', $key, $match)) {
+                        $key = $match[1];
+                        $variant = $match[2];
+                    }
+                    $key = str_replace('-', '_', $key);
+                    switch ($key) {
+                        case 'root': // Language: Root
+                        case 'und': // Language: Unknown Language
+                        case 'zxx': // Language: No linguistic content
+                        case 'ZZ': // Territory: Unknown Region
+                        case 'Zinh': // Script: Inherited
+                        case 'Zmth': // Script: Mathematical Notation
+                        case 'Zsym': // Script: Symbols
+                        case 'Zxxx': // Script: Unwritten
+                        case 'Zyyy': // Script: Common
+                        case 'Zzzz': // Script: Unknown Script
+                            break;
+                        default:
+                            if (
+                                ((strlen($key) !== 4) || ($key < 'Qaaa') || ($key > 'Qabx')) // Script: Reserved for private use
+                            ) {
+                                switch ($variant) {
+                                    case 'stand-alone':
+                                        $standAlone[$key] = $value;
+                                        break;
+                                    case '':
+                                        $result[$key] = $value;
+                                        break;
+                                }
+                            }
+                            break;
+                    }
+                }
+
+                return $result;
+            };
+            $data = array();
+            $json = json_decode(file_get_contents(__DIR__.'/cldr-data/main/en-US/languages.json'), true);
+            $data['languages'] = $fixKeys($json['main']['en-US']['localeDisplayNames']['languages']);
+            $json = json_decode(file_get_contents(__DIR__.'/cldr-data/main/en-US/territories.json'), true);
+            $data['territories'] = $fixKeys($json['main']['en-US']['localeDisplayNames']['territories']);
+            $json = json_decode(file_get_contents(__DIR__.'/cldr-data/supplemental/plurals.json'), true);
+            $data['plurals'] = $fixKeys($json['supplemental']['plurals-type-cardinal']);
+            $json = json_decode(file_get_contents(__DIR__.'/cldr-data/main/en-US/scripts.json'), true);
+            $data['scripts'] = $fixKeys($json['main']['en-US']['localeDisplayNames']['scripts'], $data['standAloneScripts']);
+            $data['standAloneScripts'] = array_merge($data['scripts'], $data['standAloneScripts']);
+            $data['scripts'] = array_merge($data['standAloneScripts'], $data['scripts']);
+            $data['supersededLanguages'] = array();
+            // Remove the languages for which we don't have plurals
+            $m = null;
+            foreach (array_keys(array_diff_key($data['languages'], $data['plurals'])) as $missingPlural) {
+                if (preg_match('/^([a-z]{2,3})_/', $missingPlural, $m)) {
+                    if (!isset($data['plurals'][$m[1]])) {
+                        unset($data['languages'][$missingPlural]);
+                    }
+                } else {
+                    unset($data['languages'][$missingPlural]);
+                }
+            }
+            // Fix the languages for which we have plurals
+            $formerCodes = array(
+                'in' => 'id', // former Indonesian
+                'iw' => 'he', // former Hebrew
+                'ji' => 'yi', // former Yiddish
+                'jw' => 'jv', // former Javanese
+                'mo' => 'ro_MD', // former Moldavian
+            );
+            $knownMissingLanguages = array(
+                'bh' => 'Bihari',
+                'guw' => 'Gun',
+                'nah' => 'Nahuatl',
+                'smi' => 'Sami',
+            );
+            foreach (array_keys(array_diff_key($data['plurals'], $data['languages'])) as $missingLanguage) {
+                if (isset($formerCodes[$missingLanguage]) && isset($data['languages'][$formerCodes[$missingLanguage]])) {
+                    $data['languages'][$missingLanguage] = $data['languages'][$formerCodes[$missingLanguage]];
+                    $data['supersededLanguages'][$missingLanguage] = $formerCodes[$missingLanguage];
+                } else {
+                    if (isset($knownMissingLanguages[$missingLanguage])) {
+                        $data['languages'][$missingLanguage] = $knownMissingLanguages[$missingLanguage];
+                    } else {
+                        throw new Exception("We have the plural rule for the language '$missingLanguage' but we don't have its language name");
+                    }
+                }
+            }
+            ksort($data['languages'], SORT_STRING);
+            ksort($data['territories'], SORT_STRING);
+            ksort($data['plurals'], SORT_STRING);
+            ksort($data['scripts'], SORT_STRING);
+            ksort($data['standAloneScripts'], SORT_STRING);
+            ksort($data['supersededLanguages'], SORT_STRING);
+            self::$data = $data;
+        }
+        if (!@isset(self::$data[$key])) {
+            throw new Exception("Invalid CLDR data key: '$key'");
+        }
+
+        return self::$data[$key];
+    }
+    /**
+     * Returns a dictionary containing the language names.
+     * The keys are the language identifiers.
+     * The values are the language names in US English.
+     * @return string[]
+     */
+    public static function getLanguageNames()
+    {
+        return self::getData('languages');
+    }
+    /**
+     * Return a dictionary containing the territory names (in US English).
+     * The keys are the territory identifiers.
+     * The values are the territory names in US English.
+     * @return string[]
+     */
+    public static function getTerritoryNames()
+    {
+        return self::getData('territories');
+    }
+    /**
+     * Return a dictionary containing the script names (in US English).
+     * The keys are the script identifiers.
+     * The values are the script names in US English.
+     * @param bool $standAlone Set to true to retrieve the stand-alone script names, false otherwise.
+     * @return string[]
+     */
+    public static function getScriptNames($standAlone)
+    {
+        return self::getData($standAlone ? 'standAloneScripts' : 'scripts');
+    }
+    /**
+     * @var array
+     */
+    private static $plurals;
+    /**
+     * A dictionary containing the plural rules.
+     * The keys are the language identifiers.
+     * The values are arrays whose keys are the CLDR category names and the values are the CLDR category definition.
+     * @example The English key-value pair is somethink like this:
+     * <code><pre>
+     * "en": {
+     *     "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+     *     "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+     * }
+     * </pre></code>
+     * @var array
+     */
+    public static function getPlurals()
+    {
+        return self::getData('plurals');
+    }
+    /**
+     * Return a list of superseded language codes.
+     * @return array Keys are the former language codes, values are the new language/locale codes.
+     */
+    public static function getSupersededLanguages()
+    {
+        return self::getData('supersededLanguages');
+    }
+    /**
+     * Retrieve the name of a language, as well as if a language code is deprecated in favor of another language code.
+     * @param string $id The language identifier.
+     * @return array|null Returns an array with the keys 'id' (normalized), 'name', 'supersededBy' (optional), 'territory' (optional), 'script' (optional), 'baseLanguage' (optional), 'categories'. If $id is not valid returns null.
+     */
+    public static function getLanguageInfo($id)
+    {
+        $result = null;
+        $matches = array();
+        if (preg_match('/^([a-z]{2,3})(?:[_\-]([a-z]{4}))?(?:[_\-]([a-z]{2}|[0-9]{3}))?(?:$|-)/i', $id, $matches)) {
+            $languageId = strtolower($matches[1]);
+            $scriptId = (isset($matches[2]) && ($matches[2] !== '')) ? ucfirst(strtolower($matches[2])) : null;
+            $territoryId = (isset($matches[3]) && ($matches[3] !== '')) ? strtoupper($matches[3]) : null;
+            $normalizedId = $languageId;
+            if (isset($scriptId)) {
+                $normalizedId .= '_'.$scriptId;
+            }
+            if (isset($territoryId)) {
+                $normalizedId .= '_'.$territoryId;
+            }
+            // Structure precedence: see Likely Subtags - http://www.unicode.org/reports/tr35/tr35-31/tr35.html#Likely_Subtags
+            $variants = array();
+            $variantsWithScript = array();
+            $variantsWithTerritory = array();
+            if (isset($scriptId) && isset($territoryId)) {
+                $variantsWithTerritory[] = $variantsWithScript[] = $variants[] = "{$languageId}_{$scriptId}_{$territoryId}";
+            }
+            if (isset($scriptId)) {
+                $variantsWithScript[] = $variants[] = "{$languageId}_{$scriptId}";
+            }
+            if (isset($territoryId)) {
+                $variantsWithTerritory[] = $variants[] = "{$languageId}_{$territoryId}";
+            }
+            $variants[] = $languageId;
+            $allGood = true;
+            $scriptName = null;
+            $scriptStandAloneName = null;
+            if (isset($scriptId)) {
+                $scriptNames = self::getScriptNames(false);
+                if (isset($scriptNames[$scriptId])) {
+                    $scriptName = $scriptNames[$scriptId];
+                    $scriptStandAloneNames = self::getScriptNames(true);
+                    $scriptStandAloneName = $scriptStandAloneNames[$scriptId];
+                } else {
+                    $allGood = false;
+                }
+            }
+            $territoryName = null;
+            if (isset($territoryId)) {
+                $territoryNames = self::getTerritoryNames();
+                if (isset($territoryNames[$territoryId])) {
+                    if ($territoryId !== '001') {
+                        $territoryName = $territoryNames[$territoryId];
+                    }
+                } else {
+                    $allGood = false;
+                }
+            }
+            $languageName = null;
+            $languageNames = self::getLanguageNames();
+            foreach ($variants as $variant) {
+                if (isset($languageNames[$variant])) {
+                    $languageName = $languageNames[$variant];
+                    if (isset($scriptName) && (!in_array($variant, $variantsWithScript))) {
+                        $languageName = $scriptName.' '.$languageName;
+                    }
+                    if (isset($territoryName) && (!in_array($variant, $variantsWithTerritory))) {
+                        $languageName .= ' ('.$territoryNames[$territoryId].')';
+                    }
+                    break;
+                }
+            }
+            if (!isset($languageName)) {
+                $allGood = false;
+            }
+            $baseLanguage = null;
+            if (isset($scriptId) || isset($territoryId)) {
+                if (isset($languageNames[$languageId]) && ($languageNames[$languageId] !== $languageName)) {
+                    $baseLanguage = $languageNames[$languageId];
+                }
+            }
+            $plural = null;
+            $plurals = self::getPlurals();
+            foreach ($variants as $variant) {
+                if (isset($plurals[$variant])) {
+                    $plural = $plurals[$variant];
+                    break;
+                }
+            }
+            if (!isset($plural)) {
+                $allGood = false;
+            }
+            $supersededBy = null;
+            $supersededBys = self::getSupersededLanguages();
+            foreach ($variants as $variant) {
+                if (isset($supersededBys[$variant])) {
+                    $supersededBy = $supersededBys[$variant];
+                    break;
+                }
+            }
+            if ($allGood) {
+                $result = array();
+                $result['id'] = $normalizedId;
+                $result['name'] = $languageName;
+                if (isset($supersededBy)) {
+                    $result['supersededBy'] = $supersededBy;
+                }
+                if (isset($scriptStandAloneName)) {
+                    $result['script'] = $scriptStandAloneName;
+                }
+                if (isset($territoryName)) {
+                    $result['territory'] = $territoryName;
+                }
+                if (isset($baseLanguage)) {
+                    $result['baseLanguage'] = $baseLanguage;
+                }
+                $result['categories'] = $plural;
+            }
+        }
+
+        return $result;
+    }
+}

lib/composer/vendor/gettext/languages/src/Exporter/Docs.php

@@ -0,0 +1,55 @@
+<?php
+namespace Gettext\Languages\Exporter;
+
+class Docs extends Html
+{
+    /**
+     * @see Exporter::toStringDo
+     */
+    protected static function toStringDo($languages)
+    {
+        $result = <<<EOT
+<!doctype html>
+<html lang="en">
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="IE=edge">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <meta name="author" content="Michele Locati">
+        <title>gettext plural rules - built from CLDR</title>
+        <meta name="description" content="List of all language rules for gettext .po files automatically generated from the Unicode CLDR data" />
+        <link rel="stylesheet" href="http://maxcdn.bootstrapcdn.com/bootstrap/3.3.2/css/bootstrap.min.css">
+        <link rel="stylesheet" href="style.css">
+    </head>
+    <body>
+        <a href="https://github.com/mlocati/cldr-to-gettext-plural-rules" class="hidden-xs"><img style="position: fixed; top: 0; right: 0; border: 0; z-index: 2000" src="https://s3.amazonaws.com/github/ribbons/forkme_right_red_aa0000.png" alt="Fork me on GitHub"></a>
+        <div class="container-fluid">
+
+EOT;
+        $result .= static::buildTable($languages, true);
+        $result .= <<<EOT
+
+        </div>
+        <script src="http://code.jquery.com/jquery-1.11.2.min.js"></script>
+        <script src="script.js"></script>
+    </body>
+</html>
+EOT;
+
+        return $result;
+    }
+    /**
+     * @see Exporter::isForPublicUse
+     */
+    public static function isForPublicUse()
+    {
+        return false;
+    }
+    /**
+     * @see Exporter::getDescription
+     */
+    public static function getDescription()
+    {
+        return 'Build the page http://mlocati.github.io/cldr-to-gettext-plural-rules';
+    }
+}

lib/composer/vendor/gettext/languages/src/Exporter/Exporter.php

@@ -0,0 +1,128 @@
+<?php
+namespace Gettext\Languages\Exporter;
+
+use Exception;
+use Gettext\Languages\Language;
+
+/**
+ * Base class for all the exporters.
+ */
+abstract class Exporter
+{
+    /**
+     * @var array
+     */
+    private static $exporters;
+    /**
+     * Return the list of all the available exporters. Keys are the exporter handles, values are the exporter class names.
+     * @param bool $onlyForPublicUse If true, internal exporters will be omitted.
+     * @return string[]
+     */
+    final public static function getExporters($onlyForPublicUse = false)
+    {
+        if (!isset(self::$exporters)) {
+            $exporters = array();
+            $m = null;
+            foreach (scandir(__DIR__) as $f) {
+                if (preg_match('/^(\w+)\.php$/', $f, $m)) {
+                    if ($f !== basename(__FILE__)) {
+                        $exporters[strtolower($m[1])] = $m[1];
+                    }
+                }
+            }
+            self::$exporters = $exporters;
+        }
+        if ($onlyForPublicUse) {
+            $result = array();
+            foreach (self::$exporters as $handle => $class) {
+                if (call_user_func(self::getExporterClassName($handle).'::isForPublicUse') === true) {
+                    $result[$handle] = $class;
+                }
+            }
+        } else {
+            $result = self::$exporters;
+        }
+
+        return $result;
+    }
+    /**
+     * Return the description of a specific exporter.
+     * @param string $exporterHandle The handle of the exporter.
+     * @throws Exception Throws an Exception if $exporterHandle is not valid.
+     * @return string
+     */
+    final public static function getExporterDescription($exporterHandle)
+    {
+        $exporters = self::getExporters();
+        if (!isset($exporters[$exporterHandle])) {
+            throw new Exception("Invalid exporter handle: '$exporterHandle'");
+        }
+
+        return call_user_func(self::getExporterClassName($exporterHandle).'::getDescription');
+    }
+    /**
+     * Returns the fully qualified class name of a exporter given its handle.
+     * @param string $exporterHandle The exporter class handle.
+     * @return string
+     */
+    final public static function getExporterClassName($exporterHandle)
+    {
+        return __NAMESPACE__.'\\'.ucfirst(strtolower($exporterHandle));
+    }
+    /**
+     * Convert a list of Language instances to string.
+     * @param Language[] $languages The Language instances to convert.
+     * @return string
+     */
+    protected static function toStringDo($languages)
+    {
+        throw new Exception(get_called_class().' does not implement the method '.__FUNCTION__);
+    }
+    /**
+     * Convert a list of Language instances to string.
+     * @param Language[] $languages The Language instances to convert.
+     * @return string
+     */
+    final public static function toString($languages, $options = null)
+    {
+        if (isset($options) && is_array($options)) {
+            if (isset($options['us-ascii']) && $options['us-ascii']) {
+                $asciiList = array();
+                foreach ($languages as $language) {
+                    $asciiList[] = $language->getUSAsciiClone();
+                }
+                $languages = $asciiList;
+            }
+        }
+
+        return static::toStringDo($languages);
+    }
+    /**
+     * Save the Language instances to a file.
+     * @param Language[] $languages The Language instances to convert.
+     * @throws Exception
+     */
+    final public static function toFile($languages, $filename, $options = null)
+    {
+        $data = self::toString($languages, $options);
+        if (@file_put_contents($filename, $data) === false) {
+            throw new Exception("Error writing data to '$filename'");
+        }
+    }
+    /**
+     * Is this exporter for public use?
+     * @return bool
+     */
+    public static function isForPublicUse()
+    {
+        return true;
+    }
+    /**
+     * Return a short description of the exporter.
+     * @return string
+     */
+    public static function getDescription()
+    {
+        throw new Exception(get_called_class().' does not implement the method '.__FUNCTION__);
+    }
+}

lib/composer/vendor/gettext/languages/src/Exporter/Html.php

@@ -0,0 +1,61 @@
+<?php
+namespace Gettext\Languages\Exporter;
+
+class Html extends Exporter
+{
+    /**
+     * @see Exporter::toStringDo
+     */
+    protected static function toStringDo($languages)
+    {
+        return self::buildTable($languages, false);
+    }
+    protected static function h($str)
+    {
+        return htmlspecialchars($str, ENT_COMPAT, 'UTF-8');
+    }
+    protected static function buildTable($languages, $forDocs)
+    {
+        $prefix = $forDocs ? '            ' : '';
+        $lines = array();
+        $lines[] = $prefix.'<table'.($forDocs ? ' class="table table-bordered table-condensed table-striped"' : '').'>';
+        $lines[] = $prefix.'    <thead>';
+        $lines[] = $prefix.'        <tr>';
+        $lines[] = $prefix.'            <th>Language code</th>';
+        $lines[] = $prefix.'            <th>Language name</th>';
+        $lines[] = $prefix.'            <th># plurals</th>';
+        $lines[] = $prefix.'            <th>Formula</th>';
+        $lines[] = $prefix.'            <th>Plurals</th>';
+        $lines[] = $prefix.'        </tr>';
+        $lines[] = $prefix.'    </thead>';
+        $lines[] = $prefix.'    <tbody>';
+        foreach ($languages as $lc) {
+            $lines[] = $prefix.'        <tr>';
+            $lines[] = $prefix.'            <td>'.$lc->id.'</td>';
+            $name = self::h($lc->name);
+            if (isset($lc->supersededBy)) {
+                $name .= '<br /><small><span>Superseded by</span> '.$lc->supersededBy.'</small>';
+            }
+            $lines[] = $prefix.'            <td>'.$name.'</td>';
+            $lines[] = $prefix.'            <td>'.count($lc->categories).'</td>';
+            $lines[] = $prefix.'            <td>'.self::h($lc->formula).'</td>';
+            $cases = array();
+            foreach ($lc->categories as $c) {
+                $cases[] = '<li><span>'.$c->id.'</span><code>'.self::h($c->examples).'</code></li>';
+            }
+            $lines[] = $prefix.'            <td><ol'.($forDocs ? ' class="cases"' : '').' start="0">'.implode('', $cases).'</ol></td>';
+            $lines[] = $prefix.'        </tr>';
+        }
+        $lines[] = $prefix.'    </tbody>';
+        $lines[] = $prefix.'</table>';
+
+        return implode("\n", $lines);
+    }
+    /**
+     * @see Exporter::getDescription
+     */
+    public static function getDescription()
+    {
+        return 'Build a HTML table';
+    }
+}

lib/composer/vendor/gettext/languages/src/Exporter/Json.php

@@ -0,0 +1,63 @@
+<?php
+namespace Gettext\Languages\Exporter;
+
+class Json extends Exporter
+{
+    /**
+     * Return the options for json_encode.
+     * @return int
+     */
+    protected static function getEncodeOptions()
+    {
+        $result = 0;
+        if (defined('\JSON_UNESCAPED_SLASHES')) {
+            $result |= \JSON_UNESCAPED_SLASHES;
+        }
+        if (defined('\JSON_UNESCAPED_UNICODE')) {
+            $result |= \JSON_UNESCAPED_UNICODE;
+        }
+
+        return $result;
+    }
+    /**
+     * @see Exporter::toStringDo
+     */
+    protected static function toStringDo($languages)
+    {
+        $list = array();
+        foreach ($languages as $language) {
+            $item = array();
+            $item['name'] = $language->name;
+            if (isset($language->supersededBy)) {
+                $item['supersededBy'] = $language->supersededBy;
+            }
+            if (isset($language->script)) {
+                $item['script'] = $language->script;
+            }
+            if (isset($language->territory)) {
+                $item['territory'] = $language->territory;
+            }
+            if (isset($language->baseLanguage)) {
+                $item['baseLanguage'] = $language->baseLanguage;
+            }
+            $item['formula'] = $language->formula;
+            $item['plurals'] = count($language->categories);
+            $item['cases'] = array();
+            $item['examples'] = array();
+            foreach ($language->categories as $category) {
+                $item['cases'][] = $category->id;
+                $item['examples'][$category->id] = $category->examples;
+            }
+            $list[$language->id] = $item;
+        }
+
+        return json_encode($list, static::getEncodeOptions());
+    }
+    /**
+     * @see Exporter::getDescription
+     */
+    public static function getDescription()
+    {
+        return 'Build a compressed JSON-encoded file';
+    }
+}

lib/composer/vendor/gettext/languages/src/Exporter/Php.php

@@ -0,0 +1,55 @@
+<?php
+namespace Gettext\Languages\Exporter;
+
+class Php extends Exporter
+{
+    /**
+     * @see Exporter::toStringDo
+     */
+    protected static function toStringDo($languages)
+    {
+        $lines = array();
+        $lines[] = '<?php';
+        $lines[] = 'return array(';
+        foreach ($languages as $lc) {
+            $lines[] = '    \''.$lc->id.'\' => array(';
+            $lines[] = '        \'name\' => \''.addslashes($lc->name).'\',';
+            if (isset($lc->supersededBy)) {
+                $lines[] = '        \'supersededBy\' => \''.$lc->supersededBy.'\',';
+            }
+            if (isset($lc->script)) {
+                $lines[] = '        \'script\' => \''.addslashes($lc->script).'\',';
+            }
+            if (isset($lc->territory)) {
+                $lines[] = '        \'territory\' => \''.addslashes($lc->territory).'\',';
+            }
+            if (isset($lc->baseLanguage)) {
+                $lines[] = '        \'baseLanguage\' => \''.addslashes($lc->baseLanguage).'\',';
+            }
+            $lines[] = '        \'formula\' => \''.$lc->formula.'\',';
+            $lines[] = '        \'plurals\' => '.count($lc->categories).',';
+            $catNames = array();
+            foreach ($lc->categories as $c) {
+                $catNames[] = "'{$c->id}'";
+            }
+            $lines[] = '        \'cases\' => array('.implode(', ', $catNames).'),';
+            $lines[] = '        \'examples\' => array(';
+            foreach ($lc->categories as $c) {
+                $lines[] = '            \''.$c->id.'\' => \''.$c->examples.'\',';
+            }
+            $lines[] = '        ),';
+            $lines[] = '    ),';
+        }
+        $lines[] = ');';
+        $lines[] = '';
+
+        return implode("\n", $lines);
+    }
+    /**
+     * @see Exporter::getDescription
+     */
+    public static function getDescription()
+    {
+        return 'Build a PHP array';
+    }
+}

lib/composer/vendor/gettext/languages/src/Exporter/Po.php

@@ -0,0 +1,31 @@
+<?php
+namespace Gettext\Languages\Exporter;
+
+use Exception;
+
+class Po extends Exporter
+{
+    /**
+     * @see Exporter::toStringDo
+     */
+    protected static function toStringDo($languages)
+    {
+        if (count($languages) !== 1) {
+            throw new Exception('The '.get_called_class().' exporter can only export one language');
+        }
+        $language = $languages[0];
+        $lines = array();
+        $lines[] = '"Language: '.$language->id.'\n"';
+        $lines[] = '"Plural-Forms: nplurals='.count($language->categories).'; plural='.$language->formula.'\n"';
+        $lines[] = '';
+
+        return implode("\n", $lines);
+    }
+    /**
+     * @see Exporter::getDescription
+     */
+    public static function getDescription()
+    {
+        return 'Build a string to be used for gettext .po files';
+    }
+}

lib/composer/vendor/gettext/languages/src/Exporter/Prettyjson.php

@@ -0,0 +1,25 @@
+<?php
+namespace Gettext\Languages\Exporter;
+
+use Exception;
+
+class Prettyjson extends Json
+{
+    /**
+     * @see Json::getEncodeOptions
+     */
+    protected static function getEncodeOptions()
+    {
+        if (!(defined('\JSON_PRETTY_PRINT') && defined('\JSON_UNESCAPED_SLASHES') && defined('\JSON_UNESCAPED_UNICODE'))) {
+            throw new Exception('PHP 5.4 or later is required to export uncompressed JSON');
+        }
+        return \JSON_PRETTY_PRINT | \JSON_UNESCAPED_SLASHES | \JSON_UNESCAPED_UNICODE;
+    }
+    /**
+     * @see Exporter::getDescription
+     */
+    public static function getDescription()
+    {
+        return 'Build an uncompressed JSON-encoded file (PHP 5.4 or later is needed)';
+    }
+}

lib/composer/vendor/gettext/languages/src/Exporter/Xml.php

@@ -0,0 +1,54 @@
+<?php
+namespace Gettext\Languages\Exporter;
+
+class Xml extends Exporter
+{
+    /**
+     * @see Exporter::toStringDo
+     */
+    protected static function toStringDo($languages)
+    {
+        $xml = new \DOMDocument('1.0', 'UTF-8');
+        $xml->loadXML('<languages
+            xmlns="https://github.com/mlocati/cldr-to-gettext-plural-rules"
+            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xsi:schemaLocation="https://github.com/mlocati/cldr-to-gettext-plural-rules http://mlocati.github.io/cldr-to-gettext-plural-rules/GettextLanguages.xsd"
+        />');
+        $xLanguages = $xml->firstChild;
+        foreach ($languages as $language) {
+            $xLanguage = $xml->createElement('language');
+            $xLanguage->setAttribute('id', $language->id);
+            $xLanguage->setAttribute('name', $language->name);
+            if (isset($language->supersededBy)) {
+                $xLanguage->setAttribute('supersededBy', $language->supersededBy);
+            }
+            if (isset($language->script)) {
+                $xLanguage->setAttribute('script', $language->script);
+            }
+            if (isset($language->territory)) {
+                $xLanguage->setAttribute('territory', $language->territory);
+            }
+            if (isset($language->baseLanguage)) {
+                $xLanguage->setAttribute('baseLanguage', $language->baseLanguage);
+            }
+            $xLanguage->setAttribute('formula', $language->formula);
+            foreach ($language->categories as $category) {
+                $xCategory = $xml->createElement('category');
+                $xCategory->setAttribute('id', $category->id);
+                $xCategory->setAttribute('examples', $category->examples);
+                $xLanguage->appendChild($xCategory);
+            }
+            $xLanguages->appendChild($xLanguage);
+        }
+        $xml->formatOutput = true;
+
+        return $xml->saveXML();
+    }
+    /**
+     * @see Exporter::getDescription
+     */
+    public static function getDescription()
+    {
+        return 'Build an XML file - schema available at http://mlocati.github.io/cldr-to-gettext-plural-rules/GettextLanguages.xsd';
+    }
+}

lib/composer/vendor/gettext/languages/src/FormulaConverter.php

@@ -0,0 +1,154 @@
+<?php
+namespace Gettext\Languages;
+
+use Exception;
+
+/**
+ * A helper class to convert a CLDR formula to a gettext formula.
+ */
+class FormulaConverter
+{
+    /**
+     * Converts a formula from the CLDR representation to the gettext representation.
+     * @param string $cldrFormula The CLDR formula to convert.
+     * @throws Exception
+     * @return bool|string Returns true if the gettext will always evaluate to true, false if gettext will always evaluate to false, return the gettext formula otherwise.
+     */
+    public static function convertFormula($cldrFormula)
+    {
+        if (strpbrk($cldrFormula, '()') !== false) {
+            throw new Exception("Unable to convert the formula '$cldrFormula': parenthesis handling not implemented");
+        }
+        $orSeparatedChunks = array();
+        foreach (explode(' or ', $cldrFormula) as $cldrFormulaChunk) {
+            $gettextFormulaChunk = null;
+            $andSeparatedChunks = array();
+            foreach (explode(' and ', $cldrFormulaChunk) as $cldrAtom) {
+                $gettextAtom = self::convertAtom($cldrAtom);
+                if ($gettextAtom === false) {
+                    // One atom joined by 'and' always evaluates to false => the whole 'and' group is always false
+                    $gettextFormulaChunk = false;
+                    break;
+                } elseif ($gettextAtom !== true) {
+                    $andSeparatedChunks[] = $gettextAtom;
+                }
+            }
+            if (!isset($gettextFormulaChunk)) {
+                if (empty($andSeparatedChunks)) {
+                    // All the atoms joined by 'and' always evaluate to true => the whole 'and' group is always true
+                    $gettextFormulaChunk = true;
+                } else {
+                    $gettextFormulaChunk = implode(' && ', $andSeparatedChunks);
+                    // Special cases simplification
+                    switch ($gettextFormulaChunk) {
+                        case 'n >= 0 && n <= 2 && n != 2':
+                            $gettextFormulaChunk = 'n == 0 || n == 1';
+                            break;
+                    }
+                }
+            }
+            if ($gettextFormulaChunk === true) {
+                // One part of the formula joined with the others by 'or' always evaluates to true => the whole formula always evaluates to true
+                return true;
+            } elseif ($gettextFormulaChunk !== false) {
+                $orSeparatedChunks[] = $gettextFormulaChunk;
+            }
+        }
+        if (empty($orSeparatedChunks)) {
+            // All the parts joined by 'or' always evaluate to false => the whole formula always evaluates to false
+            return false;
+        } else {
+            return implode(' || ', $orSeparatedChunks);
+        }
+    }
+    /**
+     * Converts an atomic part of the CLDR formula to its gettext representation.
+     * @param string $cldrAtom The CLDR formula atom to convert.
+     * @throws Exception
+     * @return bool|string Returns true if the gettext will always evaluate to true, false if gettext will always evaluate to false, return the gettext formula otherwise.
+     */
+    private static function convertAtom($cldrAtom)
+    {
+        $m = null;
+        $gettextAtom = $cldrAtom;
+        $gettextAtom = str_replace(' = ', ' == ', $gettextAtom);
+        $gettextAtom = str_replace('i', 'n', $gettextAtom);
+        if (preg_match('/^n( % \d+)? (!=|==) \d+$/', $gettextAtom)) {
+            return $gettextAtom;
+        }
+        if (preg_match('/^n( % \d+)? (!=|==) \d+(,\d+|\.\.\d+)+$/', $gettextAtom)) {
+            return self::expandAtom($gettextAtom);
+        }
+        if (preg_match('/^(?:v|w)(?: % 10+)? == (\d+)(?:\.\.\d+)?$/', $gettextAtom, $m)) { // For gettext: v == 0, w == 0
+            return (intval($m[1]) === 0) ? true : false;
+        }
+        if (preg_match('/^(?:v|w)(?: % 10+)? != (\d+)(?:\.\.\d+)?$/', $gettextAtom, $m)) { // For gettext: v == 0, w == 0
+            return (intval($m[1]) === 0) ? false : true;
+        }
+        if (preg_match('/^(?:f|t)(?: % 10+)? == (\d+)(?:\.\.\d+)?$/', $gettextAtom, $m)) { // f == empty, t == empty
+            return (intval($m[1]) === 0) ? true : false;
+        }
+        if (preg_match('/^(?:f|t)(?: % 10+)? != (\d+)(?:\.\.\d+)?$/', $gettextAtom, $m)) { // f == empty, t == empty
+            return (intval($m[1]) === 0) ? false : true;
+        }
+        throw new Exception("Unable to convert the formula chunk '$cldrAtom' from CLDR to gettext");
+    }
+    /**
+     * Expands an atom containing a range (for instance: 'n == 1,3..5').
+     * @param string $atom
+     * @throws Exception
+     * @return string
+     */
+    private static function expandAtom($atom)
+    {
+        $m = null;
+        if (preg_match('/^(n(?: % \d+)?) (==|!=) (\d+(?:\.\.\d+|,\d+)+)$/', $atom, $m)) {
+            $what = $m[1];
+            $op = $m[2];
+            $chunks = array();
+            foreach (explode(',', $m[3]) as $range) {
+                $chunk = null;
+                if ((!isset($chunk)) && preg_match('/^\d+$/', $range)) {
+                    $chunk = "$what $op $range";
+                }
+                if ((!isset($chunk)) && preg_match('/^(\d+)\.\.(\d+)$/', $range, $m)) {
+                    $from = intval($m[1]);
+                    $to = intval($m[2]);
+                    if (($to - $from) === 1) {
+                        switch ($op) {
+                            case '==':
+                                $chunk = "($what == $from || $what == $to)";
+                                break;
+                            case '!=':
+                                $chunk = "$what != $from && $what == $to";
+                                break;
+                        }
+                    } else {
+                        switch ($op) {
+                            case '==':
+                                $chunk = "$what >= $from && $what <= $to";
+                                break;
+                            case '!=':
+                                $chunk = "($what < $from || $what > $to)";
+                                break;
+                        }
+                    }
+                }
+                if (!isset($chunk)) {
+                    throw new Exception("Unhandled range '$range' in '$atom'");
+                }
+                $chunks[] = $chunk;
+            }
+            if (count($chunks) === 1) {
+                return $chunks[0];
+            }
+            switch ($op) {
+                case '==':
+                    return '('.implode(' || ', $chunks).')';break;
+                case '!=':
+                    return implode(' && ', $chunks);
+            }
+        }
+        throw new Exception("Unable to expand '$atom'");
+    }
+}

lib/composer/vendor/gettext/languages/src/Language.php

@@ -0,0 +1,366 @@
+<?php
+namespace Gettext\Languages;
+
+use Exception;
+
+/**
+ * Main class to convert the plural rules of a language from CLDR to gettext.
+ */
+class Language
+{
+    /**
+     * The language ID.
+     * @var string
+     */
+    public $id;
+    /**
+     * The language name.
+     * @var string
+     */
+    public $name;
+    /**
+     * If this language is deprecated: the gettext code of the new language.
+     * @var null|string
+     */
+    public $supersededBy;
+    /**
+     * The script name.
+     * @var string|null
+     */
+    public $script;
+    /**
+     * The territory name.
+     * @var string|null
+     */
+    public $territory;
+    /**
+     * The name of the base language
+     * @var string|null
+     */
+    public $baseLanguage;
+    /**
+     * The list of categories.
+     * @var Category[]
+     */
+    public $categories;
+    /**
+     * The gettext formula to decide which category should be applied.
+     * @var string
+     */
+    public $formula;
+    /**
+     * Initialize the instance and parse the language code.
+     * @param array $info The result of CldrData::getLanguageInfo()
+     * @throws Exception Throws an Exception if $fullId is not valid.
+     */
+    private function __construct($info)
+    {
+        $this->id = $info['id'];
+        $this->name = $info['name'];
+        $this->supersededBy = isset($info['supersededBy']) ? $info['supersededBy'] : null;
+        $this->script = isset($info['script']) ? $info['script'] : null;
+        $this->territory = isset($info['territory']) ? $info['territory'] : null;
+        $this->baseLanguage = isset($info['baseLanguage']) ? $info['baseLanguage'] : null;
+        // Let's build the category list
+        $this->categories = array();
+        foreach ($info['categories'] as $cldrCategoryId => $cldrFormulaAndExamples) {
+            $category = new Category($cldrCategoryId, $cldrFormulaAndExamples);
+            foreach ($this->categories as $c) {
+                if ($category->id === $c->id) {
+                    throw new Exception("The category '{$category->id}' is specified more than once");
+                }
+            }
+            $this->categories[] = $category;
+        }
+        if (empty($this->categories)) {
+            throw new Exception("The language '$id' does not have any plural category");
+        }
+        // Let's sort the categories from 'zero' to 'other'
+        usort($this->categories, function (Category $category1, Category $category2) {
+            return array_search($category1->id, CldrData::$categories) - array_search($category2->id, CldrData::$categories);
+        });
+        // The 'other' category should always be there
+        if ($this->categories[count($this->categories) - 1]->id !== CldrData::OTHER_CATEGORY) {
+            throw new Exception("The language '$id' does not have the '".CldrData::OTHER_CATEGORY."' plural category");
+        }
+        $this->checkAlwaysTrueCategories();
+        $this->checkAlwaysFalseCategories();
+        $this->checkAllCategoriesWithExamples();
+        $this->formula = $this->buildFormula();
+    }
+    /**
+     * Return a list of all languages available.
+     * @throws Exception
+     * @return Language[]
+     */
+    public static function getAll()
+    {
+        $result = array();
+        foreach (array_keys(CldrData::getLanguageNames()) as $cldrLanguageId) {
+            $result[] = new Language(CldrData::getLanguageInfo($cldrLanguageId));
+        }
+
+        return $result;
+    }
+    /**
+     * Return a Language instance given the language id
+     * @param string $id
+     * @return Language|null
+     */
+    public static function getById($id)
+    {
+        $result = null;
+        $info = CldrData::getLanguageInfo($id);
+        if (isset($info)) {
+            $result = new Language($info);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Let's look for categories that will always occur.
+     * This because with decimals (CLDR) we may have more cases, with integers (gettext) we have just one case.
+     * If we found that (single) category we reduce the categories to that one only.
+     */
+    private function checkAlwaysTrueCategories()
+    {
+        $alwaysTrueCategory = null;
+        foreach ($this->categories as $category) {
+            if ($category->formula === true) {
+                if (!isset($category->examples)) {
+                    throw new Exception("The category '{$category->id}' should always occur, but it does not have examples (so for CLDR it will never occur for integers!)");
+                }
+                $alwaysTrueCategory = $category;
+                break;
+            }
+        }
+        if (isset($alwaysTrueCategory)) {
+            foreach ($this->categories as $category) {
+                if (($category !== $alwaysTrueCategory) && isset($category->examples)) {
+                    throw new Exception("The category '{$category->id}' should never occur, but it has some examples (so for CLDR it will occur!)");
+                }
+            }
+            $alwaysTrueCategory->id = CldrData::OTHER_CATEGORY;
+            $alwaysTrueCategory->formula = null;
+            $this->categories = array($alwaysTrueCategory);
+        }
+    }
+    /**
+     * Let's look for categories that will never occur.
+     * This because with decimals (CLDR) we may have more cases, with integers (gettext) we have some less cases.
+     * If we found those categories we strip them out.
+     */
+    private function checkAlwaysFalseCategories()
+    {
+        $filtered = array();
+        foreach ($this->categories as $category) {
+            if ($category->formula === false) {
+                if (isset($category->examples)) {
+                    throw new Exception("The category '{$category->id}' should never occur, but it has examples (so for CLDR it may occur!)");
+                }
+            } else {
+                $filtered[] = $category;
+            }
+        }
+        $this->categories = $filtered;
+    }
+    /**
+     * Let's look for categories that don't have examples.
+     * This because with decimals (CLDR) we may have more cases, with integers (gettext) we have some less cases.
+     * If we found those categories, we check that they never occur and we strip them out.
+     * @throws Exception
+     */
+    private function checkAllCategoriesWithExamples()
+    {
+        $allCategoriesIds = array();
+        $goodCategories = array();
+        $badCategories = array();
+        $badCategoriesIds = array();
+        foreach ($this->categories as $category) {
+            $allCategoriesIds[] = $category->id;
+            if (isset($category->examples)) {
+                $goodCategories[] = $category;
+            } else {
+                $badCategories[] = $category;
+                $badCategoriesIds[] = $category->id;
+            }
+        }
+        if (empty($badCategories)) {
+            return;
+        }
+        $removeCategoriesWithoutExamples = false;
+        switch (implode(',', $badCategoriesIds).'@'.implode(',', $allCategoriesIds)) {
+            case CldrData::OTHER_CATEGORY.'@one,few,many,'.CldrData::OTHER_CATEGORY:
+                switch ($this->buildFormula()) {
+                    case '(n % 10 == 1 && n % 100 != 11) ? 0 : ((n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 12 || n % 100 > 14)) ? 1 : ((n % 10 == 0 || n % 10 >= 5 && n % 10 <= 9 || n % 100 >= 11 && n % 100 <= 14) ? 2 : 3))':
+                        // Numbers ending with 0                 => case 2 ('many')
+                        // Numbers ending with 1 but not with 11 => case 0 ('one')
+                        // Numbers ending with 11                => case 2 ('many')
+                        // Numbers ending with 2 but not with 12 => case 1 ('few')
+                        // Numbers ending with 12                => case 2 ('many')
+                        // Numbers ending with 3 but not with 13 => case 1 ('few')
+                        // Numbers ending with 13                => case 2 ('many')
+                        // Numbers ending with 4 but not with 14 => case 1 ('few')
+                        // Numbers ending with 14                => case 2 ('many')
+                        // Numbers ending with 5                 => case 2 ('many')
+                        // Numbers ending with 6                 => case 2 ('many')
+                        // Numbers ending with 7                 => case 2 ('many')
+                        // Numbers ending with 8                 => case 2 ('many')
+                        // Numbers ending with 9                 => case 2 ('many')
+                        // => the 'other' case never occurs: use 'other' for 'many'
+                        $removeCategoriesWithoutExamples = true;
+                        break;
+                    case '(n == 1) ? 0 : ((n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 12 || n % 100 > 14)) ? 1 : ((n != 1 && (n % 10 == 0 || n % 10 == 1) || n % 10 >= 5 && n % 10 <= 9 || n % 100 >= 12 && n % 100 <= 14) ? 2 : 3))':
+                        // Numbers ending with 0                  => case 2 ('many')
+                        // Numbers ending with 1 but not number 1 => case 2 ('many')
+                        // Number 1                               => case 0 ('one')
+                        // Numbers ending with 2 but not with 12  => case 1 ('few')
+                        // Numbers ending with 12                 => case 2 ('many')
+                        // Numbers ending with 3 but not with 13  => case 1 ('few')
+                        // Numbers ending with 13                 => case 2 ('many')
+                        // Numbers ending with 4 but not with 14  => case 1 ('few')
+                        // Numbers ending with 14                 => case 2 ('many')
+                        // Numbers ending with 5                  => case 2 ('many')
+                        // Numbers ending with 6                  => case 2 ('many')
+                        // Numbers ending with 7                  => case 2 ('many')
+                        // Numbers ending with 8                  => case 2 ('many')
+                        // Numbers ending with 9                  => case 2 ('many')
+                        // => the 'other' case never occurs: use 'other' for 'many'
+                        $removeCategoriesWithoutExamples = true;
+                        break;
+                }
+        }
+        if (!$removeCategoriesWithoutExamples) {
+            throw new Exception("Unhandled case of plural categories without examples '".implode(', ', $badCategoriesIds)."' out of '".implode(', ', $allCategoriesIds)."'");
+        }
+        if ($badCategories[count($badCategories) - 1]->id === CldrData::OTHER_CATEGORY) {
+            // We're removing the 'other' cagory: let's change the last good category to 'other'
+            $lastGood = $goodCategories[count($goodCategories) - 1];
+            $lastGood->id = CldrData::OTHER_CATEGORY;
+            $lastGood->formula = null;
+        }
+        $this->categories = $goodCategories;
+    }
+    /**
+     * Build the formula starting from the currently defined categories.
+     * @return string
+     */
+    private function buildFormula()
+    {
+        $numCategories = count($this->categories);
+        switch ($numCategories) {
+            case 1:
+                // Just one category
+                return '0';
+            case 2:
+                return self::reduceFormula(self::reverseFormula($this->categories[0]->formula));
+            default:
+                $formula = strval($numCategories - 1);
+                for ($i = $numCategories - 2; $i >= 0; $i--) {
+                    $f = self::reduceFormula($this->categories[$i]->formula);
+                    if (!preg_match('/^\([^()]+\)$/', $f)) {
+                        $f = "($f)";
+                    }
+                    $formula = "$f ? $i : $formula";
+                    if ($i > 0) {
+                        $formula = "($formula)";
+                    }
+                }
+
+                return $formula;
+        }
+    }
+    /**
+     * Reverse a formula.
+     * @param string $formula
+     * @throws Exception
+     * @return string
+     */
+    private static function reverseFormula($formula)
+    {
+        if (preg_match('/^n( % \d+)? == \d+(\.\.\d+|,\d+)*?$/', $formula)) {
+            return str_replace(' == ', ' != ', $formula);
+        }
+        if (preg_match('/^n( % \d+)? != \d+(\.\.\d+|,\d+)*?$/', $formula)) {
+            return str_replace(' != ', ' == ', $formula);
+        }
+        if (preg_match('/^\(?n == \d+ \|\| n == \d+\)?$/', $formula)) {
+            return trim(str_replace(array(' == ', ' || '), array(' != ', ' && '), $formula), '()');
+        }
+        $m = null;
+        if (preg_match('/^(n(?: % \d+)?) == (\d+) && (n(?: % \d+)?) != (\d+)$/', $formula, $m)) {
+            return "{$m[1]} != {$m[2]} || {$m[3]} == {$m[4]}";
+        }
+        switch ($formula) {
+            case '(n == 1 || n == 2 || n == 3) || n % 10 != 4 && n % 10 != 6 && n % 10 != 9':
+                return 'n != 1 && n != 2 && n != 3 && (n % 10 == 4 || n % 10 == 6 || n % 10 == 9)';
+            case '(n == 0 || n == 1) || n >= 11 && n <= 99':
+                return 'n >= 2 && (n < 11 || n > 99)';
+        }
+        throw new Exception("Unable to reverse the formula '$formula'");
+    }
+    /**
+     * Reduce some excessively complex formulas.
+     * @param string $formula
+     * @return string
+     */
+    private static function reduceFormula($formula)
+    {
+        $map = array(
+            'n != 0 && n != 1'              =>  'n > 1' ,
+            '(n == 0 || n == 1) && n != 0'  =>  'n == 1',
+        );
+
+        return isset($map[$formula]) ? $map[$formula] : $formula;
+    }
+    /**
+     * Take one variable and, if it's a string, we transliterate it to US-ASCII.
+     * @param mixed $value The variable to work on.
+     * @throws Exception
+     */
+    private static function asciifier(&$value)
+    {
+        if (is_string($value) && ($value !== '')) {
+            // Avoid converting from 'Ÿ' to '"Y', let's prefer 'Y'
+            $transliterated = strtr($value, array(
+                'À' => 'A', 'Á' => 'A', 'Â' => 'A', 'Ã' => 'A', 'Ä' => 'A',
+                'È' => 'E', 'É' => 'E', 'Ê' => 'E', 'Ë' => 'E',
+                'Ì' => 'I', 'Í' => 'I', 'Î' => 'I', 'Ï' => 'I',
+                'Ñ' => 'N',
+                'Ò' => 'O', 'Ó' => 'O', 'Ô' => 'O', 'Õ' => 'O', 'Ö' => 'O',
+                'Ù' => 'U', 'Ú' => 'U', 'Û' => 'U', 'Ü' => 'U',
+                'Ÿ' => 'Y', 'Ý' => 'Y',
+                'à' => 'a', 'á' => 'a', 'â' => 'a', 'ã' => 'a', 'ä' => 'a',
+                'è' => 'e', 'é' => 'e', 'ê' => 'e', 'ë' => 'e',
+                'ì' => 'i', 'í' => 'i', 'î' => 'i', 'ï' => 'i',
+                'ñ' => 'n', 'ò' => 'o', 'ó' => 'o', 'ô' => 'o', 'õ' => 'o', 'ö' => 'o',
+                'ù' => 'u', 'ú' => 'u', 'û' => 'u', 'ü' => 'u',
+                'ý' => 'y', 'ÿ' => 'y',
+            ));
+            $transliterated = @iconv('UTF-8', 'US-ASCII//IGNORE//TRANSLIT', $transliterated);
+            if (($transliterated === false) || ($transliterated === '')) {
+                throw new Exception("Unable to transliterate '$value'");
+            }
+            $value = $transliterated;
+        }
+    }
+    /**
+     * Returns a clone of this instance with all the strings to US-ASCII.
+     * @return Language
+     */
+    public function getUSAsciiClone()
+    {
+        $clone = clone $this;
+        self::asciifier($clone->name);
+        self::asciifier($clone->formula);
+        $clone->categories = array();
+        foreach ($this->categories as $category) {
+            $categoryClone = clone $category;
+            self::asciifier($categoryClone->examples);
+            $clone->categories[] = $categoryClone;
+        }
+
+        return $clone;
+    }
+}

lib/composer/vendor/gettext/languages/src/autoloader.php

@@ -0,0 +1,12 @@
+<?php
+spl_autoload_register(
+    function ($class) {
+        if (strpos($class, 'Gettext\\Languages\\') !== 0) {
+            return;
+        }
+        $file = __DIR__.str_replace('\\', DIRECTORY_SEPARATOR, substr($class, strlen('Gettext\\Languages'))).'.php';
+        if (is_file($file)) {
+            require_once $file;
+        }
+    }
+);

lib/composer/vendor/gettext/languages/src/cldr-data/main/en-US/languages.json

@@ -0,0 +1,636 @@
+{
+  "main": {
+    "en-US": {
+      "identity": {
+        "version": {
+          "_cldrVersion": "27",
+          "_number": "$Revision: 10669 $"
+        },
+        "generation": {
+          "_date": "$Date: 2014-07-23 16:10:33 -0500 (Wed, 23 Jul 2014) $"
+        },
+        "language": "en",
+        "territory": "US"
+      },
+      "localeDisplayNames": {
+        "languages": {
+          "aa": "Afar",
+          "ab": "Abkhazian",
+          "ace": "Achinese",
+          "ach": "Acoli",
+          "ada": "Adangme",
+          "ady": "Adyghe",
+          "ae": "Avestan",
+          "aeb": "Tunisian Arabic",
+          "af": "Afrikaans",
+          "afh": "Afrihili",
+          "agq": "Aghem",
+          "ain": "Ainu",
+          "ak": "Akan",
+          "akk": "Akkadian",
+          "akz": "Alabama",
+          "ale": "Aleut",
+          "aln": "Gheg Albanian",
+          "alt": "Southern Altai",
+          "am": "Amharic",
+          "an": "Aragonese",
+          "ang": "Old English",
+          "anp": "Angika",
+          "ar": "Arabic",
+          "ar-001": "Modern Standard Arabic",
+          "arc": "Aramaic",
+          "arn": "Mapuche",
+          "aro": "Araona",
+          "arp": "Arapaho",
+          "arq": "Algerian Arabic",
+          "arw": "Arawak",
+          "ary": "Moroccan Arabic",
+          "arz": "Egyptian Arabic",
+          "as": "Assamese",
+          "asa": "Asu",
+          "ase": "American Sign Language",
+          "ast": "Asturian",
+          "av": "Avaric",
+          "avk": "Kotava",
+          "awa": "Awadhi",
+          "ay": "Aymara",
+          "az": "Azerbaijani",
+          "az-alt-short": "Azeri",
+          "azb": "South Azerbaijani",
+          "ba": "Bashkir",
+          "bal": "Baluchi",
+          "ban": "Balinese",
+          "bar": "Bavarian",
+          "bas": "Basaa",
+          "bax": "Bamun",
+          "bbc": "Batak Toba",
+          "bbj": "Ghomala",
+          "be": "Belarusian",
+          "bej": "Beja",
+          "bem": "Bemba",
+          "bew": "Betawi",
+          "bez": "Bena",
+          "bfd": "Bafut",
+          "bfq": "Badaga",
+          "bg": "Bulgarian",
+          "bho": "Bhojpuri",
+          "bi": "Bislama",
+          "bik": "Bikol",
+          "bin": "Bini",
+          "bjn": "Banjar",
+          "bkm": "Kom",
+          "bla": "Siksika",
+          "bm": "Bambara",
+          "bn": "Bengali",
+          "bo": "Tibetan",
+          "bpy": "Bishnupriya",
+          "bqi": "Bakhtiari",
+          "br": "Breton",
+          "bra": "Braj",
+          "brh": "Brahui",
+          "brx": "Bodo",
+          "bs": "Bosnian",
+          "bss": "Akoose",
+          "bua": "Buriat",
+          "bug": "Buginese",
+          "bum": "Bulu",
+          "byn": "Blin",
+          "byv": "Medumba",
+          "ca": "Catalan",
+          "cad": "Caddo",
+          "car": "Carib",
+          "cay": "Cayuga",
+          "cch": "Atsam",
+          "ce": "Chechen",
+          "ceb": "Cebuano",
+          "cgg": "Chiga",
+          "ch": "Chamorro",
+          "chb": "Chibcha",
+          "chg": "Chagatai",
+          "chk": "Chuukese",
+          "chm": "Mari",
+          "chn": "Chinook Jargon",
+          "cho": "Choctaw",
+          "chp": "Chipewyan",
+          "chr": "Cherokee",
+          "chy": "Cheyenne",
+          "ckb": "Central Kurdish",
+          "co": "Corsican",
+          "cop": "Coptic",
+          "cps": "Capiznon",
+          "cr": "Cree",
+          "crh": "Crimean Turkish",
+          "cs": "Czech",
+          "csb": "Kashubian",
+          "cu": "Church Slavic",
+          "cv": "Chuvash",
+          "cy": "Welsh",
+          "da": "Danish",
+          "dak": "Dakota",
+          "dar": "Dargwa",
+          "dav": "Taita",
+          "de": "German",
+          "de-AT": "Austrian German",
+          "de-CH": "Swiss High German",
+          "del": "Delaware",
+          "den": "Slave",
+          "dgr": "Dogrib",
+          "din": "Dinka",
+          "dje": "Zarma",
+          "doi": "Dogri",
+          "dsb": "Lower Sorbian",
+          "dtp": "Central Dusun",
+          "dua": "Duala",
+          "dum": "Middle Dutch",
+          "dv": "Divehi",
+          "dyo": "Jola-Fonyi",
+          "dyu": "Dyula",
+          "dz": "Dzongkha",
+          "dzg": "Dazaga",
+          "ebu": "Embu",
+          "ee": "Ewe",
+          "efi": "Efik",
+          "egl": "Emilian",
+          "egy": "Ancient Egyptian",
+          "eka": "Ekajuk",
+          "el": "Greek",
+          "elx": "Elamite",
+          "en": "English",
+          "en-AU": "Australian English",
+          "en-CA": "Canadian English",
+          "en-GB": "British English",
+          "en-GB-alt-short": "UK English",
+          "en-US": "American English",
+          "en-US-alt-short": "US English",
+          "enm": "Middle English",
+          "eo": "Esperanto",
+          "es": "Spanish",
+          "es-419": "Latin American Spanish",
+          "es-ES": "European Spanish",
+          "es-MX": "Mexican Spanish",
+          "esu": "Central Yupik",
+          "et": "Estonian",
+          "eu": "Basque",
+          "ewo": "Ewondo",
+          "ext": "Extremaduran",
+          "fa": "Persian",
+          "fan": "Fang",
+          "fat": "Fanti",
+          "ff": "Fulah",
+          "fi": "Finnish",
+          "fil": "Filipino",
+          "fit": "Tornedalen Finnish",
+          "fj": "Fijian",
+          "fo": "Faroese",
+          "fon": "Fon",
+          "fr": "French",
+          "fr-CA": "Canadian French",
+          "fr-CH": "Swiss French",
+          "frc": "Cajun French",
+          "frm": "Middle French",
+          "fro": "Old French",
+          "frp": "Arpitan",
+          "frr": "Northern Frisian",
+          "frs": "Eastern Frisian",
+          "fur": "Friulian",
+          "fy": "Western Frisian",
+          "ga": "Irish",
+          "gaa": "Ga",
+          "gag": "Gagauz",
+          "gan": "Gan Chinese",
+          "gay": "Gayo",
+          "gba": "Gbaya",
+          "gbz": "Zoroastrian Dari",
+          "gd": "Scottish Gaelic",
+          "gez": "Geez",
+          "gil": "Gilbertese",
+          "gl": "Galician",
+          "glk": "Gilaki",
+          "gmh": "Middle High German",
+          "gn": "Guarani",
+          "goh": "Old High German",
+          "gom": "Goan Konkani",
+          "gon": "Gondi",
+          "gor": "Gorontalo",
+          "got": "Gothic",
+          "grb": "Grebo",
+          "grc": "Ancient Greek",
+          "gsw": "Swiss German",
+          "gu": "Gujarati",
+          "guc": "Wayuu",
+          "gur": "Frafra",
+          "guz": "Gusii",
+          "gv": "Manx",
+          "gwi": "Gwichʼin",
+          "ha": "Hausa",
+          "hai": "Haida",
+          "hak": "Hakka Chinese",
+          "haw": "Hawaiian",
+          "he": "Hebrew",
+          "hi": "Hindi",
+          "hif": "Fiji Hindi",
+          "hil": "Hiligaynon",
+          "hit": "Hittite",
+          "hmn": "Hmong",
+          "ho": "Hiri Motu",
+          "hr": "Croatian",
+          "hsb": "Upper Sorbian",
+          "hsn": "Xiang Chinese",
+          "ht": "Haitian",
+          "hu": "Hungarian",
+          "hup": "Hupa",
+          "hy": "Armenian",
+          "hz": "Herero",
+          "ia": "Interlingua",
+          "iba": "Iban",
+          "ibb": "Ibibio",
+          "id": "Indonesian",
+          "ie": "Interlingue",
+          "ig": "Igbo",
+          "ii": "Sichuan Yi",
+          "ik": "Inupiaq",
+          "ilo": "Iloko",
+          "inh": "Ingush",
+          "io": "Ido",
+          "is": "Icelandic",
+          "it": "Italian",
+          "iu": "Inuktitut",
+          "izh": "Ingrian",
+          "ja": "Japanese",
+          "jam": "Jamaican Creole English",
+          "jbo": "Lojban",
+          "jgo": "Ngomba",
+          "jmc": "Machame",
+          "jpr": "Judeo-Persian",
+          "jrb": "Judeo-Arabic",
+          "jut": "Jutish",
+          "jv": "Javanese",
+          "ka": "Georgian",
+          "kaa": "Kara-Kalpak",
+          "kab": "Kabyle",
+          "kac": "Kachin",
+          "kaj": "Jju",
+          "kam": "Kamba",
+          "kaw": "Kawi",
+          "kbd": "Kabardian",
+          "kbl": "Kanembu",
+          "kcg": "Tyap",
+          "kde": "Makonde",
+          "kea": "Kabuverdianu",
+          "ken": "Kenyang",
+          "kfo": "Koro",
+          "kg": "Kongo",
+          "kgp": "Kaingang",
+          "kha": "Khasi",
+          "kho": "Khotanese",
+          "khq": "Koyra Chiini",
+          "khw": "Khowar",
+          "ki": "Kikuyu",
+          "kiu": "Kirmanjki",
+          "kj": "Kuanyama",
+          "kk": "Kazakh",
+          "kkj": "Kako",
+          "kl": "Kalaallisut",
+          "kln": "Kalenjin",
+          "km": "Khmer",
+          "kmb": "Kimbundu",
+          "kn": "Kannada",
+          "ko": "Korean",
+          "koi": "Komi-Permyak",
+          "kok": "Konkani",
+          "kos": "Kosraean",
+          "kpe": "Kpelle",
+          "kr": "Kanuri",
+          "krc": "Karachay-Balkar",
+          "kri": "Krio",
+          "krj": "Kinaray-a",
+          "krl": "Karelian",
+          "kru": "Kurukh",
+          "ks": "Kashmiri",
+          "ksb": "Shambala",
+          "ksf": "Bafia",
+          "ksh": "Colognian",
+          "ku": "Kurdish",
+          "kum": "Kumyk",
+          "kut": "Kutenai",
+          "kv": "Komi",
+          "kw": "Cornish",
+          "ky": "Kyrgyz",
+          "ky-alt-variant": "Kirghiz",
+          "la": "Latin",
+          "lad": "Ladino",
+          "lag": "Langi",
+          "lah": "Lahnda",
+          "lam": "Lamba",
+          "lb": "Luxembourgish",
+          "lez": "Lezghian",
+          "lfn": "Lingua Franca Nova",
+          "lg": "Ganda",
+          "li": "Limburgish",
+          "lij": "Ligurian",
+          "liv": "Livonian",
+          "lkt": "Lakota",
+          "lmo": "Lombard",
+          "ln": "Lingala",
+          "lo": "Lao",
+          "lol": "Mongo",
+          "loz": "Lozi",
+          "lt": "Lithuanian",
+          "ltg": "Latgalian",
+          "lu": "Luba-Katanga",
+          "lua": "Luba-Lulua",
+          "lui": "Luiseno",
+          "lun": "Lunda",
+          "luo": "Luo",
+          "lus": "Mizo",
+          "luy": "Luyia",
+          "lv": "Latvian",
+          "lzh": "Literary Chinese",
+          "lzz": "Laz",
+          "mad": "Madurese",
+          "maf": "Mafa",
+          "mag": "Magahi",
+          "mai": "Maithili",
+          "mak": "Makasar",
+          "man": "Mandingo",
+          "mas": "Masai",
+          "mde": "Maba",
+          "mdf": "Moksha",
+          "mdr": "Mandar",
+          "men": "Mende",
+          "mer": "Meru",
+          "mfe": "Morisyen",
+          "mg": "Malagasy",
+          "mga": "Middle Irish",
+          "mgh": "Makhuwa-Meetto",
+          "mgo": "Metaʼ",
+          "mh": "Marshallese",
+          "mi": "Maori",
+          "mic": "Micmac",
+          "min": "Minangkabau",
+          "mk": "Macedonian",
+          "ml": "Malayalam",
+          "mn": "Mongolian",
+          "mnc": "Manchu",
+          "mni": "Manipuri",
+          "moh": "Mohawk",
+          "mos": "Mossi",
+          "mr": "Marathi",
+          "mrj": "Western Mari",
+          "ms": "Malay",
+          "mt": "Maltese",
+          "mua": "Mundang",
+          "mul": "Multiple Languages",
+          "mus": "Creek",
+          "mwl": "Mirandese",
+          "mwr": "Marwari",
+          "mwv": "Mentawai",
+          "my": "Burmese",
+          "mye": "Myene",
+          "myv": "Erzya",
+          "mzn": "Mazanderani",
+          "na": "Nauru",
+          "nan": "Min Nan Chinese",
+          "nap": "Neapolitan",
+          "naq": "Nama",
+          "nb": "Norwegian Bokmål",
+          "nd": "North Ndebele",
+          "nds": "Low German",
+          "ne": "Nepali",
+          "new": "Newari",
+          "ng": "Ndonga",
+          "nia": "Nias",
+          "niu": "Niuean",
+          "njo": "Ao Naga",
+          "nl": "Dutch",
+          "nl-BE": "Flemish",
+          "nmg": "Kwasio",
+          "nn": "Norwegian Nynorsk",
+          "nnh": "Ngiemboon",
+          "no": "Norwegian",
+          "nog": "Nogai",
+          "non": "Old Norse",
+          "nov": "Novial",
+          "nqo": "NʼKo",
+          "nr": "South Ndebele",
+          "nso": "Northern Sotho",
+          "nus": "Nuer",
+          "nv": "Navajo",
+          "nwc": "Classical Newari",
+          "ny": "Nyanja",
+          "nym": "Nyamwezi",
+          "nyn": "Nyankole",
+          "nyo": "Nyoro",
+          "nzi": "Nzima",
+          "oc": "Occitan",
+          "oj": "Ojibwa",
+          "om": "Oromo",
+          "or": "Oriya",
+          "os": "Ossetic",
+          "osa": "Osage",
+          "ota": "Ottoman Turkish",
+          "pa": "Punjabi",
+          "pag": "Pangasinan",
+          "pal": "Pahlavi",
+          "pam": "Pampanga",
+          "pap": "Papiamento",
+          "pau": "Palauan",
+          "pcd": "Picard",
+          "pdc": "Pennsylvania German",
+          "pdt": "Plautdietsch",
+          "peo": "Old Persian",
+          "pfl": "Palatine German",
+          "phn": "Phoenician",
+          "pi": "Pali",
+          "pl": "Polish",
+          "pms": "Piedmontese",
+          "pnt": "Pontic",
+          "pon": "Pohnpeian",
+          "prg": "Prussian",
+          "pro": "Old Provençal",
+          "ps": "Pashto",
+          "ps-alt-variant": "Pushto",
+          "pt": "Portuguese",
+          "pt-BR": "Brazilian Portuguese",
+          "pt-PT": "European Portuguese",
+          "qu": "Quechua",
+          "quc": "Kʼicheʼ",
+          "qug": "Chimborazo Highland Quichua",
+          "raj": "Rajasthani",
+          "rap": "Rapanui",
+          "rar": "Rarotongan",
+          "rgn": "Romagnol",
+          "rif": "Riffian",
+          "rm": "Romansh",
+          "rn": "Rundi",
+          "ro": "Romanian",
+          "ro-MD": "Moldavian",
+          "rof": "Rombo",
+          "rom": "Romany",
+          "root": "Root",
+          "rtm": "Rotuman",
+          "ru": "Russian",
+          "rue": "Rusyn",
+          "rug": "Roviana",
+          "rup": "Aromanian",
+          "rw": "Kinyarwanda",
+          "rwk": "Rwa",
+          "sa": "Sanskrit",
+          "sad": "Sandawe",
+          "sah": "Sakha",
+          "sam": "Samaritan Aramaic",
+          "saq": "Samburu",
+          "sas": "Sasak",
+          "sat": "Santali",
+          "saz": "Saurashtra",
+          "sba": "Ngambay",
+          "sbp": "Sangu",
+          "sc": "Sardinian",
+          "scn": "Sicilian",
+          "sco": "Scots",
+          "sd": "Sindhi",
+          "sdc": "Sassarese Sardinian",
+          "se": "Northern Sami",
+          "see": "Seneca",
+          "seh": "Sena",
+          "sei": "Seri",
+          "sel": "Selkup",
+          "ses": "Koyraboro Senni",
+          "sg": "Sango",
+          "sga": "Old Irish",
+          "sgs": "Samogitian",
+          "sh": "Serbo-Croatian",
+          "shi": "Tachelhit",
+          "shn": "Shan",
+          "shu": "Chadian Arabic",
+          "si": "Sinhala",
+          "sid": "Sidamo",
+          "sk": "Slovak",
+          "sl": "Slovenian",
+          "sli": "Lower Silesian",
+          "sly": "Selayar",
+          "sm": "Samoan",
+          "sma": "Southern Sami",
+          "smj": "Lule Sami",
+          "smn": "Inari Sami",
+          "sms": "Skolt Sami",
+          "sn": "Shona",
+          "snk": "Soninke",
+          "so": "Somali",
+          "sog": "Sogdien",
+          "sq": "Albanian",
+          "sr": "Serbian",
+          "srn": "Sranan Tongo",
+          "srr": "Serer",
+          "ss": "Swati",
+          "ssy": "Saho",
+          "st": "Southern Sotho",
+          "stq": "Saterland Frisian",
+          "su": "Sundanese",
+          "suk": "Sukuma",
+          "sus": "Susu",
+          "sux": "Sumerian",
+          "sv": "Swedish",
+          "sw": "Swahili",
+          "swb": "Comorian",
+          "swc": "Congo Swahili",
+          "syc": "Classical Syriac",
+          "syr": "Syriac",
+          "szl": "Silesian",
+          "ta": "Tamil",
+          "tcy": "Tulu",
+          "te": "Telugu",
+          "tem": "Timne",
+          "teo": "Teso",
+          "ter": "Tereno",
+          "tet": "Tetum",
+          "tg": "Tajik",
+          "th": "Thai",
+          "ti": "Tigrinya",
+          "tig": "Tigre",
+          "tiv": "Tiv",
+          "tk": "Turkmen",
+          "tkl": "Tokelau",
+          "tkr": "Tsakhur",
+          "tl": "Tagalog",
+          "tlh": "Klingon",
+          "tli": "Tlingit",
+          "tly": "Talysh",
+          "tmh": "Tamashek",
+          "tn": "Tswana",
+          "to": "Tongan",
+          "tog": "Nyasa Tonga",
+          "tpi": "Tok Pisin",
+          "tr": "Turkish",
+          "tru": "Turoyo",
+          "trv": "Taroko",
+          "ts": "Tsonga",
+          "tsd": "Tsakonian",
+          "tsi": "Tsimshian",
+          "tt": "Tatar",
+          "ttt": "Muslim Tat",
+          "tum": "Tumbuka",
+          "tvl": "Tuvalu",
+          "tw": "Twi",
+          "twq": "Tasawaq",
+          "ty": "Tahitian",
+          "tyv": "Tuvinian",
+          "tzm": "Central Atlas Tamazight",
+          "udm": "Udmurt",
+          "ug": "Uyghur",
+          "ug-alt-variant": "Uighur",
+          "uga": "Ugaritic",
+          "uk": "Ukrainian",
+          "umb": "Umbundu",
+          "und": "Unknown Language",
+          "ur": "Urdu",
+          "uz": "Uzbek",
+          "vai": "Vai",
+          "ve": "Venda",
+          "vec": "Venetian",
+          "vep": "Veps",
+          "vi": "Vietnamese",
+          "vls": "West Flemish",
+          "vmf": "Main-Franconian",
+          "vo": "Volapük",
+          "vot": "Votic",
+          "vro": "Võro",
+          "vun": "Vunjo",
+          "wa": "Walloon",
+          "wae": "Walser",
+          "wal": "Wolaytta",
+          "war": "Waray",
+          "was": "Washo",
+          "wbp": "Warlpiri",
+          "wo": "Wolof",
+          "wuu": "Wu Chinese",
+          "xal": "Kalmyk",
+          "xh": "Xhosa",
+          "xmf": "Mingrelian",
+          "xog": "Soga",
+          "yao": "Yao",
+          "yap": "Yapese",
+          "yav": "Yangben",
+          "ybb": "Yemba",
+          "yi": "Yiddish",
+          "yo": "Yoruba",
+          "yrl": "Nheengatu",
+          "yue": "Cantonese",
+          "za": "Zhuang",
+          "zap": "Zapotec",
+          "zbl": "Blissymbols",
+          "zea": "Zeelandic",
+          "zen": "Zenaga",
+          "zgh": "Standard Moroccan Tamazight",
+          "zh": "Chinese",
+          "zh-Hans": "Simplified Chinese",
+          "zh-Hant": "Traditional Chinese",
+          "zu": "Zulu",
+          "zun": "Zuni",
+          "zxx": "No linguistic content",
+          "zza": "Zaza"
+        }
+      }
+    }
+  }
+}

lib/composer/vendor/gettext/languages/src/cldr-data/main/en-US/scripts.json

@@ -0,0 +1,239 @@
+{
+  "main": {
+    "en-US": {
+      "identity": {
+        "version": {
+          "_cldrVersion": "27",
+          "_number": "$Revision: 10669 $"
+        },
+        "generation": {
+          "_date": "$Date: 2014-07-23 16:10:33 -0500 (Wed, 23 Jul 2014) $"
+        },
+        "language": "en",
+        "territory": "US"
+      },
+      "localeDisplayNames": {
+        "scripts": {
+          "Afak": "Afaka",
+          "Aghb": "Caucasian Albanian",
+          "Arab": "Arabic",
+          "Arab-alt-variant": "Perso-Arabic",
+          "Armi": "Imperial Aramaic",
+          "Armn": "Armenian",
+          "Avst": "Avestan",
+          "Bali": "Balinese",
+          "Bamu": "Bamum",
+          "Bass": "Bassa Vah",
+          "Batk": "Batak",
+          "Beng": "Bengali",
+          "Blis": "Blissymbols",
+          "Bopo": "Bopomofo",
+          "Brah": "Brahmi",
+          "Brai": "Braille",
+          "Bugi": "Buginese",
+          "Buhd": "Buhid",
+          "Cakm": "Chakma",
+          "Cans": "Unified Canadian Aboriginal Syllabics",
+          "Cans-alt-short": "UCAS",
+          "Cari": "Carian",
+          "Cham": "Cham",
+          "Cher": "Cherokee",
+          "Cirt": "Cirth",
+          "Copt": "Coptic",
+          "Cprt": "Cypriot",
+          "Cyrl": "Cyrillic",
+          "Cyrs": "Old Church Slavonic Cyrillic",
+          "Deva": "Devanagari",
+          "Dsrt": "Deseret",
+          "Dupl": "Duployan shorthand",
+          "Egyd": "Egyptian demotic",
+          "Egyh": "Egyptian hieratic",
+          "Egyp": "Egyptian hieroglyphs",
+          "Elba": "Elbasan",
+          "Ethi": "Ethiopic",
+          "Geok": "Georgian Khutsuri",
+          "Geor": "Georgian",
+          "Glag": "Glagolitic",
+          "Goth": "Gothic",
+          "Gran": "Grantha",
+          "Grek": "Greek",
+          "Gujr": "Gujarati",
+          "Guru": "Gurmukhi",
+          "Hang": "Hangul",
+          "Hani": "Han",
+          "Hano": "Hanunoo",
+          "Hans": "Simplified",
+          "Hans-alt-stand-alone": "Simplified Han",
+          "Hant": "Traditional",
+          "Hant-alt-stand-alone": "Traditional Han",
+          "Hebr": "Hebrew",
+          "Hira": "Hiragana",
+          "Hluw": "Anatolian Hieroglyphs",
+          "Hmng": "Pahawh Hmong",
+          "Hrkt": "Japanese syllabaries",
+          "Hung": "Old Hungarian",
+          "Inds": "Indus",
+          "Ital": "Old Italic",
+          "Java": "Javanese",
+          "Jpan": "Japanese",
+          "Jurc": "Jurchen",
+          "Kali": "Kayah Li",
+          "Kana": "Katakana",
+          "Khar": "Kharoshthi",
+          "Khmr": "Khmer",
+          "Khoj": "Khojki",
+          "Knda": "Kannada",
+          "Kore": "Korean",
+          "Kpel": "Kpelle",
+          "Kthi": "Kaithi",
+          "Lana": "Lanna",
+          "Laoo": "Lao",
+          "Latf": "Fraktur Latin",
+          "Latg": "Gaelic Latin",
+          "Latn": "Latin",
+          "Lepc": "Lepcha",
+          "Limb": "Limbu",
+          "Lina": "Linear A",
+          "Linb": "Linear B",
+          "Lisu": "Fraser",
+          "Loma": "Loma",
+          "Lyci": "Lycian",
+          "Lydi": "Lydian",
+          "Mahj": "Mahajani",
+          "Mand": "Mandaean",
+          "Mani": "Manichaean",
+          "Maya": "Mayan hieroglyphs",
+          "Mend": "Mende",
+          "Merc": "Meroitic Cursive",
+          "Mero": "Meroitic",
+          "Mlym": "Malayalam",
+          "Modi": "Modi",
+          "Mong": "Mongolian",
+          "Moon": "Moon",
+          "Mroo": "Mro",
+          "Mtei": "Meitei Mayek",
+          "Mymr": "Myanmar",
+          "Narb": "Old North Arabian",
+          "Nbat": "Nabataean",
+          "Nkgb": "Naxi Geba",
+          "Nkoo": "N’Ko",
+          "Nshu": "Nüshu",
+          "Ogam": "Ogham",
+          "Olck": "Ol Chiki",
+          "Orkh": "Orkhon",
+          "Orya": "Oriya",
+          "Osma": "Osmanya",
+          "Palm": "Palmyrene",
+          "Pauc": "Pau Cin Hau",
+          "Perm": "Old Permic",
+          "Phag": "Phags-pa",
+          "Phli": "Inscriptional Pahlavi",
+          "Phlp": "Psalter Pahlavi",
+          "Phlv": "Book Pahlavi",
+          "Phnx": "Phoenician",
+          "Plrd": "Pollard Phonetic",
+          "Prti": "Inscriptional Parthian",
+          "Qaaa": "Qaaa",
+          "Qaab": "Qaab",
+          "Qaac": "Qaac",
+          "Qaad": "Qaad",
+          "Qaae": "Qaae",
+          "Qaaf": "Qaaf",
+          "Qaag": "Qaag",
+          "Qaah": "Qaah",
+          "Qaaj": "Qaaj",
+          "Qaak": "Qaak",
+          "Qaal": "Qaal",
+          "Qaam": "Qaam",
+          "Qaan": "Qaan",
+          "Qaao": "Qaao",
+          "Qaap": "Qaap",
+          "Qaaq": "Qaaq",
+          "Qaar": "Qaar",
+          "Qaas": "Qaas",
+          "Qaat": "Qaat",
+          "Qaau": "Qaau",
+          "Qaav": "Qaav",
+          "Qaaw": "Qaaw",
+          "Qaax": "Qaax",
+          "Qaay": "Qaay",
+          "Qaaz": "Qaaz",
+          "Qaba": "Qaba",
+          "Qabb": "Qabb",
+          "Qabc": "Qabc",
+          "Qabd": "Qabd",
+          "Qabe": "Qabe",
+          "Qabf": "Qabf",
+          "Qabg": "Qabg",
+          "Qabh": "Qabh",
+          "Qabi": "Qabi",
+          "Qabj": "Qabj",
+          "Qabk": "Qabk",
+          "Qabl": "Qabl",
+          "Qabm": "Qabm",
+          "Qabn": "Qabn",
+          "Qabo": "Qabo",
+          "Qabp": "Qabp",
+          "Qabq": "Qabq",
+          "Qabr": "Qabr",
+          "Qabs": "Qabs",
+          "Qabt": "Qabt",
+          "Qabu": "Qabu",
+          "Qabv": "Qabv",
+          "Qabw": "Qabw",
+          "Qabx": "Qabx",
+          "Rjng": "Rejang",
+          "Roro": "Rongorongo",
+          "Runr": "Runic",
+          "Samr": "Samaritan",
+          "Sara": "Sarati",
+          "Sarb": "Old South Arabian",
+          "Saur": "Saurashtra",
+          "Sgnw": "SignWriting",
+          "Shaw": "Shavian",
+          "Shrd": "Sharada",
+          "Sidd": "Siddham",
+          "Sind": "Khudawadi",
+          "Sinh": "Sinhala",
+          "Sora": "Sora Sompeng",
+          "Sund": "Sundanese",
+          "Sylo": "Syloti Nagri",
+          "Syrc": "Syriac",
+          "Syre": "Estrangelo Syriac",
+          "Syrj": "Western Syriac",
+          "Syrn": "Eastern Syriac",
+          "Tagb": "Tagbanwa",
+          "Takr": "Takri",
+          "Tale": "Tai Le",
+          "Talu": "New Tai Lue",
+          "Taml": "Tamil",
+          "Tang": "Tangut",
+          "Tavt": "Tai Viet",
+          "Telu": "Telugu",
+          "Teng": "Tengwar",
+          "Tfng": "Tifinagh",
+          "Tglg": "Tagalog",
+          "Thaa": "Thaana",
+          "Thai": "Thai",
+          "Tibt": "Tibetan",
+          "Tirh": "Tirhuta",
+          "Ugar": "Ugaritic",
+          "Vaii": "Vai",
+          "Visp": "Visible Speech",
+          "Wara": "Varang Kshiti",
+          "Wole": "Woleai",
+          "Xpeo": "Old Persian",
+          "Xsux": "Sumero-Akkadian Cuneiform",
+          "Xsux-alt-short": "S-A Cuneiform",
+          "Yiii": "Yi",
+          "Zinh": "Inherited",
+          "Zmth": "Mathematical Notation",
+          "Zsym": "Symbols",
+          "Zxxx": "Unwritten",
+          "Zyyy": "Common",
+          "Zzzz": "Unknown Script"
+        }
+      }
+    }
+  }
+}

lib/composer/vendor/gettext/languages/src/cldr-data/main/en-US/territories.json

@@ -0,0 +1,324 @@
+{
+  "main": {
+    "en-US": {
+      "identity": {
+        "version": {
+          "_cldrVersion": "27",
+          "_number": "$Revision: 10669 $"
+        },
+        "generation": {
+          "_date": "$Date: 2014-07-23 16:10:33 -0500 (Wed, 23 Jul 2014) $"
+        },
+        "language": "en",
+        "territory": "US"
+      },
+      "localeDisplayNames": {
+        "territories": {
+          "001": "World",
+          "002": "Africa",
+          "003": "North America",
+          "005": "South America",
+          "009": "Oceania",
+          "011": "Western Africa",
+          "013": "Central America",
+          "014": "Eastern Africa",
+          "015": "Northern Africa",
+          "017": "Middle Africa",
+          "018": "Southern Africa",
+          "019": "Americas",
+          "021": "Northern America",
+          "029": "Caribbean",
+          "030": "Eastern Asia",
+          "034": "Southern Asia",
+          "035": "Southeast Asia",
+          "039": "Southern Europe",
+          "053": "Australasia",
+          "054": "Melanesia",
+          "057": "Micronesian Region",
+          "061": "Polynesia",
+          "142": "Asia",
+          "143": "Central Asia",
+          "145": "Western Asia",
+          "150": "Europe",
+          "151": "Eastern Europe",
+          "154": "Northern Europe",
+          "155": "Western Europe",
+          "419": "Latin America",
+          "AC": "Ascension Island",
+          "AD": "Andorra",
+          "AE": "United Arab Emirates",
+          "AF": "Afghanistan",
+          "AG": "Antigua & Barbuda",
+          "AI": "Anguilla",
+          "AL": "Albania",
+          "AM": "Armenia",
+          "AN": "Netherlands Antilles",
+          "AO": "Angola",
+          "AQ": "Antarctica",
+          "AR": "Argentina",
+          "AS": "American Samoa",
+          "AT": "Austria",
+          "AU": "Australia",
+          "AW": "Aruba",
+          "AX": "Åland Islands",
+          "AZ": "Azerbaijan",
+          "BA": "Bosnia & Herzegovina",
+          "BA-alt-short": "Bosnia",
+          "BB": "Barbados",
+          "BD": "Bangladesh",
+          "BE": "Belgium",
+          "BF": "Burkina Faso",
+          "BG": "Bulgaria",
+          "BH": "Bahrain",
+          "BI": "Burundi",
+          "BJ": "Benin",
+          "BL": "St. Barthélemy",
+          "BM": "Bermuda",
+          "BN": "Brunei",
+          "BO": "Bolivia",
+          "BQ": "Caribbean Netherlands",
+          "BR": "Brazil",
+          "BS": "Bahamas",
+          "BT": "Bhutan",
+          "BV": "Bouvet Island",
+          "BW": "Botswana",
+          "BY": "Belarus",
+          "BZ": "Belize",
+          "CA": "Canada",
+          "CC": "Cocos (Keeling) Islands",
+          "CD": "Congo - Kinshasa",
+          "CD-alt-variant": "Congo (DRC)",
+          "CF": "Central African Republic",
+          "CG": "Congo - Brazzaville",
+          "CG-alt-variant": "Congo (Republic)",
+          "CH": "Switzerland",
+          "CI": "Côte d’Ivoire",
+          "CI-alt-variant": "Ivory Coast",
+          "CK": "Cook Islands",
+          "CL": "Chile",
+          "CM": "Cameroon",
+          "CN": "China",
+          "CO": "Colombia",
+          "CP": "Clipperton Island",
+          "CR": "Costa Rica",
+          "CU": "Cuba",
+          "CV": "Cape Verde",
+          "CW": "Curaçao",
+          "CX": "Christmas Island",
+          "CY": "Cyprus",
+          "CZ": "Czech Republic",
+          "DE": "Germany",
+          "DG": "Diego Garcia",
+          "DJ": "Djibouti",
+          "DK": "Denmark",
+          "DM": "Dominica",
+          "DO": "Dominican Republic",
+          "DZ": "Algeria",
+          "EA": "Ceuta & Melilla",
+          "EC": "Ecuador",
+          "EE": "Estonia",
+          "EG": "Egypt",
+          "EH": "Western Sahara",
+          "ER": "Eritrea",
+          "ES": "Spain",
+          "ET": "Ethiopia",
+          "EU": "European Union",
+          "FI": "Finland",
+          "FJ": "Fiji",
+          "FK": "Falkland Islands",
+          "FK-alt-variant": "Falkland Islands (Islas Malvinas)",
+          "FM": "Micronesia",
+          "FO": "Faroe Islands",
+          "FR": "France",
+          "GA": "Gabon",
+          "GB": "United Kingdom",
+          "GB-alt-short": "UK",
+          "GD": "Grenada",
+          "GE": "Georgia",
+          "GF": "French Guiana",
+          "GG": "Guernsey",
+          "GH": "Ghana",
+          "GI": "Gibraltar",
+          "GL": "Greenland",
+          "GM": "Gambia",
+          "GN": "Guinea",
+          "GP": "Guadeloupe",
+          "GQ": "Equatorial Guinea",
+          "GR": "Greece",
+          "GS": "South Georgia & South Sandwich Islands",
+          "GT": "Guatemala",
+          "GU": "Guam",
+          "GW": "Guinea-Bissau",
+          "GY": "Guyana",
+          "HK": "Hong Kong SAR China",
+          "HK-alt-short": "Hong Kong",
+          "HM": "Heard & McDonald Islands",
+          "HN": "Honduras",
+          "HR": "Croatia",
+          "HT": "Haiti",
+          "HU": "Hungary",
+          "IC": "Canary Islands",
+          "ID": "Indonesia",
+          "IE": "Ireland",
+          "IL": "Israel",
+          "IM": "Isle of Man",
+          "IN": "India",
+          "IO": "British Indian Ocean Territory",
+          "IQ": "Iraq",
+          "IR": "Iran",
+          "IS": "Iceland",
+          "IT": "Italy",
+          "JE": "Jersey",
+          "JM": "Jamaica",
+          "JO": "Jordan",
+          "JP": "Japan",
+          "KE": "Kenya",
+          "KG": "Kyrgyzstan",
+          "KH": "Cambodia",
+          "KI": "Kiribati",
+          "KM": "Comoros",
+          "KN": "St. Kitts & Nevis",
+          "KP": "North Korea",
+          "KR": "South Korea",
+          "KW": "Kuwait",
+          "KY": "Cayman Islands",
+          "KZ": "Kazakhstan",
+          "LA": "Laos",
+          "LB": "Lebanon",
+          "LC": "St. Lucia",
+          "LI": "Liechtenstein",
+          "LK": "Sri Lanka",
+          "LR": "Liberia",
+          "LS": "Lesotho",
+          "LT": "Lithuania",
+          "LU": "Luxembourg",
+          "LV": "Latvia",
+          "LY": "Libya",
+          "MA": "Morocco",
+          "MC": "Monaco",
+          "MD": "Moldova",
+          "ME": "Montenegro",
+          "MF": "St. Martin",
+          "MG": "Madagascar",
+          "MH": "Marshall Islands",
+          "MK": "Macedonia",
+          "MK-alt-variant": "Macedonia (FYROM)",
+          "ML": "Mali",
+          "MM": "Myanmar (Burma)",
+          "MM-alt-short": "Myanmar",
+          "MN": "Mongolia",
+          "MO": "Macau SAR China",
+          "MO-alt-short": "Macau",
+          "MP": "Northern Mariana Islands",
+          "MQ": "Martinique",
+          "MR": "Mauritania",
+          "MS": "Montserrat",
+          "MT": "Malta",
+          "MU": "Mauritius",
+          "MV": "Maldives",
+          "MW": "Malawi",
+          "MX": "Mexico",
+          "MY": "Malaysia",
+          "MZ": "Mozambique",
+          "NA": "Namibia",
+          "NC": "New Caledonia",
+          "NE": "Niger",
+          "NF": "Norfolk Island",
+          "NG": "Nigeria",
+          "NI": "Nicaragua",
+          "NL": "Netherlands",
+          "NO": "Norway",
+          "NP": "Nepal",
+          "NR": "Nauru",
+          "NU": "Niue",
+          "NZ": "New Zealand",
+          "OM": "Oman",
+          "PA": "Panama",
+          "PE": "Peru",
+          "PF": "French Polynesia",
+          "PG": "Papua New Guinea",
+          "PH": "Philippines",
+          "PK": "Pakistan",
+          "PL": "Poland",
+          "PM": "St. Pierre & Miquelon",
+          "PN": "Pitcairn Islands",
+          "PR": "Puerto Rico",
+          "PS": "Palestinian Territories",
+          "PS-alt-short": "Palestine",
+          "PT": "Portugal",
+          "PW": "Palau",
+          "PY": "Paraguay",
+          "QA": "Qatar",
+          "QO": "Outlying Oceania",
+          "RE": "Réunion",
+          "RO": "Romania",
+          "RS": "Serbia",
+          "RU": "Russia",
+          "RW": "Rwanda",
+          "SA": "Saudi Arabia",
+          "SB": "Solomon Islands",
+          "SC": "Seychelles",
+          "SD": "Sudan",
+          "SE": "Sweden",
+          "SG": "Singapore",
+          "SH": "St. Helena",
+          "SI": "Slovenia",
+          "SJ": "Svalbard & Jan Mayen",
+          "SK": "Slovakia",
+          "SL": "Sierra Leone",
+          "SM": "San Marino",
+          "SN": "Senegal",
+          "SO": "Somalia",
+          "SR": "Suriname",
+          "SS": "South Sudan",
+          "ST": "São Tomé & Príncipe",
+          "SV": "El Salvador",
+          "SX": "Sint Maarten",
+          "SY": "Syria",
+          "SZ": "Swaziland",
+          "TA": "Tristan da Cunha",
+          "TC": "Turks & Caicos Islands",
+          "TD": "Chad",
+          "TF": "French Southern Territories",
+          "TG": "Togo",
+          "TH": "Thailand",
+          "TJ": "Tajikistan",
+          "TK": "Tokelau",
+          "TL": "Timor-Leste",
+          "TL-alt-variant": "East Timor",
+          "TM": "Turkmenistan",
+          "TN": "Tunisia",
+          "TO": "Tonga",
+          "TR": "Turkey",
+          "TT": "Trinidad & Tobago",
+          "TV": "Tuvalu",
+          "TW": "Taiwan",
+          "TZ": "Tanzania",
+          "UA": "Ukraine",
+          "UG": "Uganda",
+          "UM": "U.S. Outlying Islands",
+          "US": "United States",
+          "US-alt-short": "US",
+          "UY": "Uruguay",
+          "UZ": "Uzbekistan",
+          "VA": "Vatican City",
+          "VC": "St. Vincent & Grenadines",
+          "VE": "Venezuela",
+          "VG": "British Virgin Islands",
+          "VI": "U.S. Virgin Islands",
+          "VN": "Vietnam",
+          "VU": "Vanuatu",
+          "WF": "Wallis & Futuna",
+          "WS": "Samoa",
+          "XK": "Kosovo",
+          "YE": "Yemen",
+          "YT": "Mayotte",
+          "ZA": "South Africa",
+          "ZM": "Zambia",
+          "ZW": "Zimbabwe",
+          "ZZ": "Unknown Region"
+        }
+      }
+    }
+  }
+}

lib/composer/vendor/gettext/languages/src/cldr-data/supplemental/plurals.json

@@ -0,0 +1,844 @@
+{
+  "supplemental": {
+    "version": {
+      "_cldrVersion": "27",
+      "_number": "$Revision: 11229 $"
+    },
+    "generation": {
+      "_date": "$Date: 2015-02-18 16:11:57 +0100 (Wed, 18 Feb 2015) $"
+    },
+    "plurals-type-cardinal": {
+      "af": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ak": {
+        "pluralRule-count-one": "n = 0..1 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "am": {
+        "pluralRule-count-one": "i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ar": {
+        "pluralRule-count-zero": "n = 0 @integer 0 @decimal 0.0, 0.00, 0.000, 0.0000",
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-few": "n % 100 = 3..10 @integer 3~10, 103~110, 1003, … @decimal 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 103.0, 1003.0, …",
+        "pluralRule-count-many": "n % 100 = 11..99 @integer 11~26, 111, 1011, … @decimal 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 111.0, 1011.0, …",
+        "pluralRule-count-other": " @integer 100~102, 200~202, 300~302, 400~402, 500~502, 600, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "as": {
+        "pluralRule-count-one": "i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "asa": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ast": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "az": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "be": {
+        "pluralRule-count-one": "n % 10 = 1 and n % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 1.0, 21.0, 31.0, 41.0, 51.0, 61.0, 71.0, 81.0, 101.0, 1001.0, …",
+        "pluralRule-count-few": "n % 10 = 2..4 and n % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, … @decimal 2.0, 3.0, 4.0, 22.0, 23.0, 24.0, 32.0, 33.0, 102.0, 1002.0, …",
+        "pluralRule-count-many": "n % 10 = 0 or n % 10 = 5..9 or n % 100 = 11..14 @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-other": "   @decimal 0.1~0.9, 1.1~1.7, 10.1, 100.1, 1000.1, …"
+      },
+      "bem": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "bez": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "bg": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "bh": {
+        "pluralRule-count-one": "n = 0..1 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "bm": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "bn": {
+        "pluralRule-count-one": "i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "bo": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "br": {
+        "pluralRule-count-one": "n % 10 = 1 and n % 100 != 11,71,91 @integer 1, 21, 31, 41, 51, 61, 81, 101, 1001, … @decimal 1.0, 21.0, 31.0, 41.0, 51.0, 61.0, 81.0, 101.0, 1001.0, …",
+        "pluralRule-count-two": "n % 10 = 2 and n % 100 != 12,72,92 @integer 2, 22, 32, 42, 52, 62, 82, 102, 1002, … @decimal 2.0, 22.0, 32.0, 42.0, 52.0, 62.0, 82.0, 102.0, 1002.0, …",
+        "pluralRule-count-few": "n % 10 = 3..4,9 and n % 100 != 10..19,70..79,90..99 @integer 3, 4, 9, 23, 24, 29, 33, 34, 39, 43, 44, 49, 103, 1003, … @decimal 3.0, 4.0, 9.0, 23.0, 24.0, 29.0, 33.0, 34.0, 103.0, 1003.0, …",
+        "pluralRule-count-many": "n != 0 and n % 1000000 = 0 @integer 1000000, … @decimal 1000000.0, 1000000.00, 1000000.000, …",
+        "pluralRule-count-other": " @integer 0, 5~8, 10~20, 100, 1000, 10000, 100000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, …"
+      },
+      "brx": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "bs": {
+        "pluralRule-count-one": "v = 0 and i % 10 = 1 and i % 100 != 11 or f % 10 = 1 and f % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-few": "v = 0 and i % 10 = 2..4 and i % 100 != 12..14 or f % 10 = 2..4 and f % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, … @decimal 0.2~0.4, 1.2~1.4, 2.2~2.4, 3.2~3.4, 4.2~4.4, 5.2, 10.2, 100.2, 1000.2, …",
+        "pluralRule-count-other": " @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.5~1.0, 1.5~2.0, 2.5~2.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ca": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ce": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "cgg": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "chr": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ckb": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "cs": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-few": "i = 2..4 and v = 0 @integer 2~4",
+        "pluralRule-count-many": "v != 0   @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-other": " @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, …"
+      },
+      "cy": {
+        "pluralRule-count-zero": "n = 0 @integer 0 @decimal 0.0, 0.00, 0.000, 0.0000",
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-few": "n = 3 @integer 3 @decimal 3.0, 3.00, 3.000, 3.0000",
+        "pluralRule-count-many": "n = 6 @integer 6 @decimal 6.0, 6.00, 6.000, 6.0000",
+        "pluralRule-count-other": " @integer 4, 5, 7~20, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "da": {
+        "pluralRule-count-one": "n = 1 or t != 0 and i = 0,1 @integer 1 @decimal 0.1~1.6",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 2.0~3.4, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "de": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "dsb": {
+        "pluralRule-count-one": "v = 0 and i % 100 = 1 or f % 100 = 1 @integer 1, 101, 201, 301, 401, 501, 601, 701, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-two": "v = 0 and i % 100 = 2 or f % 100 = 2 @integer 2, 102, 202, 302, 402, 502, 602, 702, 1002, … @decimal 0.2, 1.2, 2.2, 3.2, 4.2, 5.2, 6.2, 7.2, 10.2, 100.2, 1000.2, …",
+        "pluralRule-count-few": "v = 0 and i % 100 = 3..4 or f % 100 = 3..4 @integer 3, 4, 103, 104, 203, 204, 303, 304, 403, 404, 503, 504, 603, 604, 703, 704, 1003, … @decimal 0.3, 0.4, 1.3, 1.4, 2.3, 2.4, 3.3, 3.4, 4.3, 4.4, 5.3, 5.4, 6.3, 6.4, 7.3, 7.4, 10.3, 100.3, 1000.3, …",
+        "pluralRule-count-other": " @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.5~1.0, 1.5~2.0, 2.5~2.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "dv": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "dz": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ee": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "el": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "en": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "eo": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "es": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "et": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "eu": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "fa": {
+        "pluralRule-count-one": "i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ff": {
+        "pluralRule-count-one": "i = 0,1 @integer 0, 1 @decimal 0.0~1.5",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "fi": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "fil": {
+        "pluralRule-count-one": "v = 0 and i = 1,2,3 or v = 0 and i % 10 != 4,6,9 or v != 0 and f % 10 != 4,6,9 @integer 0~3, 5, 7, 8, 10~13, 15, 17, 18, 20, 21, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.3, 0.5, 0.7, 0.8, 1.0~1.3, 1.5, 1.7, 1.8, 2.0, 2.1, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-other": " @integer 4, 6, 9, 14, 16, 19, 24, 26, 104, 1004, … @decimal 0.4, 0.6, 0.9, 1.4, 1.6, 1.9, 2.4, 2.6, 10.4, 100.4, 1000.4, …"
+      },
+      "fo": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "fr": {
+        "pluralRule-count-one": "i = 0,1 @integer 0, 1 @decimal 0.0~1.5",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "fur": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "fy": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ga": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-few": "n = 3..6 @integer 3~6 @decimal 3.0, 4.0, 5.0, 6.0, 3.00, 4.00, 5.00, 6.00, 3.000, 4.000, 5.000, 6.000, 3.0000, 4.0000, 5.0000, 6.0000",
+        "pluralRule-count-many": "n = 7..10 @integer 7~10 @decimal 7.0, 8.0, 9.0, 10.0, 7.00, 8.00, 9.00, 10.00, 7.000, 8.000, 9.000, 10.000, 7.0000, 8.0000, 9.0000, 10.0000",
+        "pluralRule-count-other": " @integer 0, 11~25, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "gd": {
+        "pluralRule-count-one": "n = 1,11 @integer 1, 11 @decimal 1.0, 11.0, 1.00, 11.00, 1.000, 11.000, 1.0000",
+        "pluralRule-count-two": "n = 2,12 @integer 2, 12 @decimal 2.0, 12.0, 2.00, 12.00, 2.000, 12.000, 2.0000",
+        "pluralRule-count-few": "n = 3..10,13..19 @integer 3~10, 13~19 @decimal 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 3.00",
+        "pluralRule-count-other": " @integer 0, 20~34, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "gl": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "gsw": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "gu": {
+        "pluralRule-count-one": "i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "guw": {
+        "pluralRule-count-one": "n = 0..1 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "gv": {
+        "pluralRule-count-one": "v = 0 and i % 10 = 1 @integer 1, 11, 21, 31, 41, 51, 61, 71, 101, 1001, …",
+        "pluralRule-count-two": "v = 0 and i % 10 = 2 @integer 2, 12, 22, 32, 42, 52, 62, 72, 102, 1002, …",
+        "pluralRule-count-few": "v = 0 and i % 100 = 0,20,40,60,80 @integer 0, 20, 40, 60, 80, 100, 120, 140, 1000, 10000, 100000, 1000000, …",
+        "pluralRule-count-many": "v != 0   @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-other": " @integer 3~10, 13~19, 23, 103, 1003, …"
+      },
+      "ha": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "haw": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "he": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-two": "i = 2 and v = 0 @integer 2",
+        "pluralRule-count-many": "v = 0 and n != 0..10 and n % 10 = 0 @integer 20, 30, 40, 50, 60, 70, 80, 90, 100, 1000, 10000, 100000, 1000000, …",
+        "pluralRule-count-other": " @integer 0, 3~17, 101, 1001, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "hi": {
+        "pluralRule-count-one": "i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "hr": {
+        "pluralRule-count-one": "v = 0 and i % 10 = 1 and i % 100 != 11 or f % 10 = 1 and f % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-few": "v = 0 and i % 10 = 2..4 and i % 100 != 12..14 or f % 10 = 2..4 and f % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, … @decimal 0.2~0.4, 1.2~1.4, 2.2~2.4, 3.2~3.4, 4.2~4.4, 5.2, 10.2, 100.2, 1000.2, …",
+        "pluralRule-count-other": " @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.5~1.0, 1.5~2.0, 2.5~2.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "hsb": {
+        "pluralRule-count-one": "v = 0 and i % 100 = 1 or f % 100 = 1 @integer 1, 101, 201, 301, 401, 501, 601, 701, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-two": "v = 0 and i % 100 = 2 or f % 100 = 2 @integer 2, 102, 202, 302, 402, 502, 602, 702, 1002, … @decimal 0.2, 1.2, 2.2, 3.2, 4.2, 5.2, 6.2, 7.2, 10.2, 100.2, 1000.2, …",
+        "pluralRule-count-few": "v = 0 and i % 100 = 3..4 or f % 100 = 3..4 @integer 3, 4, 103, 104, 203, 204, 303, 304, 403, 404, 503, 504, 603, 604, 703, 704, 1003, … @decimal 0.3, 0.4, 1.3, 1.4, 2.3, 2.4, 3.3, 3.4, 4.3, 4.4, 5.3, 5.4, 6.3, 6.4, 7.3, 7.4, 10.3, 100.3, 1000.3, …",
+        "pluralRule-count-other": " @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.5~1.0, 1.5~2.0, 2.5~2.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "hu": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "hy": {
+        "pluralRule-count-one": "i = 0,1 @integer 0, 1 @decimal 0.0~1.5",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "id": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ig": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ii": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "in": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "is": {
+        "pluralRule-count-one": "t = 0 and i % 10 = 1 and i % 100 != 11 or t != 0 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1~1.6, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "it": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "iu": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-other": " @integer 0, 3~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "iw": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-two": "i = 2 and v = 0 @integer 2",
+        "pluralRule-count-many": "v = 0 and n != 0..10 and n % 10 = 0 @integer 20, 30, 40, 50, 60, 70, 80, 90, 100, 1000, 10000, 100000, 1000000, …",
+        "pluralRule-count-other": " @integer 0, 3~17, 101, 1001, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ja": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "jbo": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "jgo": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ji": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "jmc": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "jv": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "jw": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ka": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "kab": {
+        "pluralRule-count-one": "i = 0,1 @integer 0, 1 @decimal 0.0~1.5",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "kaj": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "kcg": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "kde": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "kea": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "kk": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "kkj": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "kl": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "km": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "kn": {
+        "pluralRule-count-one": "i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ko": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ks": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ksb": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ksh": {
+        "pluralRule-count-zero": "n = 0 @integer 0 @decimal 0.0, 0.00, 0.000, 0.0000",
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ku": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "kw": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-other": " @integer 0, 3~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ky": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "lag": {
+        "pluralRule-count-zero": "n = 0 @integer 0 @decimal 0.0, 0.00, 0.000, 0.0000",
+        "pluralRule-count-one": "i = 0,1 and n != 0 @integer 1 @decimal 0.1~1.6",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "lb": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "lg": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "lkt": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ln": {
+        "pluralRule-count-one": "n = 0..1 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "lo": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "lt": {
+        "pluralRule-count-one": "n % 10 = 1 and n % 100 != 11..19 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 1.0, 21.0, 31.0, 41.0, 51.0, 61.0, 71.0, 81.0, 101.0, 1001.0, …",
+        "pluralRule-count-few": "n % 10 = 2..9 and n % 100 != 11..19 @integer 2~9, 22~29, 102, 1002, … @decimal 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 22.0, 102.0, 1002.0, …",
+        "pluralRule-count-many": "f != 0   @decimal 0.1~0.9, 1.1~1.7, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-other": " @integer 0, 10~20, 30, 40, 50, 60, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "lv": {
+        "pluralRule-count-zero": "n % 10 = 0 or n % 100 = 11..19 or v = 2 and f % 100 = 11..19 @integer 0, 10~20, 30, 40, 50, 60, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-one": "n % 10 = 1 and n % 100 != 11 or v = 2 and f % 10 = 1 and f % 100 != 11 or v != 2 and f % 10 = 1 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1, 1.0, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-other": " @integer 2~9, 22~29, 102, 1002, … @decimal 0.2~0.9, 1.2~1.9, 10.2, 100.2, 1000.2, …"
+      },
+      "mas": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "mg": {
+        "pluralRule-count-one": "n = 0..1 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "mgo": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "mk": {
+        "pluralRule-count-one": "v = 0 and i % 10 = 1 or f % 10 = 1 @integer 1, 11, 21, 31, 41, 51, 61, 71, 101, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-other": " @integer 0, 2~10, 12~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.2~1.0, 1.2~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ml": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "mn": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "mo": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-few": "v != 0 or n = 0 or n != 1 and n % 100 = 1..19 @integer 0, 2~16, 101, 1001, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-other": " @integer 20~35, 100, 1000, 10000, 100000, 1000000, …"
+      },
+      "mr": {
+        "pluralRule-count-one": "i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ms": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "mt": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-few": "n = 0 or n % 100 = 2..10 @integer 0, 2~10, 102~107, 1002, … @decimal 0.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 10.0, 102.0, 1002.0, …",
+        "pluralRule-count-many": "n % 100 = 11..19 @integer 11~19, 111~117, 1011, … @decimal 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 111.0, 1011.0, …",
+        "pluralRule-count-other": " @integer 20~35, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "my": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "nah": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "naq": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-other": " @integer 0, 3~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "nb": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "nd": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ne": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "nl": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "nn": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "nnh": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "no": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "nqo": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "nr": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "nso": {
+        "pluralRule-count-one": "n = 0..1 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ny": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "nyn": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "om": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "or": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "os": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "pa": {
+        "pluralRule-count-one": "n = 0..1 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "pap": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "pl": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-few": "v = 0 and i % 10 = 2..4 and i % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, …",
+        "pluralRule-count-many": "v = 0 and i != 1 and i % 10 = 0..1 or v = 0 and i % 10 = 5..9 or v = 0 and i % 100 = 12..14 @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, …",
+        "pluralRule-count-other": "   @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "prg": {
+        "pluralRule-count-zero": "n % 10 = 0 or n % 100 = 11..19 or v = 2 and f % 100 = 11..19 @integer 0, 10~20, 30, 40, 50, 60, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-one": "n % 10 = 1 and n % 100 != 11 or v = 2 and f % 10 = 1 and f % 100 != 11 or v != 2 and f % 10 = 1 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1, 1.0, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-other": " @integer 2~9, 22~29, 102, 1002, … @decimal 0.2~0.9, 1.2~1.9, 10.2, 100.2, 1000.2, …"
+      },
+      "ps": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "pt": {
+        "pluralRule-count-one": "n = 0..2 and n != 2 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "pt-PT": {
+        "pluralRule-count-one": "n = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "rm": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ro": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-few": "v != 0 or n = 0 or n != 1 and n % 100 = 1..19 @integer 0, 2~16, 101, 1001, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-other": " @integer 20~35, 100, 1000, 10000, 100000, 1000000, …"
+      },
+      "rof": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "root": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ru": {
+        "pluralRule-count-one": "v = 0 and i % 10 = 1 and i % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, …",
+        "pluralRule-count-few": "v = 0 and i % 10 = 2..4 and i % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, …",
+        "pluralRule-count-many": "v = 0 and i % 10 = 0 or v = 0 and i % 10 = 5..9 or v = 0 and i % 100 = 11..14 @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, …",
+        "pluralRule-count-other": "   @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "rwk": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "sah": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "saq": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "se": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-other": " @integer 0, 3~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "seh": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ses": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "sg": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "sh": {
+        "pluralRule-count-one": "v = 0 and i % 10 = 1 and i % 100 != 11 or f % 10 = 1 and f % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-few": "v = 0 and i % 10 = 2..4 and i % 100 != 12..14 or f % 10 = 2..4 and f % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, … @decimal 0.2~0.4, 1.2~1.4, 2.2~2.4, 3.2~3.4, 4.2~4.4, 5.2, 10.2, 100.2, 1000.2, …",
+        "pluralRule-count-other": " @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.5~1.0, 1.5~2.0, 2.5~2.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "shi": {
+        "pluralRule-count-one": "i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04",
+        "pluralRule-count-few": "n = 2..10 @integer 2~10 @decimal 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 2.00, 3.00, 4.00, 5.00, 6.00, 7.00, 8.00",
+        "pluralRule-count-other": " @integer 11~26, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~1.9, 2.1~2.7, 10.1, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "si": {
+        "pluralRule-count-one": "n = 0,1 or i = 0 and f = 1 @integer 0, 1 @decimal 0.0, 0.1, 1.0, 0.00, 0.01, 1.00, 0.000, 0.001, 1.000, 0.0000, 0.0001, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.2~0.9, 1.1~1.8, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "sk": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-few": "i = 2..4 and v = 0 @integer 2~4",
+        "pluralRule-count-many": "v != 0   @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-other": " @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, …"
+      },
+      "sl": {
+        "pluralRule-count-one": "v = 0 and i % 100 = 1 @integer 1, 101, 201, 301, 401, 501, 601, 701, 1001, …",
+        "pluralRule-count-two": "v = 0 and i % 100 = 2 @integer 2, 102, 202, 302, 402, 502, 602, 702, 1002, …",
+        "pluralRule-count-few": "v = 0 and i % 100 = 3..4 or v != 0 @integer 3, 4, 103, 104, 203, 204, 303, 304, 403, 404, 503, 504, 603, 604, 703, 704, 1003, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-other": " @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, …"
+      },
+      "sma": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-other": " @integer 0, 3~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "smi": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-other": " @integer 0, 3~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "smj": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-other": " @integer 0, 3~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "smn": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-other": " @integer 0, 3~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "sms": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-two": "n = 2 @integer 2 @decimal 2.0, 2.00, 2.000, 2.0000",
+        "pluralRule-count-other": " @integer 0, 3~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "sn": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "so": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "sq": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "sr": {
+        "pluralRule-count-one": "v = 0 and i % 10 = 1 and i % 100 != 11 or f % 10 = 1 and f % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, … @decimal 0.1, 1.1, 2.1, 3.1, 4.1, 5.1, 6.1, 7.1, 10.1, 100.1, 1000.1, …",
+        "pluralRule-count-few": "v = 0 and i % 10 = 2..4 and i % 100 != 12..14 or f % 10 = 2..4 and f % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, … @decimal 0.2~0.4, 1.2~1.4, 2.2~2.4, 3.2~3.4, 4.2~4.4, 5.2, 10.2, 100.2, 1000.2, …",
+        "pluralRule-count-other": " @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0, 0.5~1.0, 1.5~2.0, 2.5~2.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ss": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ssy": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "st": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "sv": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "sw": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "syr": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ta": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "te": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "teo": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "th": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ti": {
+        "pluralRule-count-one": "n = 0..1 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "tig": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "tk": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "tl": {
+        "pluralRule-count-one": "v = 0 and i = 1,2,3 or v = 0 and i % 10 != 4,6,9 or v != 0 and f % 10 != 4,6,9 @integer 0~3, 5, 7, 8, 10~13, 15, 17, 18, 20, 21, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.3, 0.5, 0.7, 0.8, 1.0~1.3, 1.5, 1.7, 1.8, 2.0, 2.1, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …",
+        "pluralRule-count-other": " @integer 4, 6, 9, 14, 16, 19, 24, 26, 104, 1004, … @decimal 0.4, 0.6, 0.9, 1.4, 1.6, 1.9, 2.4, 2.6, 10.4, 100.4, 1000.4, …"
+      },
+      "tn": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "to": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "tr": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ts": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "tzm": {
+        "pluralRule-count-one": "n = 0..1 or n = 11..99 @integer 0, 1, 11~24 @decimal 0.0, 1.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0",
+        "pluralRule-count-other": " @integer 2~10, 100~106, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ug": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "uk": {
+        "pluralRule-count-one": "v = 0 and i % 10 = 1 and i % 100 != 11 @integer 1, 21, 31, 41, 51, 61, 71, 81, 101, 1001, …",
+        "pluralRule-count-few": "v = 0 and i % 10 = 2..4 and i % 100 != 12..14 @integer 2~4, 22~24, 32~34, 42~44, 52~54, 62, 102, 1002, …",
+        "pluralRule-count-many": "v = 0 and i % 10 = 0 or v = 0 and i % 10 = 5..9 or v = 0 and i % 100 = 11..14 @integer 0, 5~19, 100, 1000, 10000, 100000, 1000000, …",
+        "pluralRule-count-other": "   @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ur": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "uz": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "ve": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "vi": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "vo": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "vun": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "wa": {
+        "pluralRule-count-one": "n = 0..1 @integer 0, 1 @decimal 0.0, 1.0, 0.00, 1.00, 0.000, 1.000, 0.0000, 1.0000",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 0.1~0.9, 1.1~1.7, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "wae": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "wo": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "xh": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "xog": {
+        "pluralRule-count-one": "n = 1 @integer 1 @decimal 1.0, 1.00, 1.000, 1.0000",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~0.9, 1.1~1.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "yi": {
+        "pluralRule-count-one": "i = 1 and v = 0 @integer 1",
+        "pluralRule-count-other": " @integer 0, 2~16, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "yo": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "zh": {
+        "pluralRule-count-other": " @integer 0~15, 100, 1000, 10000, 100000, 1000000, … @decimal 0.0~1.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      },
+      "zu": {
+        "pluralRule-count-one": "i = 0 or n = 1 @integer 0, 1 @decimal 0.0~1.0, 0.00~0.04",
+        "pluralRule-count-other": " @integer 2~17, 100, 1000, 10000, 100000, 1000000, … @decimal 1.1~2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …"
+      }
+    }
+  }
+}